Discord Bot

x-tierzero-discord-key: <32-char-hex-api-key>

{
  "idempotency_key": "49c3e8c1-df6d-4caf-b7c7-f9236f6b5954",
  "sent_at": "2025-07-02T18:41:11Z",
  "event": "bot_mentioned",
  "version": "1.0",
  "data": {
    // Event-specific payload
  }
}

{
  "event": "server_joined",
  "data": {
    "server": {
      "id": "1111222233334444",
      "name": "Engineering Team",
      "icon_url": "https://cdn.discordapp.com/icons/...",
      "owner_id": "9999000011112222"
    }
  }
}

{
  "event": "bot_mentioned",
  "data": {
    "message": {
      "id": "123456789012345678",
      "server_id": "1111222233334444",
      "channel_id": "5555666677778888",
      "author": {
        "id": "9999000011112222",
        "username": "alice",
        "global_name": "Alice Chen",
        "bot": false
      },
      "body": "@tierzero-bot can you check latency?",
      "timestamp": "2025-07-02T19:01:57Z",
      "mentions_bot": true
    }
  }
}

{
  "event": "reaction_added",
  "data": {
    "message_id": "123456789012345678",
    "user": { /* User object */ },
    "reaction": {
      "emoji": { "id": null, "name": "👍" }
    }
  }
}

{
  "event": "server_left",
  "data": {
    "server_id": "1111222233334444"
  }
}

import { Client, GatewayIntentBits, Message, Guild, MessageReaction, User } from 'discord.js';
import express from 'express';
import { v4 as uuidv4 } from 'uuid';

interface TierZeroWebhookEnvelope {
  idempotency_key: string;
  sent_at: string;
  event: string;
  version: string;
  data: any;
}

class TierZeroBot {
  private client: Client;
  private tierZeroApiKey: string;
  private tierZeroBaseUrl: string = 'https://api.tierzero.ai';
  private app: express.Application;

  constructor(discordToken: string, tierZeroApiKey: string, port: number = 3000) {
    this.tierZeroApiKey = tierZeroApiKey;
    
    // Initialize Discord client
    this.client = new Client({
      intents: [
        GatewayIntentBits.Guilds,
        GatewayIntentBits.GuildMessages,
        GatewayIntentBits.MessageContent,
        GatewayIntentBits.GuildMessageReactions
      ]
    });

    // Initialize Express server for webhooks
    this.app = express();
    this.app.use(express.json());
    this.setupWebhookRoutes();
    this.setupDiscordEvents();

    this.client.login(discordToken);
    this.app.listen(port, () => {
      console.log(`TierZero Discord bot webhook server running on port ${port}`);
    });
  }

  private async sendToTierZero(event: string, data: any): Promise<void> {
    const payload: TierZeroWebhookEnvelope = {
      idempotency_key: uuidv4(),
      sent_at: new Date().toISOString(),
      event,
      version: '1.0',
      data
    };

    try {
      const response = await fetch(`${this.tierZeroBaseUrl}/discord/webhooks/${event}`, {
        method: 'POST',
        headers: {
          'x-tierzero-discord-key': this.tierZeroApiKey,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(payload)
      });

      if (!response.ok) {
        console.error(`TierZero API error: ${response.status}`);
      }
    } catch (error) {
      console.error('Failed to send event to TierZero:', error);
    }
  }

  private setupDiscordEvents(): void {
    this.client.on('guildCreate', async (guild: Guild) => {
      const serverData = {
        id: guild.id,
        name: guild.name,
        icon_url: guild.iconURL(),
        owner_id: guild.ownerId
      };
      
      await this.sendToTierZero('server_joined', { server: serverData });
    });

    this.client.on('messageCreate', async (message: Message) => {
      if (message.author.bot) return;
      
      if (message.mentions.has(this.client.user!)) {
        const messageData = {
          id: message.id,
          server_id: message.guild?.id || null,
          channel_id: message.channel.id,
          thread_id: message.channel.isThread() ? message.channel.id : null,
          author: {
            id: message.author.id,
            username: message.author.username,
            global_name: message.author.globalName,
            avatar_url: message.author.avatarURL(),
            bot: message.author.bot
          },
          body: message.content,
          embeds: message.embeds,
          attachments: message.attachments.map(a => ({ url: a.url, name: a.name })),
          reactions: [],
          timestamp: message.createdAt.toISOString(),
          edited_timestamp: message.editedAt?.toISOString() || null,
          mentions_bot: true
        };
        
        await this.sendToTierZero('bot_mentioned', { message: messageData });
      }
    });

    this.client.on('messageReactionAdd', async (reaction: MessageReaction, user: User) => {
      if (user.bot) return;
      
      const reactionData = {
        message_id: reaction.message.id,
        channel_id: reaction.message.channel.id,
        thread_id: reaction.message.channel.isThread() ? reaction.message.channel.id : null,
        user: {
          id: user.id,
          username: user.username,
          global_name: user.globalName,
          avatar_url: user.avatarURL(),
          bot: user.bot
        },
        reaction: {
          emoji: {
            id: reaction.emoji.id,
            name: reaction.emoji.name
          },
          count: reaction.count,
          me: reaction.users.cache.has(this.client.user!.id)
        }
      };
      
      await this.sendToTierZero('reaction_added', reactionData);
    });
  }

  private setupWebhookRoutes(): void {
    // Middleware to verify TierZero API key
    const verifyApiKey = (req: express.Request, res: express.Response, next: express.NextFunction) => {
      const apiKey = req.headers['x-tierzero-discord-key'];
      if (apiKey !== this.tierZeroApiKey) {
        return res.status(401).json({ error: 'UNAUTHORIZED', details: 'Invalid API key' });
      }
      next();
    };

    this.app.use('/webhooks', verifyApiKey);

    // Send message endpoint
    this.app.post('/webhooks/send_message', async (req, res) => {
      try {
        const { channel_id, thread_id, body, embeds, components } = req.body.data;
        const targetId = thread_id || channel_id;
        
        const channel = await this.client.channels.fetch(targetId);
        if (!channel?.isTextBased()) {
          return res.status(404).json({ error: 'NOT_FOUND', details: 'Channel not found' });
        }

        const message = await channel.send({
          content: body,
          embeds: embeds || [],
          components: components || []
        });

        res.json({
          status: 'OK',
          message: {
            id: message.id,
            timestamp: message.createdAt.toISOString()
          }
        });
      } catch (error) {
        res.status(500).json({ error: 'INTERNAL_ERROR', details: 'Failed to send message' });
      }
    });

    // Add reaction endpoint
    this.app.post('/webhooks/add_reaction', async (req, res) => {
      try {
        const { message_id, channel_id, emoji } = req.body.data;
        
        const channel = await this.client.channels.fetch(channel_id);
        if (!channel?.isTextBased()) {
          return res.status(404).json({ error: 'NOT_FOUND', details: 'Channel not found' });
        }

        const message = await channel.messages.fetch(message_id);
        await message.react(emoji.id ? `${emoji.name}:${emoji.id}` : emoji.name);

        res.json({ status: 'OK' });
      } catch (error) {
        res.status(500).json({ error: 'INTERNAL_ERROR', details: 'Failed to add reaction' });
      }
    });
  }
}

// Usage
const bot = new TierZeroBot(
  process.env.DISCORD_TOKEN!,
  process.env.TIERZERO_API_KEY!,
  3000
);