@gamalan/pi-gateway 1.0.0

package/src/adapters/discord.ts

@@ -0,0 +1,270 @@
+/**
+ * Discord Adapter - Hermes-style Discord platform adapter
+ * 
+ * Features:
+ * - DM and guild channel support
+ * - Slash command registration
+ * - Typing indicators
+ * - Message editing/deletion
+ * - Rate limit handling
+ */
+
+import { BaseAdapter, type PlatformMessage, type PlatformConfig } from "./base.js";
+import { logger } from "../logger.js";
+
+export interface DiscordConfig extends PlatformConfig {
+  platform: "discord";
+  botToken: string;
+  guildId?: string;
+  allowedChannels?: string[];  // Whitelist specific channels
+  allowedRoles?: string[];     // Whitelist roles
+  requireMention?: boolean;    // Require @mention in guilds
+}
+
+export class DiscordAdapter extends BaseAdapter {
+  readonly platform = "discord" as const;
+  config: DiscordConfig;
+  private httpClient: typeof fetch | null = null;
+  private wsConnection: WebSocket | null = null;
+  private heartbeatInterval: ReturnType<typeof setInterval> | null = null;
+  private sequence: number | null = null;
+  private sessionId: string | null = null;
+  private intents: number = 0;
+
+  constructor(config: DiscordConfig) {
+    super();
+    this.config = config;
+    
+    // Intents: GUILD_MESSAGES (1<<9) + DIRECT_MESSAGES (1<<12) + MESSAGE_CONTENT (1<<15)
+    this.intents = 1 << 9 | 1 << 12 | 1 << 15;
+  }
+
+  async initialize(): Promise<void> {
+    // Test bot token
+    const response = await this.apiRequest("/users/@me");
+    const data: any = await response.json();
+    if (!response.ok) {
+      throw new Error(`Discord authentication failed: ${response.status}`);
+    }
+    logger.info(`[Discord] Bot initialized: ${data.username}`);
+  }
+
+  private async apiRequest(endpoint: string, options: RequestInit = {}): Promise<Response> {
+    const url = `https://discord.com/api/v10${endpoint}`;
+    return fetch(url, {
+      ...options,
+      headers: {
+        "Authorization": `Bot ${this.config.botToken}`,
+        "Content-Type": "application/json",
+        ...options.headers,
+      },
+    });
+  }
+
+  async start(callbacks): Promise<void> {
+    await super.start(callbacks);
+
+    // Connect to Gateway
+    const gatewayResponse = await this.apiRequest("/gateway");
+    const gatewayData = (await gatewayResponse.json()) as { url: string };
+    const gatewayUrl = `${gatewayData.url}?v=10&encoding=json&intents=${this.intents}`;
+
+    this.wsConnection = new WebSocket(gatewayUrl);
+
+    this.wsConnection.onopen = () => {
+      logger.info("[Discord] WebSocket connected");
+    };
+
+    this.wsConnection.onmessage = async (event) => {
+      const data: any = JSON.parse(event.data);
+      await this.handleGatewayMessage(data);
+    };
+
+    this.wsConnection.onclose = () => {
+      logger.info("[Discord] WebSocket closed");
+      this.callbacks?.onDisconnect?.();
+      // Attempt reconnect after 5 seconds
+      setTimeout(() => this.start(callbacks), 5000);
+    };
+  }
+
+  private async handleGatewayMessage(data: any): Promise<void> {
+    switch (data.op) {
+      case 0: // Dispatch
+        this.sequence = data.s;
+        await this.handleDispatch(data.t, data.d);
+        break;
+        
+      case 10: // Hello
+        this.startHeartbeat(data.d.heartbeat_interval);
+        this.identify();
+        break;
+        
+      case 11: // Heartbeat ACK
+        // Heartbeat acknowledged
+        break;
+    }
+  }
+
+  private startHeartbeat(interval: number): void {
+    this.heartbeatInterval = setInterval(() => {
+      if (this.wsConnection?.readyState === WebSocket.OPEN) {
+        this.wsConnection.send(JSON.stringify({
+          op: 1,
+          d: this.sequence,
+        }));
+      }
+    }, interval);
+  }
+
+  private async identify(): Promise<void> {
+    const identifyPayload = {
+      op: 2,
+      d: {
+        token: this.config.botToken,
+        intents: this.intents,
+        properties: {
+          os: "linux",
+          browser: "pi-gateway",
+          device: "pi-gateway",
+        },
+      },
+    };
+    
+    this.wsConnection?.send(JSON.stringify(identifyPayload));
+  }
+
+  private async handleDispatch(type: string, data: any): Promise<void> {
+    switch (type) {
+      case "READY":
+        this.sessionId = data.session_id;
+        logger.info(`[Discord] Logged in as ${data.user.username}`);
+        break;
+
+      case "MESSAGE_CREATE":
+        await this.handleMessage(data);
+        break;
+
+      case "MESSAGE_UPDATE":
+        // Handle edits if needed
+        break;
+    }
+  }
+
+  private async handleMessage(data: any): Promise<void> {
+    // Ignore bots
+    if (data.author.bot && data.author.id !== this.getBotId()) return;
+    
+    // Check if DM or allowed channel
+    const isDM = !data.guild_id;
+    if (!isDM && this.config.allowedChannels?.length) {
+      if (!this.config.allowedChannels.includes(data.channel_id)) return;
+    }
+
+    // Check mention requirement in guilds
+    if (!isDM && this.config.requireMention) {
+      const mentioned = data.content.includes(`<@${this.getBotId()}>`);
+      if (!mentioned) return;
+    }
+
+    const message: PlatformMessage = {
+      id: data.id,
+      platform: this.platform,
+      channelId: data.channel_id,
+      userId: data.author.id,
+      content: data.content,
+      timestamp: new Date(data.timestamp).getTime(),
+      metadata: {
+        guildId: data.guild_id,
+        username: data.author.username,
+        discriminator: data.author.discriminator,
+        isDM,
+      },
+    };
+
+    await this.callbacks?.onMessage(message);
+  }
+
+  private getBotId(): string {
+    // Extract from token - this is approximate
+    return this.config.botToken.split(".")[0];
+  }
+
+  async sendMessage(channelId: string, content: string): Promise<string> {
+    const response = await this.apiRequest(`/channels/${channelId}/messages`, {
+      method: "POST",
+      body: JSON.stringify({ content }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Failed to send message: ${error}`);
+    }
+
+    const data = (await response.json()) as { id: string };
+    return data.id;
+  }
+
+  async editMessage(channelId: string, messageId: string, content: string): Promise<void> {
+    await this.apiRequest(`/channels/${channelId}/messages/${messageId}`, {
+      method: "PATCH",
+      body: JSON.stringify({ content }),
+    });
+  }
+
+  async deleteMessage(channelId: string, messageId: string): Promise<void> {
+    await this.apiRequest(`/channels/${channelId}/messages/${messageId}`, {
+      method: "DELETE",
+    });
+  }
+
+  async setTyping(channelId: string, isTyping: boolean): Promise<void> {
+    if (!isTyping) return; // Discord doesn't have a "stop typing" API
+    
+    await this.apiRequest(`/channels/${channelId}/typing`, {
+      method: "POST",
+    });
+  }
+
+  async getStatus(): Promise<{ connected: boolean; latency?: number }> {
+    try {
+      const response = await this.apiRequest("/gateway/bot");
+      const data: any = await response.json();
+      return {
+        connected: true,
+        latency: data.session_start_limit?.remaining ?? undefined,
+      };
+    } catch {
+      return { connected: false };
+    }
+  }
+
+  async stop(): Promise<void> {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+    }
+    if (this.wsConnection) {
+      this.wsConnection.close();
+    }
+    await super.stop();
+  }
+
+  // Helper to register slash commands
+  async registerSlashCommands(commands: Array<{
+    name: string;
+    description: string;
+    options?: any[];
+  }>): Promise<void> {
+    if (!this.config.guildId) {
+      logger.warn("[Discord] guildId required for slash commands");
+      return;
+    }
+
+    await this.apiRequest(`/applications/${this.getBotId()}/guilds/${this.config.guildId}/commands`, {
+      method: "PUT",
+      body: JSON.stringify(commands),
+    });
+    
+    logger.info(`[Discord] Registered ${commands.length} slash commands`);
+  }
+}

package/src/adapters/index.ts

@@ -0,0 +1,13 @@
+export { BaseAdapter, type PlatformMessage, type PlatformConfig, type AdapterCallbacks, type PlatformAdapter } from "./base.js";
+export { DiscordAdapter } from "./discord.js";
+export type { DiscordConfig } from "./discord.js";
+export { TwitchAdapter } from "./twitch.js";
+export type { TwitchConfig } from "./twitch.js";
+export { TelegramAdapter } from "./telegram.js";
+export type { TelegramConfig } from "./telegram.js";
+export { SlackAdapter } from "./slack.js";
+export type { SlackConfig } from "./slack.js";
+export { WhatsAppAdapter } from "./whatsapp.js";
+export type { WhatsAppConfig } from "./whatsapp.js";
+export { WebSocketAdapter } from "./websocket.js";
+export type { WebSocketConfig } from "./websocket.js";

package/src/adapters/slack.ts

@@ -0,0 +1,313 @@
+/**
+ * Slack Adapter - Hermes-style Slack platform adapter
+ * 
+ * Features:
+ * - Incoming webhooks (outbound only)
+ * - Web API (with bot token)
+ * - Slash command support
+ * - Block Kit support
+ */
+
+import { BaseAdapter, type PlatformMessage, type PlatformConfig } from "./base.js";
+import { logger } from "../logger.js";
+
+export interface SlackConfig extends PlatformConfig {
+  platform: "slack";
+  webhookUrl?: string;
+  botToken?: string;
+  signingSecret?: string;
+  teamId?: string;
+  defaultChannel?: string;
+}
+
+interface SlackMessage {
+  type: string;
+  channel?: string;
+  user?: string;
+  username?: string;
+  text: string;
+  ts: string;
+  thread_ts?: string;
+}
+
+export class SlackAdapter extends BaseAdapter {
+  readonly platform = "slack" as const;
+  config: SlackConfig;
+  
+  private connected = false;
+
+  constructor(config: SlackConfig) {
+    super();
+    this.config = {
+      enabled: true,
+      platform: "slack",
+      ...config,
+    };
+  }
+
+  async initialize(): Promise<void> {
+    if (this.config.botToken) {
+      // Test bot token
+      const response = await this.apiRequest("auth.test", { method: "POST" });
+      const data = await response.json() as { ok: boolean; team_id?: string };
+      
+      if (!data.ok) {
+        throw new Error(`Slack auth failed: ${data}`);
+      }
+      
+      logger.info(`[Slack] Bot initialized for team: ${data.team_id}`);
+    } else if (this.config.webhookUrl) {
+      logger.info("[Slack] Using webhook mode (outbound only)");
+    } else {
+      throw new Error("Slack requires either botToken or webhookUrl");
+    }
+  }
+
+  private async apiRequest(endpoint: string, options: RequestInit = {}): Promise<Response> {
+    const url = `https://slack.com/api/${endpoint}`;
+    return fetch(url, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.config.botToken}`,
+        ...options.headers,
+      },
+    });
+  }
+
+  async start(callbacks): Promise<void> {
+    await super.start(callbacks);
+    this.connected = true;
+    
+    if (!this.config.botToken && !this.config.webhookUrl) {
+      logger.warn("[Slack] No credentials configured - adapter is outbound-only");
+    }
+  }
+
+  async stop(): Promise<void> {
+    this.connected = false;
+    await super.stop();
+  }
+
+  async sendMessage(channelId: string, content: string): Promise<string> {
+    // Try webhook first if available
+    if (this.config.webhookUrl) {
+      const payload = {
+        text: content,
+        ...(channelId && channelId.startsWith("#") ? { channel: channelId } : {}),
+      };
+
+      const response = await fetch(this.config.webhookUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+      });
+
+      if (!response.ok) {
+        throw new Error(`Slack webhook failed: ${response.status}`);
+      }
+
+      return `webhook-${Date.now()}`;
+    }
+
+    // Use Web API if we have a bot token
+    if (this.config.botToken) {
+      const response = await this.apiRequest("chat.postMessage", {
+        method: "POST",
+        body: JSON.stringify({
+          channel: channelId,
+          text: content,
+        }),
+      });
+
+      const data = await response.json() as { ok: boolean; ts?: string; error?: string };
+
+      if (!data.ok) {
+        throw new Error(`Slack API error: ${data.error}`);
+      }
+
+      return data.ts || String(Date.now());
+    }
+
+    throw new Error("No Slack credentials configured");
+  }
+
+  async postMessage(channelId: string, content: string, blocks?: any[]): Promise<string> {
+    if (!this.config.botToken) {
+      throw new Error("Bot token required for rich messages");
+    }
+
+    const body: Record<string, any> = {
+      channel: channelId,
+      text: content,
+    };
+
+    if (blocks) {
+      body.blocks = blocks;
+    }
+
+    const response = await this.apiRequest("chat.postMessage", {
+      method: "POST",
+      body: JSON.stringify(body),
+    });
+
+    const data = await response.json() as { ok: boolean; ts?: string; error?: string };
+
+    if (!data.ok) {
+      throw new Error(`Slack API error: ${data.error}`);
+    }
+
+    return data.ts || String(Date.now());
+  }
+
+  async replyToThread(channelId: string, threadTs: string, content: string): Promise<string> {
+    if (!this.config.botToken) {
+      throw new Error("Bot token required for threaded replies");
+    }
+
+    const response = await this.apiRequest("chat.postMessage", {
+      method: "POST",
+      body: JSON.stringify({
+        channel: channelId,
+        text: content,
+        thread_ts: threadTs,
+      }),
+    });
+
+    const data = await response.json() as { ok: boolean; ts?: string; error?: string };
+
+    if (!data.ok) {
+      throw new Error(`Slack API error: ${data.error}`);
+    }
+
+    return data.ts || String(Date.now());
+  }
+
+  async editMessage(channelId: string, messageTs: string, content: string): Promise<void> {
+    if (!this.config.botToken) {
+      throw new Error("Bot token required for editing");
+    }
+
+    await this.apiRequest("chat.update", {
+      method: "POST",
+      body: JSON.stringify({
+        channel: channelId,
+        ts: messageTs,
+        text: content,
+      }),
+    });
+  }
+
+  async deleteMessage(channelId: string, messageTs: string): Promise<void> {
+    if (!this.config.botToken) {
+      throw new Error("Bot token required for deletion");
+    }
+
+    await this.apiRequest("chat.delete", {
+      method: "POST",
+      body: JSON.stringify({
+        channel: channelId,
+        ts: messageTs,
+      }),
+    });
+  }
+
+  async setTyping(channelId: string, isTyping: boolean): Promise<void> {
+    if (!this.config.botToken) return;
+
+    await this.apiRequest("chat.postEphemeral", {
+      method: "POST",
+      body: JSON.stringify({
+        channel: channelId,
+        text: isTyping ? "_typing_" : "",
+      }),
+    });
+  }
+
+  async getChannelInfo(channelId: string): Promise<{
+    id: string;
+    name: string;
+    numMembers: number;
+    topic: string;
+  } | null> {
+    if (!this.config.botToken) {
+      throw new Error("Bot token required");
+    }
+
+    const response = await this.apiRequest("conversations.info", {
+      method: "POST",
+      body: JSON.stringify({ channel: channelId }),
+    });
+
+    const data = await response.json() as { 
+      ok: boolean; 
+      channel?: { 
+        id: string; 
+        name: string; 
+        num_members: number; 
+        topic?: { value: string };
+      };
+    };
+
+    if (!data.ok || !data.channel) {
+      return null;
+    }
+
+    return {
+      id: data.channel.id,
+      name: data.channel.name,
+      numMembers: data.channel.num_members,
+      topic: data.channel.topic?.value || "",
+    };
+  }
+
+  async listChannels(): Promise<Array<{ id: string; name: string }>> {
+    if (!this.config.botToken) {
+      throw new Error("Bot token required");
+    }
+
+    const response = await this.apiRequest("conversations.list", {
+      method: "POST",
+      body: JSON.stringify({ types: "public_channel,private_channel" }),
+    });
+
+    const data = await response.json() as { 
+      ok: boolean; 
+      channels?: Array<{ id: string; name: string }>;
+    };
+
+    if (!data.ok) {
+      return [];
+    }
+
+    return (data.channels || []).map(c => ({ id: c.id, name: c.name }));
+  }
+
+  async getStatus(): Promise<{ connected: boolean; latency?: number }> {
+    return { 
+      connected: this.connected,
+      ...(this.config.botToken ? { mode: "api" } : { mode: "webhook" })
+    };
+  }
+
+  // Handle incoming events (for WebSocket or Socket Mode)
+  async handleIncomingEvent(event: any): Promise<void> {
+    if (event.type === "message" && !event.subtype) {
+      const message: PlatformMessage = {
+        id: this.generateMessageId(),
+        platform: "slack",
+        channelId: event.channel,
+        userId: event.user,
+        content: event.text,
+        timestamp: parseFloat(event.ts) * 1000,
+        metadata: {
+          team: event.team,
+          threadTs: event.thread_ts,
+          username: event.username,
+        },
+      };
+
+      this.emitMessage(message);
+    }
+  }
+}