@ebowwa/daemons 0.5.0

package/src/channels/discord.ts

@@ -0,0 +1,306 @@
+/**
+ * Discord Channel Adapter
+ *
+ * Implements ChannelConnector from @ebowwa/channel-types.
+ * Discord bot using discord.js.
+ */
+
+import { Client, GatewayIntentBits, type Message, type TextChannel } from "discord.js";
+import {
+  type ChannelId,
+  type ChannelMessage,
+  type ChannelResponse,
+  type ChannelCapabilities,
+  type MessageSender,
+  type MessageContext,
+  createChannelId,
+} from "@ebowwa/channel-types";
+import {
+  BaseChannel,
+  type GLMChannelConfig,
+  type BaseChannelConfig,
+} from "./base.js";
+
+// ============================================================
+// DISCORD CHANNEL CONFIG
+// ============================================================
+
+export interface DiscordChannelConfig extends GLMChannelConfig {
+  platform: "discord";
+  /** Bot token */
+  botToken: string;
+  /** Application ID for slash commands */
+  applicationId?: string;
+  /** Guild ID to restrict to */
+  guildId?: string;
+  /** Channel IDs to listen to (empty = all) */
+  channelIds?: string[];
+  /** Enable slash commands */
+  enableSlashCommands?: boolean;
+}
+
+// Legacy type alias for backwards compat
+export type { DiscordChannelConfig as DiscordConfig };
+
+// ============================================================
+// DISCORD CHANNEL
+// ============================================================
+
+export class DiscordChannel extends BaseChannel {
+  readonly id: ChannelId;
+  readonly label = "Discord";
+  readonly capabilities: ChannelCapabilities = {
+    supports: {
+      text: true,
+      media: true,
+      replies: true,
+      threads: true,
+      reactions: true,
+      editing: true,
+      streaming: false, // Discord doesn't support true streaming
+    },
+    media: {
+      maxFileSize: 25 * 1024 * 1024, // 25MB (nitro is higher)
+      supportedMimeTypes: ["image/*", "video/*", "audio/*", "application/*"],
+    },
+    rateLimits: {
+      messagesPerMinute: 50,
+      charactersPerMessage: 2000,
+    },
+  };
+
+  private client: Client;
+  private token: string;
+  private guildId?: string;
+  private channelIds?: string[];
+
+  constructor(config: DiscordChannelConfig) {
+    super(config);
+    this.token = config.botToken;
+    this.guildId = config.guildId;
+    this.channelIds = config.channelIds;
+    this.id = this.createId();
+    this.client = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.MessageContent,
+      ],
+    });
+  }
+
+  // ============================================================
+  // ChannelConnector Implementation
+  // ============================================================
+
+  /**
+   * Send response to Discord
+   */
+  async send(response: ChannelResponse): Promise<void> {
+    const { channelId, messageId } = response.replyTo;
+
+    try {
+      const channel = await this.client.channels.fetch(channelId.accountId);
+      if (!channel || !channel.isTextBased()) {
+        console.error("[Discord] Cannot send: channel not found or not text-based");
+        return;
+      }
+
+      const textChannel = channel as TextChannel;
+      const message = await textChannel.messages.fetch(messageId);
+
+      if (response.content.replyToOriginal) {
+        await message.reply(response.content.text);
+      } else {
+        await textChannel.send(response.content.text);
+      }
+    } catch (error) {
+      console.error("[Discord] Error sending response:", error);
+    }
+  }
+
+  // ============================================================
+  // Platform-Specific Implementation
+  // ============================================================
+
+  /**
+   * Start Discord bot
+   */
+  protected async startPlatform(): Promise<void> {
+    console.log("[Discord] Starting bot...");
+
+    this.client.on("ready", () => {
+      console.log(`[Discord] Logged in as ${this.client.user?.tag}`);
+      console.log("[Discord] Ready to handle messages");
+    });
+
+    this.client.on("messageCreate", async (message: Message) => {
+      // Ignore bot messages
+      if (message.author.bot) return;
+
+      // Check guild restriction
+      if (this.guildId && message.guildId !== this.guildId) {
+        return;
+      }
+
+      // Check channel restriction
+      if (this.channelIds?.length && !this.channelIds.includes(message.channelId)) {
+        return;
+      }
+
+      console.log(`[Discord] [${message.author.tag}]: ${message.content}`);
+
+      // Send typing indicator
+      if ("sendTyping" in message.channel && typeof message.channel.sendTyping === "function") {
+        await message.channel.sendTyping();
+      }
+
+      try {
+        // Create normalized ChannelMessage
+        const channelMessage = this.createChannelMessage(message);
+
+        // Route through base channel
+        const response = await this.routeChannelMessage(channelMessage);
+
+        // Send response
+        await this.send(response);
+      } catch (error) {
+        console.error("[Discord] Error handling message:", error);
+        await message.reply(
+          `Sorry, I encountered an error: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    });
+
+    await this.client.login(this.token);
+  }
+
+  /**
+   * Stop Discord bot
+   */
+  protected async stopPlatform(): Promise<void> {
+    console.log("[Discord] Shutting down...");
+    await this.client.destroy();
+  }
+
+  // ============================================================
+  // Discord-Specific Helpers
+  // ============================================================
+
+  /**
+   * Create normalized ChannelMessage from Discord message
+   */
+  private createChannelMessage(msg: Message): ChannelMessage {
+    const sender: MessageSender = {
+      id: msg.author.id,
+      username: msg.author.username,
+      displayName: msg.author.displayName || msg.author.username,
+      isBot: msg.author.bot,
+    };
+
+    const context: MessageContext = {
+      isDM: msg.channel.isDMBased(),
+      groupName: !msg.channel.isDMBased() ? msg.guild?.name : undefined,
+      threadId: msg.channel.isThread() ? msg.channelId : undefined,
+      metadata: {
+        guildId: msg.guildId,
+        channelId: msg.channelId,
+      },
+    };
+
+    // Extract media attachments
+    const media = msg.attachments.size > 0
+      ? msg.attachments.map((att) => ({
+          type: att.contentType?.startsWith("image")
+            ? "image" as const
+            : att.contentType?.startsWith("video")
+            ? "video" as const
+            : att.contentType?.startsWith("audio")
+            ? "audio" as const
+            : "file" as const,
+          url: att.url,
+          mimeType: att.contentType || undefined,
+          filename: att.name || undefined,
+        }))
+      : undefined;
+
+    return {
+      messageId: msg.id,
+      channelId: {
+        platform: "discord",
+        accountId: msg.channelId,
+      },
+      timestamp: new Date(msg.createdTimestamp),
+      sender,
+      text: msg.content,
+      media,
+      context,
+      replyTo: msg.reference?.messageId
+        ? {
+            messageId: msg.reference.messageId,
+            channelId: {
+              platform: "discord",
+              accountId: msg.reference.channelId,
+            },
+          }
+        : undefined,
+      quotedText: undefined,
+    };
+  }
+
+  /**
+   * Send response, handling chunking for long messages
+   */
+  private async sendResponse(message: Message, response: string): Promise<void> {
+    const maxLength = 2000; // Discord message limit
+
+    if (response.length > maxLength) {
+      const chunks = response.match(/[\s\S]{1,2000}/g) || [];
+      for (const chunk of chunks) {
+        await message.reply(chunk);
+      }
+    } else {
+      await message.reply(response);
+    }
+  }
+}
+
+// ============================================================
+// FACTORY FUNCTION
+// ============================================================
+
+/**
+ * Create a Discord channel from config
+ */
+export function createDiscordChannel(config: DiscordChannelConfig): DiscordChannel {
+  return new DiscordChannel(config);
+}
+
+/**
+ * Create Discord channel config from environment (Doppler)
+ */
+export function createDiscordConfigFromEnv(): DiscordChannelConfig | null {
+  const token = process.env.DISCORD_BOT_TOKEN;
+  if (!token) return null;
+
+  const channelIds = process.env.DISCORD_CHANNEL_IDS
+    ?.split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+  return {
+    platform: "discord",
+    accountId: process.env.DISCORD_ACCOUNT_ID || "default",
+    instanceId: process.env.DISCORD_INSTANCE_ID,
+    botToken: token,
+    applicationId: process.env.DISCORD_APPLICATION_ID,
+    guildId: process.env.DISCORD_GUILD_ID,
+    channelIds,
+    enableSlashCommands: process.env.DISCORD_ENABLE_SLASH_COMMANDS !== "false",
+    daemonWorkdir: process.env.DAEMON_WORKDIR,
+    daemonBaseBranch: process.env.DAEMON_BASE_BRANCH,
+    enableDaemonAutoPR: process.env.DAEMON_AUTO_PR === "true",
+    enableDaemonAutoCommit: process.env.DAEMON_AUTO_COMMIT === "true",
+    butlerStorageDir: process.env.BUTLER_STORAGE_DIR,
+  };
+}

package/src/channels/index.ts

@@ -0,0 +1,169 @@
+/**
+ * GLM Daemon Channels
+ *
+ * Communication channel adapters for GLM Daemon.
+ * All channels implement ChannelConnector from @ebowwa/channel-types.
+ *
+ * Supported platforms:
+ * - Telegram
+ * - Discord
+ */
+
+// Re-export types from channel-types for convenience
+export type {
+  ChannelConnector,
+  ChannelId,
+  ChannelMessage,
+  ChannelResponse,
+  ChannelCapabilities,
+  MessageHandler,
+  MessageRef,
+  ResponseContent,
+} from "@ebowwa/channel-types";
+
+// Base channel
+export {
+  BaseChannel,
+  type GLMChannelConfig,
+  type BaseChannelConfig,
+  type MessageContext,
+  type RouteResult,
+  type MessageClassification,
+} from "./base.js";
+
+// Telegram (GLM-powered channel wrapping @ebowwa/channel-telegram)
+export {
+  GLMTelegramChannel,
+  type TelegramChannelConfig,
+  type TelegramConfig,
+  createTelegramChannel,
+  createTelegramConfigFromEnv,
+} from "./telegram.js";
+
+// Legacy alias for backwards compat
+export { GLMTelegramChannel as TelegramChannel } from "./telegram.js";
+
+// Discord
+export {
+  DiscordChannel,
+  type DiscordChannelConfig,
+  type DiscordConfig,
+  createDiscordChannel,
+  createDiscordConfigFromEnv,
+} from "./discord.js";
+
+// ============================================================
+// CHANNEL REGISTRY
+// ============================================================
+
+import type { ChannelConnector } from "@ebowwa/channel-types";
+import { BaseChannel } from "./base.js";
+import {
+  GLMTelegramChannel,
+  type TelegramChannelConfig,
+  createTelegramConfigFromEnv,
+} from "./telegram.js";
+import {
+  DiscordChannel,
+  type DiscordChannelConfig,
+  createDiscordConfigFromEnv,
+} from "./discord.js";
+
+/**
+ * Channel registry for managing multiple channels
+ */
+export class ChannelRegistry {
+  private static channels = new Map<string, ChannelConnector>();
+
+  /**
+   * Register a channel
+   */
+  static register(name: string, channel: ChannelConnector): void {
+    this.channels.set(name, channel);
+  }
+
+  /**
+   * Get a registered channel
+   */
+  static get(name: string): ChannelConnector | undefined {
+    return this.channels.get(name);
+  }
+
+  /**
+   * Unregister a channel
+   */
+  static unregister(name: string): void {
+    const channel = this.channels.get(name);
+    if (channel) {
+      channel.stop();
+      this.channels.delete(name);
+    }
+  }
+
+  /**
+   * Get all registered channels
+   */
+  static getAll(): Map<string, ChannelConnector> {
+    return new Map(this.channels);
+  }
+
+  /**
+   * Stop all channels
+   */
+  static async stopAll(): Promise<void> {
+    const stopPromises = Array.from(this.channels.values()).map((channel) => channel.stop());
+    await Promise.all(stopPromises);
+    this.channels.clear();
+  }
+
+  /**
+   * Start all channels
+   */
+  static async startAll(): Promise<void> {
+    const startPromises = Array.from(this.channels.values()).map((channel) => channel.start());
+    await Promise.all(startPromises);
+  }
+}
+
+// ============================================================
+// FACTORY FUNCTIONS
+// ============================================================
+
+/**
+ * Create all channels from environment variables (Doppler)
+ */
+export function createChannelsFromEnv(): ChannelConnector[] {
+  const channels: ChannelConnector[] = [];
+
+  // Telegram
+  const telegramConfig = createTelegramConfigFromEnv();
+  if (telegramConfig) {
+    channels.push(new GLMTelegramChannel(telegramConfig));
+  }
+
+  // Discord
+  const discordConfig = createDiscordConfigFromEnv();
+  if (discordConfig) {
+    channels.push(new DiscordChannel(discordConfig));
+  }
+
+  return channels;
+}
+
+/**
+ * Initialize channels from environment and register them
+ */
+export async function initializeChannelsFromEnv(): Promise<ChannelRegistry> {
+  const channels = createChannelsFromEnv();
+
+  for (const channel of channels) {
+    // Use platform:accountId as the key
+    const key = `${channel.id.platform}:${channel.id.accountId}`;
+    ChannelRegistry.register(key, channel);
+  }
+
+  // Start all channels
+  await ChannelRegistry.startAll();
+
+  return ChannelRegistry;
+}