acp-discord 0.5.1 → 0.6.0

package/README.md

@@ -11,6 +11,7 @@ Send a message in Discord, get AI coding assistance back — with tool call visu
 - **File diffs** — see unified diffs in Discord when the agent modifies files
 - **Tool call visualization** — see what the agent is doing (⏳ pending → 🔄 running → ✅ done / ❌ failed), with a ⏹️ stop button to cancel
 - **Permission UI** — Discord buttons for approving/denying agent actions, with file diffs shown inline for review before approval
+- **Discord channel management** — agents can create/delete/modify Discord channels via MCP tools, with user confirmation for all mutating operations
 - **Auto-reply mode** — optionally respond to all messages in a channel, not just mentions
 - **Multi-agent support** — different channels can use different agents
 - **Daemon mode** — runs in background with auto-start (systemd/launchd)
@@ -46,6 +47,7 @@ command = "claude-code"
 args = ["--acp"]
 cwd = "/path/to/your/project"
 idle_timeout = 600  # seconds before idle session is terminated (default: 600)
+discord_tools = true  # enable Discord channel management MCP tools (default: false)
 
 [channels.1234567890123456]
 agent = "claude"
@@ -93,6 +95,20 @@ acp-discord update          # Update to latest version, auto-restarts daemon
 
 If a prompt is sent while the agent is already working, it gets queued and processed after the current task completes.
 
+### Channel Management
+
+When `discord_tools = true` is set on an agent, the bot injects an MCP server that gives the agent these tools:
+
+| Tool | Description | Requires Approval |
+|------|-------------|:-----------------:|
+| `list_channels` | List all text channels in the server | No |
+| `create_channel` | Create a new text channel | Yes |
+| `delete_channel` | Delete a channel | Yes |
+| `update_channel` | Update channel name/topic | Yes |
+| `send_message` | Send a message to a channel | No |
+
+All mutating operations (create, delete, update) require user approval via Discord buttons before executing. Newly created channels are automatically registered so the bot responds to messages there.
+
 ### Development
 
 ```bash
@@ -107,9 +123,9 @@ pnpm test:watch   # Watch mode
 Discord User
     ↓  slash command / mention
 Discord Bot (discord.js)
-    ↓  channel routing
-Session Manager (per-channel sessions)
-    ↓  spawn agent subprocess
+    ↓  channel routing           ↑ IPC (Unix socket)
+Session Manager                MCP Server (discord-channels)
+    ↓  spawn agent subprocess      ↑ MCP tools (stdio)
 ACP Client (JSON-RPC over stdio)
     ↓  prompt / permissions / tool calls
 Agent (claude-code, codex, etc.)

package/dist/{chunk-QRVSGBED.js → chunk-S4TTOKFY.js}

@@ -61,11 +61,15 @@ function parseConfig(toml) {
     if (agent.cwd !== void 0 && typeof agent.cwd !== "string") {
       throw new Error(`agents.${name}.cwd must be a string`);
     }
+    if (agent.discord_tools !== void 0 && typeof agent.discord_tools !== "boolean") {
+      throw new Error(`agents.${name}.discord_tools must be a boolean`);
+    }
     parsedAgents[name] = {
       command: agent.command,
       args: agent.args ?? [],
       cwd: typeof agent.cwd === "string" ? agent.cwd : process.cwd(),
-      idle_timeout: typeof agent.idle_timeout === "number" ? agent.idle_timeout : 600
+      idle_timeout: typeof agent.idle_timeout === "number" ? agent.idle_timeout : 600,
+      discord_tools: agent.discord_tools === true
     };
   }
   const channels = raw.channels ?? {};
@@ -107,6 +111,7 @@ function resolveChannelConfig(config, channelId) {
   if (!agentConf) return null;
   return {
     channelId,
+    agentName: channelConf.agent,
     agent: {
       ...agentConf,
       cwd: channelConf.cwd ?? agentConf.cwd
@@ -124,4 +129,4 @@ export {
   loadConfig,
   resolveChannelConfig
 };
-//# sourceMappingURL=chunk-QRVSGBED.js.map
+//# sourceMappingURL=chunk-S4TTOKFY.js.map

package/dist/chunk-S4TTOKFY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli/pid.ts","../src/shared/config.ts"],"sourcesContent":["import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync } from \"node:fs\";\nimport { dirname } from \"node:path\";\n\nexport function writePid(pidPath: string, pid: number): void {\n  mkdirSync(dirname(pidPath), { recursive: true });\n  writeFileSync(pidPath, String(pid), \"utf-8\");\n}\n\nexport function readPid(pidPath: string): number | null {\n  if (!existsSync(pidPath)) return null;\n  const content = readFileSync(pidPath, \"utf-8\").trim();\n  const pid = parseInt(content, 10);\n  return isNaN(pid) ? null : pid;\n}\n\nexport function removePid(pidPath: string): void {\n  if (existsSync(pidPath)) unlinkSync(pidPath);\n}\n\nexport function isDaemonRunning(pidPath: string): boolean {\n  const pid = readPid(pidPath);\n  if (pid === null) return false;\n  try {\n    process.kill(pid, 0); // signal 0 = check if process exists\n    return true;\n  } catch {\n    return false;\n  }\n}\n","import { parse } from \"smol-toml\";\nimport { readFileSync } from \"node:fs\";\nimport type { AppConfig, ResolvedChannelConfig } from \"./types.js\";\n\nexport function parseConfig(toml: string): AppConfig {\n  const raw = parse(toml) as Record<string, unknown>;\n\n  const discord = raw.discord as Record<string, unknown> | undefined;\n  if (!discord?.token || typeof discord.token !== \"string\") {\n    throw new Error(\"Missing required: discord.token\");\n  }\n  if (discord.token.trim().length === 0) {\n    throw new Error(\"discord.token must not be empty\");\n  }\n\n  const agents = raw.agents as Record<string, Record<string, unknown>> | undefined;\n  if (!agents || Object.keys(agents).length === 0) {\n    throw new Error(\"Missing required: at least one agent in [agents.*]\");\n  }\n\n  const parsedAgents: AppConfig[\"agents\"] = {};\n  for (const [name, agent] of Object.entries(agents)) {\n    // Validate command is a non-empty string\n    if (!agent.command || typeof agent.command !== \"string\") {\n      throw new Error(`agents.${name}.command must be a non-empty string`);\n    }\n\n    // Validate args is an array of strings\n    if (agent.args !== undefined) {\n      if (!Array.isArray(agent.args) || !agent.args.every((a: unknown) => typeof a === \"string\")) {\n        throw new Error(`agents.${name}.args must be an array of strings`);\n      }\n    }\n\n    // Validate idle_timeout is a positive number\n    if (agent.idle_timeout !== undefined) {\n      if (typeof agent.idle_timeout !== \"number\" || agent.idle_timeout <= 0) {\n        throw new Error(`agents.${name}.idle_timeout must be a positive number`);\n      }\n    }\n\n    // Validate cwd is a string if provided\n    if (agent.cwd !== undefined && typeof agent.cwd !== \"string\") {\n      throw new Error(`agents.${name}.cwd must be a string`);\n    }\n\n    // Validate discord_tools is a boolean if provided\n    if (agent.discord_tools !== undefined && typeof agent.discord_tools !== \"boolean\") {\n      throw new Error(`agents.${name}.discord_tools must be a boolean`);\n    }\n\n    parsedAgents[name] = {\n      command: agent.command,\n      args: (agent.args as string[]) ?? [],\n      cwd: typeof agent.cwd === \"string\" ? agent.cwd : process.cwd(),\n      idle_timeout: typeof agent.idle_timeout === \"number\" ? agent.idle_timeout : 600,\n      discord_tools: agent.discord_tools === true,\n    };\n  }\n\n  const channels = (raw.channels ?? {}) as Record<string, Record<string, unknown>>;\n  const parsedChannels: AppConfig[\"channels\"] = {};\n  for (const [id, ch] of Object.entries(channels)) {\n    const agentRef = ch.agent ?? \"default\";\n    if (typeof agentRef !== \"string\") {\n      throw new Error(`channels.${id}.agent must be a string`);\n    }\n    if (!parsedAgents[agentRef]) {\n      throw new Error(`channels.${id}.agent references unknown agent \"${agentRef}\"`);\n    }\n    if (ch.cwd !== undefined && typeof ch.cwd !== \"string\") {\n      throw new Error(`channels.${id}.cwd must be a string`);\n    }\n    if (ch.auto_reply !== undefined && typeof ch.auto_reply !== \"boolean\") {\n      throw new Error(`channels.${id}.auto_reply must be a boolean`);\n    }\n\n    parsedChannels[id] = {\n      agent: agentRef,\n      cwd: ch.cwd ? String(ch.cwd) : undefined,\n      auto_reply: ch.auto_reply === true,\n    };\n  }\n\n  return {\n    discord: { token: String(discord.token) },\n    agents: parsedAgents,\n    channels: parsedChannels,\n  };\n}\n\nexport function loadConfig(configPath: string): AppConfig {\n  const content = readFileSync(configPath, \"utf-8\");\n  return parseConfig(content);\n}\n\nexport function resolveChannelConfig(\n  config: AppConfig,\n  channelId: string,\n): ResolvedChannelConfig | null {\n  const channelConf = config.channels[channelId];\n  if (!channelConf) return null;\n\n  const agentConf = config.agents[channelConf.agent];\n  if (!agentConf) return null;\n\n  return {\n    channelId,\n    agentName: channelConf.agent,\n    agent: {\n      ...agentConf,\n      cwd: channelConf.cwd ?? agentConf.cwd,\n    },\n    autoReply: channelConf.auto_reply === true,\n  };\n}\n"],"mappings":"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","names":["readFileSync"]}

package/dist/daemon.js

@@ -4,11 +4,11 @@ import {
   removePid,
   resolveChannelConfig,
   writePid
-} from "./chunk-QRVSGBED.js";
+} from "./chunk-S4TTOKFY.js";
 
 // src/daemon/index.ts
-import { join } from "path";
-import { homedir } from "os";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
 
 // src/daemon/discord-bot.ts
 import {
@@ -20,8 +20,11 @@ import {
   SlashCommandBuilder,
   ActionRowBuilder as ActionRowBuilder2,
   ButtonBuilder as ButtonBuilder2,
-  ButtonStyle as ButtonStyle2
+  ButtonStyle as ButtonStyle2,
+  EmbedBuilder as EmbedBuilder2
 } from "discord.js";
+import { resolve as resolvePath, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
 
 // src/daemon/channel-router.ts
 var ChannelRouter = class {
@@ -35,6 +38,19 @@ var ChannelRouter = class {
   isConfigured(channelId) {
     return this.resolve(channelId) !== null;
   }
+  registerDynamic(channelId, agentName, autoReply) {
+    if (!this.config.agents[agentName]) {
+      console.error(`Cannot register dynamic channel: unknown agent "${agentName}"`);
+      return;
+    }
+    this.config.channels[channelId] = {
+      agent: agentName,
+      auto_reply: autoReply
+    };
+  }
+  unregisterDynamic(channelId) {
+    delete this.config.channels[channelId];
+  }
 };
 
 // src/daemon/session-manager.ts
@@ -129,8 +145,8 @@ var SessionManager = class {
   constructor(handlers) {
     this.handlers = handlers;
   }
-  async prompt(channelId, text, agentConfig, requestorId) {
-    const session = await this.getOrCreate(channelId, agentConfig, requestorId);
+  async prompt(channelId, text, agentConfig, requestorId, mcpServers) {
+    const session = await this.getOrCreate(channelId, agentConfig, requestorId, mcpServers);
     session.lastActivity = Date.now();
     this.resetIdleTimer(session, agentConfig.idle_timeout);
     if (session.prompting) {
@@ -165,12 +181,12 @@ var SessionManager = class {
       session.connection.cancel({ sessionId: session.sessionId });
     }
   }
-  async getOrCreate(channelId, agentConfig, requestorId) {
+  async getOrCreate(channelId, agentConfig, requestorId, mcpServers) {
     const existing = this.sessions.get(channelId);
     if (existing) return existing;
-    return this.createSession(channelId, agentConfig, requestorId);
+    return this.createSession(channelId, agentConfig, requestorId, mcpServers);
   }
-  async createSession(channelId, config, requestorId) {
+  async createSession(channelId, config, requestorId, mcpServers) {
     const proc = spawn(config.command, config.args, {
       stdio: ["pipe", "pipe", "inherit"],
       cwd: config.cwd
@@ -183,11 +199,14 @@ var SessionManager = class {
         this.sessions.delete(channelId);
       }
     });
-    proc.on("exit", () => {
+    proc.on("exit", (code) => {
       const session = this.sessions.get(channelId);
       if (session?.process === proc) {
-        this.sessions.delete(channelId);
         clearTimeout(session.idleTimer);
+        this.sessions.delete(channelId);
+        if (code !== 0 && code !== null) {
+          console.warn(`Agent process for channel ${channelId} exited with code ${code}`);
+        }
       }
     });
     let connection;
@@ -215,7 +234,7 @@ var SessionManager = class {
       });
       const result = await connection.newSession({
         cwd: config.cwd,
-        mcpServers: []
+        mcpServers: mcpServers ?? []
       });
       sessionId = result.sessionId;
     } catch (err) {
@@ -460,6 +479,116 @@ async function sendPermissionRequest(channel, toolTitle, toolKind, options, requ
   });
 }
 
+// src/daemon/ipc-server.ts
+import { createServer } from "net";
+import { existsSync, unlinkSync, mkdirSync, chmodSync } from "fs";
+import { dirname } from "path";
+import { homedir } from "os";
+import { join } from "path";
+var DEFAULT_IPC_SOCKET_PATH = join(homedir(), ".acp-discord", "ipc.sock");
+var IpcServer = class {
+  server = null;
+  socketPath;
+  handler;
+  connections = /* @__PURE__ */ new Set();
+  constructor(handler, socketPath = DEFAULT_IPC_SOCKET_PATH) {
+    this.handler = handler;
+    this.socketPath = socketPath;
+  }
+  async start() {
+    if (existsSync(this.socketPath)) {
+      unlinkSync(this.socketPath);
+    }
+    mkdirSync(dirname(this.socketPath), { recursive: true });
+    return new Promise((resolve, reject) => {
+      this.server = createServer((socket) => this.handleConnection(socket));
+      this.server.on("error", (err) => {
+        console.error("IPC server error:", err);
+        reject(err);
+      });
+      this.server.listen(this.socketPath, () => {
+        chmodSync(this.socketPath, 384);
+        console.log(`IPC server listening on ${this.socketPath}`);
+        resolve();
+      });
+    });
+  }
+  handleConnection(socket) {
+    this.connections.add(socket);
+    let buffer = "";
+    socket.on("data", (data) => {
+      buffer += data.toString();
+      let newlineIdx;
+      while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, newlineIdx).trim();
+        buffer = buffer.slice(newlineIdx + 1);
+        if (line) {
+          this.processMessage(socket, line).catch((err) => {
+            console.error("IPC message processing error:", err);
+          });
+        }
+      }
+    });
+    socket.on("close", () => {
+      this.connections.delete(socket);
+    });
+    socket.on("error", (err) => {
+      console.error("IPC connection error:", err);
+      this.connections.delete(socket);
+    });
+  }
+  async processMessage(socket, raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      console.error("IPC: invalid JSON:", raw);
+      return;
+    }
+    switch (msg.action) {
+      case "register_channel":
+        if (msg.channelId && msg.agentName) {
+          this.handler.registerChannel(msg.channelId, msg.agentName, msg.autoReply ?? true);
+        }
+        break;
+      case "unregister_channel":
+        if (msg.channelId) {
+          this.handler.unregisterChannel(msg.channelId);
+        }
+        break;
+      case "confirm_action":
+        if (msg.requestId && msg.sourceChannelId && msg.description) {
+          const approved = await this.handler.confirmAction(
+            msg.sourceChannelId,
+            msg.description,
+            msg.details ?? ""
+          );
+          const response = JSON.stringify({ requestId: msg.requestId, approved }) + "\n";
+          socket.write(response);
+        }
+        break;
+      default:
+        console.error("IPC: unknown action:", msg.action);
+    }
+  }
+  stop() {
+    for (const conn of this.connections) {
+      conn.destroy();
+    }
+    this.connections.clear();
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+    if (existsSync(this.socketPath)) {
+      try {
+        unlinkSync(this.socketPath);
+      } catch {
+      }
+    }
+  }
+};
+
 // src/daemon/discord-bot.ts
 async function startDiscordBot(config) {
   const router = new ChannelRouter(config);
@@ -471,6 +600,51 @@ async function startDiscordBot(config) {
   const pendingDiffs = /* @__PURE__ */ new Map();
   const permissionDiffShown = /* @__PURE__ */ new Map();
   let discordClient;
+  const pendingConfirmations = /* @__PURE__ */ new Map();
+  async function handleConfirmAction(sourceChannelId, description, details) {
+    const channel = await fetchChannel(sourceChannelId);
+    if (!channel) return false;
+    const allowedUserId = sessionManager.getActiveRequestorId(sourceChannelId);
+    const requestId = `mcp_confirm_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const embed = new EmbedBuilder2().setColor(16753920).setTitle(`Channel Action: ${description}`).setDescription(details || "No additional details").setTimestamp();
+    const row = new ActionRowBuilder2().addComponents(
+      new ButtonBuilder2().setCustomId(`mcp_approve_${requestId}`).setLabel("\u2705 Approve").setStyle(ButtonStyle2.Success),
+      new ButtonBuilder2().setCustomId(`mcp_reject_${requestId}`).setLabel("\u274C Reject").setStyle(ButtonStyle2.Danger)
+    );
+    const msg = await channel.send({ embeds: [embed], components: [row] });
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        pendingConfirmations.delete(requestId);
+        msg.delete().catch(() => msg.edit({ components: [] }).catch(() => {
+        }));
+        resolve(false);
+      }, 5 * 60 * 1e3);
+      pendingConfirmations.set(requestId, {
+        resolve: (approved) => {
+          clearTimeout(timeout);
+          pendingConfirmations.delete(requestId);
+          msg.delete().catch(() => msg.edit({ components: [] }).catch(() => {
+          }));
+          resolve(approved);
+        },
+        allowedUserId
+      });
+    });
+  }
+  const ipcServer = new IpcServer(
+    {
+      registerChannel(channelId, agentName, autoReply) {
+        router.registerDynamic(channelId, agentName, autoReply);
+        console.log(`IPC: registered dynamic channel ${channelId} -> agent ${agentName}`);
+      },
+      unregisterChannel(channelId) {
+        router.unregisterDynamic(channelId);
+        console.log(`IPC: unregistered dynamic channel ${channelId}`);
+      },
+      confirmAction: handleConfirmAction
+    },
+    DEFAULT_IPC_SOCKET_PATH
+  );
   const handlers = {
     onToolCall(channelId, toolCallId, title, _kind, status, diffs, rawInput) {
       if (!toolStates.has(channelId)) toolStates.set(channelId, /* @__PURE__ */ new Map());
@@ -517,6 +691,26 @@ async function startDiscordBot(config) {
     }
   };
   const sessionManager = new SessionManager(handlers);
+  function buildMcpServers(channelId, agentName, guildId) {
+    const resolved = router.resolve(channelId);
+    if (!resolved?.agent.discord_tools) return [];
+    const currentDir = import.meta.dirname ?? dirname2(fileURLToPath(import.meta.url));
+    const mcpScriptPath = resolvePath(currentDir, "mcp-discord-channels.js");
+    return [
+      {
+        name: "discord-channels",
+        command: "node",
+        args: [mcpScriptPath],
+        env: [
+          { name: "DISCORD_TOKEN", value: config.discord.token },
+          { name: "GUILD_ID", value: guildId },
+          { name: "IPC_SOCKET_PATH", value: DEFAULT_IPC_SOCKET_PATH },
+          { name: "AGENT_NAME", value: agentName },
+          { name: "SOURCE_CHANNEL_ID", value: channelId }
+        ]
+      }
+    ];
+  }
   function accumulateDiffs(channelId, toolCallId, diffs) {
     if (diffs.length === 0) return;
     if (!pendingDiffs.has(channelId)) pendingDiffs.set(channelId, /* @__PURE__ */ new Map());
@@ -622,6 +816,13 @@ async function startDiscordBot(config) {
       }
     }
   }
+  function getGuildId(message) {
+    return message.guildId ?? null;
+  }
+  async function promptWithMcp(channelId, text, agentName, guildId, agentConfig, requestorId) {
+    const mcpServers = guildId ? buildMcpServers(channelId, agentName, guildId) : void 0;
+    await sessionManager.prompt(channelId, text, agentConfig, requestorId, mcpServers);
+  }
   discordClient = new Client({
     intents: [
       GatewayIntentBits.Guilds,
@@ -629,6 +830,18 @@ async function startDiscordBot(config) {
       GatewayIntentBits.MessageContent
     ]
   });
+  discordClient.on("error", (err) => {
+    console.error("Discord client error:", err);
+  });
+  discordClient.on("warn", (msg) => {
+    console.warn("Discord client warning:", msg);
+  });
+  discordClient.on("shardDisconnect", (event, shardId) => {
+    console.warn(`Shard ${shardId} disconnected (code: ${event.code})`);
+  });
+  discordClient.on("shardReconnecting", (shardId) => {
+    console.log(`Shard ${shardId} reconnecting...`);
+  });
   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(
@@ -661,7 +874,7 @@ async function startDiscordBot(config) {
       await message.reply("\u23F3 Agent is working. Your message has been queued.");
     }
     try {
-      await sessionManager.prompt(channelId, text, resolved.agent, message.author.id);
+      await promptWithMcp(channelId, text, resolved.agentName, getGuildId(message), 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(() => {
@@ -680,6 +893,21 @@ async function startDiscordBot(config) {
       sessionManager.cancel(channelId);
       await interaction.update({ components: [] });
     }
+    if (interaction.customId.startsWith("mcp_approve_") || interaction.customId.startsWith("mcp_reject_")) {
+      const approved = interaction.customId.startsWith("mcp_approve_");
+      const requestId = interaction.customId.replace(/^mcp_(approve|reject)_/, "");
+      const pending = pendingConfirmations.get(requestId);
+      if (pending) {
+        if (pending.allowedUserId && interaction.user.id !== pending.allowedUserId) {
+          await interaction.reply({ content: "Only the user who started this prompt can approve or reject.", ephemeral: true });
+          return;
+        }
+        await interaction.deferUpdate();
+        pending.resolve(approved);
+      } else {
+        await interaction.reply({ content: "This confirmation has expired.", ephemeral: true });
+      }
+    }
   });
   discordClient.on(Events.InteractionCreate, async (interaction) => {
     if (!interaction.isChatInputCommand()) return;
@@ -698,7 +926,8 @@ async function startDiscordBot(config) {
       await interaction.editReply(`\u{1F4AC} Processing: ${text.slice(0, 100)}...`);
     }
     try {
-      await sessionManager.prompt(channelId, text, resolved.agent, interaction.user.id);
+      const guildId = interaction.guildId ?? null;
+      await promptWithMcp(channelId, text, resolved.agentName, guildId, 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(() => {
@@ -721,11 +950,14 @@ async function startDiscordBot(config) {
     flushTimers.delete(channelId);
     await interaction.reply("Session cleared. Next message will start a fresh agent.");
   });
+  await ipcServer.start();
   process.on("SIGTERM", () => {
+    ipcServer.stop();
     sessionManager.teardownAll();
     discordClient.destroy();
   });
   process.on("SIGINT", () => {
+    ipcServer.stop();
     sessionManager.teardownAll();
     discordClient.destroy();
   });
@@ -741,15 +973,23 @@ async function startDiscordBot(config) {
     } else {
       console.error("Error: Failed to connect to Discord:", message);
     }
+    ipcServer.stop();
     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");
+var CONFIG_DIR = join2(homedir2(), ".acp-discord");
+var CONFIG_PATH = join2(CONFIG_DIR, "config.toml");
+var PID_PATH = join2(CONFIG_DIR, "daemon.pid");
 async function runDaemon() {
+  process.on("uncaughtException", (err) => {
+    console.error("Uncaught exception:", err);
+    setTimeout(() => process.exit(1), 1e3);
+  });
+  process.on("unhandledRejection", (reason) => {
+    console.error("Unhandled rejection:", reason);
+  });
   const config = loadConfig(CONFIG_PATH);
   writePid(PID_PATH, process.pid);
   process.on("exit", () => removePid(PID_PATH));