acp-discord 0.1.0

package/dist/daemon.js

@@ -0,0 +1,606 @@
+#!/usr/bin/env node
+import {
+  loadConfig,
+  removePid,
+  resolveChannelConfig,
+  writePid
+} from "./chunk-SITRIFHO.js";
+
+// src/daemon/index.ts
+import { join } from "path";
+import { homedir } from "os";
+
+// src/daemon/discord-bot.ts
+import {
+  Client,
+  GatewayIntentBits,
+  Events,
+  REST,
+  Routes,
+  SlashCommandBuilder,
+  ActionRowBuilder as ActionRowBuilder2,
+  ButtonBuilder as ButtonBuilder2,
+  ButtonStyle as ButtonStyle2
+} from "discord.js";
+
+// src/daemon/channel-router.ts
+var ChannelRouter = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  resolve(channelId) {
+    return resolveChannelConfig(this.config, channelId);
+  }
+  isConfigured(channelId) {
+    return this.resolve(channelId) !== null;
+  }
+};
+
+// src/daemon/session-manager.ts
+import { spawn } from "child_process";
+import { Readable, Writable } from "stream";
+import { ClientSideConnection, ndJsonStream, PROTOCOL_VERSION } from "@agentclientprotocol/sdk";
+
+// src/daemon/acp-client.ts
+function createAcpClient(channelId, handlers, getRequestorId) {
+  return {
+    async requestPermission(params) {
+      const result = await handlers.onPermissionRequest(
+        channelId,
+        getRequestorId(),
+        {
+          toolCallId: params.toolCall.toolCallId,
+          title: params.toolCall.title ?? "Unknown",
+          kind: params.toolCall.kind ?? "other"
+        },
+        params.options.map((o) => ({
+          optionId: o.optionId,
+          name: o.name,
+          kind: o.kind
+        }))
+      );
+      if (result.outcome === "selected") {
+        return { outcome: { outcome: "selected", optionId: result.optionId } };
+      }
+      return { outcome: { outcome: "cancelled" } };
+    },
+    async sessionUpdate(params) {
+      const update = params.update;
+      switch (update.sessionUpdate) {
+        case "agent_message_chunk": {
+          if (update.content.type === "text") {
+            handlers.onAgentMessageChunk(channelId, update.content.text);
+          }
+          break;
+        }
+        case "tool_call": {
+          handlers.onToolCall(
+            channelId,
+            update.toolCallId,
+            update.title ?? "Unknown",
+            update.kind ?? "other",
+            update.status ?? "pending"
+          );
+          break;
+        }
+        case "tool_call_update": {
+          handlers.onToolCallUpdate(
+            channelId,
+            update.toolCallId,
+            update.status ?? "in_progress"
+          );
+          break;
+        }
+      }
+    }
+  };
+}
+
+// src/daemon/session-manager.ts
+var SessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  handlers;
+  constructor(handlers) {
+    this.handlers = handlers;
+  }
+  async prompt(channelId, text, agentConfig, requestorId) {
+    const session = await this.getOrCreate(channelId, agentConfig, requestorId);
+    session.lastActivity = Date.now();
+    this.resetIdleTimer(session, agentConfig.idle_timeout);
+    if (session.prompting) {
+      session.queue.push({ text, requestorId });
+      return "queued";
+    }
+    return this.executePrompt(session, text, requestorId, agentConfig);
+  }
+  async executePrompt(session, text, requestorId, agentConfig) {
+    session.prompting = true;
+    session.activePromptRequestorId = requestorId;
+    try {
+      const result = await session.connection.prompt({
+        sessionId: session.sessionId,
+        prompt: [{ type: "text", text }]
+      });
+      this.handlers.onPromptComplete(session.channelId, result.stopReason);
+      return result.stopReason;
+    } finally {
+      session.prompting = false;
+      const next = session.queue.shift();
+      if (next) {
+        this.executePrompt(session, next.text, next.requestorId, agentConfig).catch((err) => {
+          console.error(`Queued prompt failed for channel ${session.channelId}:`, err);
+        });
+      }
+    }
+  }
+  cancel(channelId) {
+    const session = this.sessions.get(channelId);
+    if (session) {
+      session.connection.cancel({ sessionId: session.sessionId });
+    }
+  }
+  async getOrCreate(channelId, agentConfig, requestorId) {
+    const existing = this.sessions.get(channelId);
+    if (existing) return existing;
+    return this.createSession(channelId, agentConfig, requestorId);
+  }
+  async createSession(channelId, config, requestorId) {
+    const proc = spawn(config.command, config.args, {
+      stdio: ["pipe", "pipe", "inherit"],
+      cwd: config.cwd
+    });
+    proc.on("error", (err) => {
+      console.error(`Agent process error for channel ${channelId}:`, err);
+      const session = this.sessions.get(channelId);
+      if (session?.process === proc) {
+        clearTimeout(session.idleTimer);
+        this.sessions.delete(channelId);
+      }
+    });
+    proc.on("exit", () => {
+      const session = this.sessions.get(channelId);
+      if (session?.process === proc) {
+        this.sessions.delete(channelId);
+        clearTimeout(session.idleTimer);
+      }
+    });
+    let connection;
+    let sessionId;
+    try {
+      const stream = ndJsonStream(
+        Writable.toWeb(proc.stdin),
+        Readable.toWeb(proc.stdout)
+      );
+      const client = createAcpClient(channelId, this.handlers, () => {
+        return this.sessions.get(channelId)?.activePromptRequestorId ?? requestorId;
+      });
+      connection = new ClientSideConnection((_agent) => client, stream);
+      await connection.initialize({
+        protocolVersion: PROTOCOL_VERSION,
+        clientCapabilities: {
+          fs: { readTextFile: true, writeTextFile: true },
+          terminal: true
+        },
+        clientInfo: {
+          name: "acp-discord",
+          title: "ACP Discord Bot",
+          version: "0.1.0"
+        }
+      });
+      const result = await connection.newSession({
+        cwd: config.cwd,
+        mcpServers: []
+      });
+      sessionId = result.sessionId;
+    } catch (err) {
+      proc.kill();
+      throw err;
+    }
+    const managed = {
+      channelId,
+      process: proc,
+      connection,
+      sessionId,
+      lastActivity: Date.now(),
+      idleTimer: this.startIdleTimer(channelId, config.idle_timeout),
+      prompting: false,
+      queue: [],
+      activePromptRequestorId: requestorId
+    };
+    this.sessions.set(channelId, managed);
+    return managed;
+  }
+  startIdleTimer(channelId, timeoutSec) {
+    return setTimeout(() => this.teardown(channelId), timeoutSec * 1e3);
+  }
+  resetIdleTimer(session, timeoutSec) {
+    clearTimeout(session.idleTimer);
+    session.idleTimer = this.startIdleTimer(session.channelId, timeoutSec);
+  }
+  teardown(channelId) {
+    const session = this.sessions.get(channelId);
+    if (!session) return;
+    clearTimeout(session.idleTimer);
+    session.process.kill();
+    this.sessions.delete(channelId);
+  }
+  teardownAll() {
+    for (const channelId of this.sessions.keys()) {
+      this.teardown(channelId);
+    }
+  }
+  isPrompting(channelId) {
+    return this.sessions.get(channelId)?.prompting ?? false;
+  }
+  getActiveRequestorId(channelId) {
+    const session = this.sessions.get(channelId);
+    if (!session?.prompting) return null;
+    return session.activePromptRequestorId;
+  }
+  getActiveChannels() {
+    return Array.from(this.sessions.keys());
+  }
+};
+
+// src/daemon/permission-ui.ts
+import {
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  EmbedBuilder
+} from "discord.js";
+var KIND_LABELS = {
+  allow_once: "\u2705 Allow",
+  allow_always: "\u2705 Always Allow",
+  reject_once: "\u274C Reject",
+  reject_always: "\u274C Never Allow"
+};
+var KIND_STYLES = {
+  allow_once: ButtonStyle.Success,
+  allow_always: ButtonStyle.Success,
+  reject_once: ButtonStyle.Danger,
+  reject_always: ButtonStyle.Danger
+};
+async function sendPermissionRequest(channel, toolTitle, toolKind, options, requestorId, timeoutMs = 14 * 60 * 1e3) {
+  if (options.length === 0) {
+    return { outcome: "cancelled" };
+  }
+  const embed = new EmbedBuilder().setColor(16753920).setTitle(`Permission: ${toolTitle}`).setDescription(`Tool type: \`${toolKind}\``).setTimestamp();
+  const buttons = options.map(
+    (opt) => new ButtonBuilder().setCustomId(`perm_${opt.optionId}`).setLabel(KIND_LABELS[opt.kind] ?? opt.name).setStyle(KIND_STYLES[opt.kind] ?? ButtonStyle.Secondary)
+  );
+  const rows = [];
+  for (let i = 0; i < buttons.length; i += 5) {
+    rows.push(new ActionRowBuilder().addComponents(buttons.slice(i, i + 5)));
+  }
+  const msg = await channel.send({ embeds: [embed], components: rows });
+  return new Promise((resolve) => {
+    const collector = msg.createMessageComponentCollector({
+      filter: (i) => i.user.id === requestorId,
+      time: timeoutMs
+    });
+    collector.on("collect", async (interaction) => {
+      const optionId = interaction.customId.replace("perm_", "");
+      await interaction.update({ components: [] });
+      collector.stop("selected");
+      resolve({ outcome: "selected", optionId });
+    });
+    collector.on("end", (_collected, reason) => {
+      if (reason === "time") {
+        msg.edit({ components: [] }).catch(() => {
+        });
+        resolve({ outcome: "cancelled" });
+      }
+    });
+  });
+}
+
+// src/daemon/message-bridge.ts
+var DISCORD_MAX_LENGTH = 2e3;
+function splitMessage(text, maxLength = DISCORD_MAX_LENGTH) {
+  if (text.length <= maxLength) return [text];
+  const chunks = [];
+  let remaining = text;
+  let inCodeBlock = false;
+  let codeFence = "";
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLength) {
+      chunks.push(remaining);
+      break;
+    }
+    let splitAt = maxLength;
+    const lastNewline = remaining.lastIndexOf("\n", maxLength);
+    if (lastNewline > maxLength * 0.5) {
+      splitAt = lastNewline + 1;
+    }
+    let chunk = remaining.slice(0, splitAt);
+    remaining = remaining.slice(splitAt);
+    const fenceMatches = chunk.match(/```\w*/g) || [];
+    for (const fence of fenceMatches) {
+      if (!inCodeBlock) {
+        inCodeBlock = true;
+        codeFence = fence;
+      } else {
+        inCodeBlock = false;
+        codeFence = "";
+      }
+    }
+    if (inCodeBlock) {
+      chunk += "\n```";
+      remaining = codeFence + "\n" + remaining;
+      inCodeBlock = false;
+      codeFence = "";
+    }
+    chunks.push(chunk);
+  }
+  return chunks;
+}
+var STATUS_ICONS = {
+  pending: "\u23F3",
+  // ⏳
+  in_progress: "\u{1F504}",
+  // 🔄
+  completed: "\u2705",
+  // ✅
+  failed: "\u274C"
+  // ❌
+};
+function formatToolSummary(tools) {
+  const lines = [];
+  for (const [, tool] of tools) {
+    lines.push(`${STATUS_ICONS[tool.status]} ${tool.title}`);
+  }
+  return lines.join("\n");
+}
+
+// src/daemon/discord-bot.ts
+async function startDiscordBot(config) {
+  const router = new ChannelRouter(config);
+  const toolStates = /* @__PURE__ */ new Map();
+  const toolSummaryMessages = /* @__PURE__ */ new Map();
+  const replyBuffers = /* @__PURE__ */ new Map();
+  const replyMessages = /* @__PURE__ */ new Map();
+  const flushTimers = /* @__PURE__ */ new Map();
+  let discordClient;
+  const handlers = {
+    onToolCall(channelId, toolCallId, title, _kind, status) {
+      if (!toolStates.has(channelId)) toolStates.set(channelId, /* @__PURE__ */ new Map());
+      toolStates.get(channelId).set(toolCallId, { title, status });
+      updateToolSummaryMessage(channelId);
+    },
+    onToolCallUpdate(channelId, toolCallId, status) {
+      const tools = toolStates.get(channelId);
+      const tool = tools?.get(toolCallId);
+      if (tool) {
+        tool.status = status;
+        updateToolSummaryMessage(channelId);
+      }
+    },
+    onAgentMessageChunk(channelId, text) {
+      const current = replyBuffers.get(channelId) ?? "";
+      replyBuffers.set(channelId, current + text);
+      scheduleFlushReply(channelId);
+    },
+    async onPermissionRequest(channelId, requestorId, toolCall, options) {
+      const channel = await fetchChannel(channelId);
+      if (!channel) return { outcome: "cancelled" };
+      return sendPermissionRequest(channel, toolCall.title, toolCall.kind, options, requestorId);
+    },
+    onPromptComplete(channelId, _stopReason) {
+      flushReply(channelId, true);
+      removeStopButton(channelId);
+      toolStates.delete(channelId);
+      toolSummaryMessages.delete(channelId);
+      replyBuffers.delete(channelId);
+      replyMessages.delete(channelId);
+    }
+  };
+  const sessionManager = new SessionManager(handlers);
+  async function fetchChannel(channelId) {
+    const cached = discordClient.channels.cache.get(channelId);
+    if (cached) return cached;
+    try {
+      const fetched = await discordClient.channels.fetch(channelId);
+      return fetched;
+    } catch {
+      return null;
+    }
+  }
+  async function updateToolSummaryMessage(channelId) {
+    const tools = toolStates.get(channelId);
+    if (!tools) return;
+    const content = formatToolSummary(tools);
+    const channel = await fetchChannel(channelId);
+    if (!channel) return;
+    const stopButton = new ActionRowBuilder2().addComponents(
+      new ButtonBuilder2().setCustomId(`stop_${channelId}`).setLabel("\u23F9 Stop").setStyle(ButtonStyle2.Secondary)
+    );
+    const existing = toolSummaryMessages.get(channelId);
+    if (existing) {
+      await existing.edit({ content, components: [stopButton] }).catch(() => {
+      });
+    } else {
+      const msg = await channel.send({ content, components: [stopButton] });
+      toolSummaryMessages.set(channelId, msg);
+    }
+  }
+  async function removeStopButton(channelId) {
+    const msg = toolSummaryMessages.get(channelId);
+    if (msg) {
+      const tools = toolStates.get(channelId);
+      const content = tools ? formatToolSummary(tools) : msg.content;
+      await msg.edit({ content, components: [] }).catch(() => {
+      });
+    }
+  }
+  function scheduleFlushReply(channelId) {
+    if (flushTimers.has(channelId)) return;
+    flushTimers.set(
+      channelId,
+      setTimeout(() => {
+        flushTimers.delete(channelId);
+        flushReply(channelId, false);
+      }, 500)
+    );
+  }
+  async function flushReply(channelId, final) {
+    const timer = flushTimers.get(channelId);
+    if (timer) {
+      clearTimeout(timer);
+      flushTimers.delete(channelId);
+    }
+    const buffer = replyBuffers.get(channelId);
+    if (!buffer) return;
+    const channel = await fetchChannel(channelId);
+    if (!channel) return;
+    if (final) {
+      const existing = replyMessages.get(channelId);
+      if (existing) await existing.delete().catch(() => {
+      });
+      replyMessages.delete(channelId);
+      const chunks = splitMessage(buffer);
+      for (const chunk of chunks) {
+        await channel.send(chunk);
+      }
+      replyBuffers.delete(channelId);
+    } else {
+      const truncated = buffer.length > 2e3 ? buffer.slice(buffer.length - 1900) + "..." : buffer;
+      const existing = replyMessages.get(channelId);
+      if (existing) {
+        await existing.edit(truncated).catch(() => {
+        });
+      } else {
+        const msg = await channel.send(truncated);
+        replyMessages.set(channelId, msg);
+      }
+    }
+  }
+  discordClient = new Client({
+    intents: [
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.MessageContent
+    ]
+  });
+  discordClient.on(Events.ClientReady, async (c) => {
+    console.log(`Discord bot ready: ${c.user.tag}`);
+    const askCommand = new SlashCommandBuilder().setName("ask").setDescription("Ask the coding agent a question").addStringOption(
+      (opt) => opt.setName("message").setDescription("Your message").setRequired(true)
+    );
+    const rest = new REST().setToken(config.discord.token);
+    try {
+      await rest.put(Routes.applicationCommands(c.application.id), {
+        body: [askCommand.toJSON()]
+      });
+      console.log("Registered /ask command");
+    } catch (err) {
+      console.error("Failed to register commands:", err);
+    }
+  });
+  discordClient.on(Events.MessageCreate, async (message) => {
+    if (message.author.bot) return;
+    const channelId = message.channelId;
+    const resolved = router.resolve(channelId);
+    if (!resolved) return;
+    const isMention = message.mentions.has(discordClient.user);
+    if (!isMention) return;
+    const text = message.content.replace(/<@!?\d+>/g, "").trim();
+    if (!text) {
+      await message.reply("Please provide a message.");
+      return;
+    }
+    if (sessionManager.isPrompting(channelId)) {
+      await message.reply("\u23F3 Agent is working. Your message has been queued.");
+    }
+    try {
+      await sessionManager.prompt(channelId, text, resolved.agent, message.author.id);
+    } catch (err) {
+      console.error(`Prompt failed for channel ${channelId}:`, err);
+      await message.reply("An error occurred while processing your request.").catch(() => {
+      });
+    }
+  });
+  discordClient.on(Events.InteractionCreate, async (interaction) => {
+    if (!interaction.isButton()) return;
+    if (interaction.customId.startsWith("stop_")) {
+      const channelId = interaction.customId.replace("stop_", "");
+      const activeRequestor = sessionManager.getActiveRequestorId(channelId);
+      if (activeRequestor && interaction.user.id !== activeRequestor) {
+        await interaction.reply({ content: "Only the user who started this prompt can stop it.", ephemeral: true });
+        return;
+      }
+      sessionManager.cancel(channelId);
+      await interaction.update({ components: [] });
+    }
+  });
+  discordClient.on(Events.InteractionCreate, async (interaction) => {
+    if (!interaction.isChatInputCommand()) return;
+    if (interaction.commandName !== "ask") return;
+    const channelId = interaction.channelId;
+    const resolved = router.resolve(channelId);
+    if (!resolved) {
+      await interaction.reply({ content: "This channel is not configured for ACP.", ephemeral: true });
+      return;
+    }
+    const text = interaction.options.getString("message", true);
+    await interaction.deferReply();
+    if (sessionManager.isPrompting(channelId)) {
+      await interaction.editReply("\u23F3 Agent is working. Your message has been queued.");
+    } else {
+      await interaction.editReply(`\u{1F4AC} Processing: ${text.slice(0, 100)}...`);
+    }
+    try {
+      await sessionManager.prompt(channelId, text, resolved.agent, interaction.user.id);
+    } catch (err) {
+      console.error(`Prompt failed for channel ${channelId}:`, err);
+      await interaction.followUp({ content: "An error occurred while processing your request.", ephemeral: true }).catch(() => {
+      });
+    }
+  });
+  process.on("SIGTERM", () => {
+    sessionManager.teardownAll();
+    discordClient.destroy();
+  });
+  process.on("SIGINT", () => {
+    sessionManager.teardownAll();
+    discordClient.destroy();
+  });
+  try {
+    await discordClient.login(config.discord.token);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.includes("TOKEN_INVALID") || message.includes("An invalid token was provided")) {
+      console.error("Error: Invalid Discord bot token. Check your config.toml.");
+    } else if (message.includes("ConnectTimeout") || message.includes("ETIMEDOUT") || message.includes("ECONNREFUSED")) {
+      console.error("Error: Cannot connect to Discord API. Check your network or proxy settings.");
+      console.error("Hint: Set HTTPS_PROXY=http://127.0.0.1:7890 if you need a proxy.");
+    } else {
+      console.error("Error: Failed to connect to Discord:", message);
+    }
+    process.exit(1);
+  }
+}
+
+// src/daemon/index.ts
+var CONFIG_DIR = join(homedir(), ".acp-discord");
+var CONFIG_PATH = join(CONFIG_DIR, "config.toml");
+var PID_PATH = join(CONFIG_DIR, "daemon.pid");
+async function runDaemon() {
+  const config = loadConfig(CONFIG_PATH);
+  writePid(PID_PATH, process.pid);
+  process.on("exit", () => removePid(PID_PATH));
+  console.log(`acp-discord daemon started (PID: ${process.pid})`);
+  console.log(`Loaded config: ${Object.keys(config.channels).length} channel(s)`);
+  await startDiscordBot(config);
+}
+if (process.env.ACP_DISCORD_DAEMON === "1") {
+  runDaemon().catch((err) => {
+    console.error("Daemon failed:", err);
+    process.exit(1);
+  });
+}
+export {
+  runDaemon
+};
+//# sourceMappingURL=daemon.js.map