afk-code 0.1.0 → 0.1.3

package/dist/cli/index.js

@@ -0,0 +1,1972 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/slack/session-manager.ts
+import { watch } from "fs";
+import { readdir, readFile, stat, unlink } from "fs/promises";
+import { createServer } from "net";
+import { createHash } from "crypto";
+function hash(data) {
+  return createHash("md5").update(data).digest("hex");
+}
+var DAEMON_SOCKET2, SessionManager;
+var init_session_manager = __esm({
+  "src/slack/session-manager.ts"() {
+    "use strict";
+    DAEMON_SOCKET2 = "/tmp/afk-code-daemon.sock";
+    SessionManager = class {
+      sessions = /* @__PURE__ */ new Map();
+      claimedFiles = /* @__PURE__ */ new Set();
+      events;
+      server = null;
+      constructor(events) {
+        this.events = events;
+      }
+      async start() {
+        try {
+          await unlink(DAEMON_SOCKET2);
+        } catch {
+        }
+        this.server = createServer((socket) => {
+          let messageBuffer = "";
+          socket.on("data", (data) => {
+            messageBuffer += data.toString();
+            const lines = messageBuffer.split("\n");
+            messageBuffer = lines.pop() || "";
+            for (const line of lines) {
+              if (!line.trim()) continue;
+              try {
+                const parsed = JSON.parse(line);
+                this.handleSessionMessage(socket, parsed);
+              } catch (error) {
+                console.error("[SessionManager] Error parsing message:", error);
+              }
+            }
+          });
+          socket.on("error", (error) => {
+            console.error("[SessionManager] Socket error:", error);
+          });
+          socket.on("close", () => {
+            for (const [id, session] of this.sessions) {
+              if (session.socket === socket) {
+                console.log(`[SessionManager] Session disconnected: ${id}`);
+                this.stopWatching(session);
+                this.sessions.delete(id);
+                this.events.onSessionEnd(id);
+                break;
+              }
+            }
+          });
+        });
+        this.server.listen(DAEMON_SOCKET2, () => {
+          console.log(`[SessionManager] Listening on ${DAEMON_SOCKET2}`);
+        });
+      }
+      stop() {
+        for (const session of this.sessions.values()) {
+          this.stopWatching(session);
+        }
+        this.sessions.clear();
+        if (this.server) {
+          this.server.close();
+        }
+      }
+      sendInput(sessionId, text) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+          console.error(`[SessionManager] Session not found: ${sessionId}`);
+          return false;
+        }
+        try {
+          session.socket.write(JSON.stringify({ type: "input", text }) + "\n");
+        } catch (err) {
+          console.error(`[SessionManager] Failed to send input to ${sessionId}:`, err);
+          this.stopWatching(session);
+          this.sessions.delete(sessionId);
+          this.events.onSessionEnd(sessionId);
+          return false;
+        }
+        setTimeout(() => {
+          try {
+            session.socket.write(JSON.stringify({ type: "input", text: "\r" }) + "\n");
+          } catch {
+          }
+        }, 50);
+        return true;
+      }
+      getSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) return void 0;
+        return {
+          id: session.id,
+          name: session.name,
+          cwd: session.cwd,
+          projectDir: session.projectDir,
+          status: session.status,
+          startedAt: session.startedAt
+        };
+      }
+      getAllSessions() {
+        return Array.from(this.sessions.values()).map((s) => ({
+          id: s.id,
+          name: s.name,
+          cwd: s.cwd,
+          projectDir: s.projectDir,
+          status: s.status,
+          startedAt: s.startedAt
+        }));
+      }
+      async handleSessionMessage(socket, message) {
+        switch (message.type) {
+          case "session_start": {
+            const initialFileStats = await this.snapshotJsonlFiles(message.projectDir);
+            const session = {
+              id: message.id,
+              name: message.name || message.command?.join(" ") || "Session",
+              cwd: message.cwd,
+              projectDir: message.projectDir,
+              socket,
+              status: "running",
+              seenMessages: /* @__PURE__ */ new Set(),
+              startedAt: /* @__PURE__ */ new Date(),
+              slugFound: false,
+              lastTodosHash: "",
+              inPlanMode: false,
+              initialFileStats
+            };
+            this.sessions.set(message.id, session);
+            console.log(`[SessionManager] Session started: ${message.id} - ${session.name}`);
+            console.log(`[SessionManager] Snapshot: ${initialFileStats.size} existing JSONL files`);
+            this.events.onSessionStart({
+              id: session.id,
+              name: session.name,
+              cwd: session.cwd,
+              projectDir: session.projectDir,
+              status: session.status,
+              startedAt: session.startedAt
+            });
+            this.startWatching(session);
+            break;
+          }
+          case "session_end": {
+            const session = this.sessions.get(message.sessionId);
+            if (session) {
+              console.log(`[SessionManager] Session ended: ${message.sessionId}`);
+              this.stopWatching(session);
+              this.sessions.delete(message.sessionId);
+              this.events.onSessionEnd(message.sessionId);
+            }
+            break;
+          }
+        }
+      }
+      async snapshotJsonlFiles(projectDir) {
+        const stats = /* @__PURE__ */ new Map();
+        try {
+          const files = await readdir(projectDir);
+          for (const f of files) {
+            if (f.endsWith(".jsonl") && !f.startsWith("agent-")) {
+              const path = `${projectDir}/${f}`;
+              const fileStat = await stat(path);
+              stats.set(path, fileStat.mtimeMs);
+            }
+          }
+        } catch {
+        }
+        return stats;
+      }
+      async hasConversationMessages(path) {
+        try {
+          const content = await readFile(path, "utf-8");
+          return content.includes('"type":"user"') || content.includes('"type":"assistant"');
+        } catch {
+          return false;
+        }
+      }
+      async findActiveJsonlFile(session) {
+        try {
+          const files = await readdir(session.projectDir);
+          const jsonlFiles = files.filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
+          const allPaths = jsonlFiles.map((f) => `${session.projectDir}/${f}`).filter((path) => !this.claimedFiles.has(path));
+          if (allPaths.length === 0) return null;
+          const fileStats = await Promise.all(
+            allPaths.map(async (path) => {
+              const fileStat = await stat(path);
+              return { path, mtime: fileStat.mtimeMs };
+            })
+          );
+          fileStats.sort((a, b) => b.mtime - a.mtime);
+          for (const { path, mtime } of fileStats) {
+            const initialMtime = session.initialFileStats.get(path);
+            if (initialMtime !== void 0 && mtime > initialMtime) {
+              if (await this.hasConversationMessages(path)) {
+                console.log(`[SessionManager] Found modified JSONL (--continue): ${path}`);
+                return path;
+              }
+            }
+          }
+          for (const { path } of fileStats) {
+            const initialMtime = session.initialFileStats.get(path);
+            if (initialMtime === void 0) {
+              if (await this.hasConversationMessages(path)) {
+                console.log(`[SessionManager] Found new JSONL: ${path}`);
+                return path;
+              }
+            }
+          }
+          return null;
+        } catch {
+          return null;
+        }
+      }
+      async processJsonlUpdates(session) {
+        if (!session.watchedFile) return;
+        try {
+          const content = await readFile(session.watchedFile, "utf-8");
+          const lines = content.split("\n").filter(Boolean);
+          for (const line of lines) {
+            const lineHash = hash(line);
+            if (session.seenMessages.has(lineHash)) continue;
+            session.seenMessages.add(lineHash);
+            if (!session.slugFound) {
+              const slug = this.extractSlug(line);
+              if (slug) {
+                session.slugFound = true;
+                session.name = slug;
+                console.log(`[SessionManager] Session ${session.id} name: ${slug}`);
+                this.events.onSessionUpdate(session.id, slug);
+              }
+            }
+            const todos = this.extractTodos(line);
+            if (todos) {
+              const todosHash = hash(JSON.stringify(todos));
+              if (todosHash !== session.lastTodosHash) {
+                session.lastTodosHash = todosHash;
+                this.events.onTodos(session.id, todos);
+              }
+            }
+            const planModeStatus = this.detectPlanMode(line);
+            if (planModeStatus !== null && planModeStatus !== session.inPlanMode) {
+              session.inPlanMode = planModeStatus;
+              console.log(`[SessionManager] Session ${session.id} plan mode: ${planModeStatus}`);
+              this.events.onPlanModeChange(session.id, planModeStatus);
+            }
+            const toolCalls = this.extractToolCalls(line);
+            for (const tool of toolCalls) {
+              this.events.onToolCall(session.id, tool);
+            }
+            const toolResults = this.extractToolResults(line);
+            for (const result of toolResults) {
+              this.events.onToolResult(session.id, result);
+            }
+            const parsed = this.parseJsonlLine(line);
+            if (parsed) {
+              const messageTime = new Date(parsed.timestamp);
+              if (messageTime < session.startedAt) continue;
+              this.events.onMessage(session.id, parsed.role, parsed.content);
+            }
+          }
+        } catch (err) {
+          console.error("[SessionManager] Error processing JSONL:", err);
+        }
+      }
+      async startWatching(session) {
+        const jsonlFile = await this.findActiveJsonlFile(session);
+        if (jsonlFile) {
+          session.watchedFile = jsonlFile;
+          this.claimedFiles.add(jsonlFile);
+          console.log(`[SessionManager] Watching: ${jsonlFile}`);
+          await this.processJsonlUpdates(session);
+        } else {
+          console.log(`[SessionManager] Waiting for JSONL changes in ${session.projectDir}`);
+        }
+        try {
+          session.watcher = watch(session.projectDir, { recursive: false }, async (_, filename) => {
+            if (!filename?.endsWith(".jsonl")) return;
+            if (!session.watchedFile) {
+              const newFile = await this.findActiveJsonlFile(session);
+              if (newFile) {
+                session.watchedFile = newFile;
+                this.claimedFiles.add(newFile);
+              }
+            }
+            const filePath = `${session.projectDir}/${filename}`;
+            if (session.watchedFile && filePath === session.watchedFile) {
+              await this.processJsonlUpdates(session);
+            }
+          });
+        } catch (err) {
+          console.error("[SessionManager] Error setting up watcher:", err);
+        }
+        const pollInterval = setInterval(async () => {
+          if (!this.sessions.has(session.id)) {
+            clearInterval(pollInterval);
+            return;
+          }
+          if (!session.watchedFile) {
+            const newFile = await this.findActiveJsonlFile(session);
+            if (newFile) {
+              session.watchedFile = newFile;
+              this.claimedFiles.add(newFile);
+            }
+          }
+          if (session.watchedFile) {
+            await this.processJsonlUpdates(session);
+          }
+        }, 1e3);
+      }
+      stopWatching(session) {
+        if (session.watcher) {
+          session.watcher.close();
+        }
+        if (session.watchedFile) {
+          this.claimedFiles.delete(session.watchedFile);
+        }
+      }
+      detectPlanMode(line) {
+        try {
+          const data = JSON.parse(line);
+          if (data.type !== "user") return null;
+          const content = data.message?.content;
+          if (typeof content !== "string") return null;
+          if (content.includes("<system-reminder>") && content.includes("Plan mode is active")) {
+            return true;
+          }
+          if (content.includes("Exited Plan Mode") || content.includes("exited plan mode")) {
+            return false;
+          }
+          return null;
+        } catch {
+          return null;
+        }
+      }
+      extractToolCalls(line) {
+        try {
+          const data = JSON.parse(line);
+          if (data.type !== "assistant") return [];
+          const content = data.message?.content;
+          if (!Array.isArray(content)) return [];
+          const tools = [];
+          for (const block of content) {
+            if (block.type === "tool_use" && block.id && block.name) {
+              tools.push({
+                id: block.id,
+                name: block.name,
+                input: block.input || {}
+              });
+            }
+          }
+          return tools;
+        } catch {
+          return [];
+        }
+      }
+      extractToolResults(line) {
+        try {
+          const data = JSON.parse(line);
+          if (data.type !== "user") return [];
+          const content = data.message?.content;
+          if (!Array.isArray(content)) return [];
+          const results = [];
+          for (const block of content) {
+            if (block.type === "tool_result" && block.tool_use_id) {
+              let text = "";
+              if (typeof block.content === "string") {
+                text = block.content;
+              } else if (Array.isArray(block.content)) {
+                text = block.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+              }
+              results.push({
+                toolUseId: block.tool_use_id,
+                content: text,
+                isError: block.is_error === true
+              });
+            }
+          }
+          return results;
+        } catch {
+          return [];
+        }
+      }
+      extractSlug(line) {
+        try {
+          const data = JSON.parse(line);
+          if (data.slug && typeof data.slug === "string") {
+            return data.slug;
+          }
+          return null;
+        } catch {
+          return null;
+        }
+      }
+      extractTodos(line) {
+        try {
+          const data = JSON.parse(line);
+          if (data.todos && Array.isArray(data.todos) && data.todos.length > 0) {
+            return data.todos.map((t) => ({
+              content: t.content || "",
+              status: t.status || "pending",
+              activeForm: t.activeForm
+            }));
+          }
+          return null;
+        } catch {
+          return null;
+        }
+      }
+      parseJsonlLine(line) {
+        try {
+          const data = JSON.parse(line);
+          if (data.type !== "user" && data.type !== "assistant") return null;
+          if (data.isMeta || data.subtype) return null;
+          const message = data.message;
+          if (!message || !message.role) return null;
+          let content = "";
+          if (typeof message.content === "string") {
+            content = message.content;
+          } else if (Array.isArray(message.content)) {
+            for (const block of message.content) {
+              if (block.type === "text" && block.text) {
+                content += block.text;
+              }
+            }
+          }
+          if (!content.trim()) return null;
+          return {
+            role: message.role,
+            content: content.trim(),
+            timestamp: data.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+          };
+        } catch {
+          return null;
+        }
+      }
+    };
+  }
+});
+
+// src/slack/channel-manager.ts
+function sanitizeChannelName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-_\s]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 70);
+}
+var ChannelManager;
+var init_channel_manager = __esm({
+  "src/slack/channel-manager.ts"() {
+    "use strict";
+    ChannelManager = class {
+      channels = /* @__PURE__ */ new Map();
+      channelToSession = /* @__PURE__ */ new Map();
+      client;
+      userId;
+      constructor(client, userId) {
+        this.client = client;
+        this.userId = userId;
+      }
+      async createChannel(sessionId, sessionName, cwd) {
+        if (this.channels.has(sessionId)) {
+          return this.channels.get(sessionId);
+        }
+        const folderName = cwd.split("/").filter(Boolean).pop() || "session";
+        const baseName = `afk-${sanitizeChannelName(folderName)}`;
+        let channelName = baseName;
+        let suffix = 1;
+        let result;
+        while (true) {
+          const nameToTry = channelName.length > 80 ? channelName.slice(0, 80) : channelName;
+          try {
+            result = await this.client.conversations.create({
+              name: nameToTry,
+              is_private: true
+            });
+            channelName = nameToTry;
+            break;
+          } catch (err) {
+            if (err.data?.error === "name_taken") {
+              suffix++;
+              channelName = `${baseName}-${suffix}`;
+            } else {
+              throw err;
+            }
+          }
+        }
+        if (!result?.channel?.id) {
+          console.error("[ChannelManager] Failed to create channel - no ID returned");
+          return null;
+        }
+        const mapping = {
+          sessionId,
+          channelId: result.channel.id,
+          channelName,
+          sessionName,
+          status: "running",
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        this.channels.set(sessionId, mapping);
+        this.channelToSession.set(result.channel.id, sessionId);
+        try {
+          await this.client.conversations.setTopic({
+            channel: result.channel.id,
+            topic: `Claude Code session: ${sessionName}`
+          });
+        } catch (err) {
+          console.error("[ChannelManager] Failed to set topic:", err.message);
+        }
+        if (this.userId) {
+          try {
+            await this.client.conversations.invite({
+              channel: result.channel.id,
+              users: this.userId
+            });
+            console.log(`[ChannelManager] Invited user to channel`);
+          } catch (err) {
+            if (err.data?.error !== "already_in_channel") {
+              console.error("[ChannelManager] Failed to invite user:", err.message);
+            }
+          }
+        }
+        console.log(`[ChannelManager] Created channel #${channelName} for session ${sessionId}`);
+        return mapping;
+      }
+      async archiveChannel(sessionId) {
+        const mapping = this.channels.get(sessionId);
+        if (!mapping) return false;
+        try {
+          const timestamp = Date.now().toString(36);
+          const archivedName = `${mapping.channelName}-archived-${timestamp}`.slice(0, 80);
+          await this.client.conversations.rename({
+            channel: mapping.channelId,
+            name: archivedName
+          });
+          await this.client.conversations.archive({
+            channel: mapping.channelId
+          });
+          console.log(`[ChannelManager] Archived channel #${mapping.channelName}`);
+          return true;
+        } catch (err) {
+          console.error("[ChannelManager] Failed to archive channel:", err.message);
+          return false;
+        }
+      }
+      getChannel(sessionId) {
+        return this.channels.get(sessionId);
+      }
+      getSessionByChannel(channelId) {
+        return this.channelToSession.get(channelId);
+      }
+      updateStatus(sessionId, status) {
+        const mapping = this.channels.get(sessionId);
+        if (mapping) {
+          mapping.status = status;
+        }
+      }
+      updateName(sessionId, name) {
+        const mapping = this.channels.get(sessionId);
+        if (mapping) {
+          mapping.sessionName = name;
+        }
+      }
+      getAllActive() {
+        return Array.from(this.channels.values()).filter((c) => c.status !== "ended");
+      }
+    };
+  }
+});
+
+// src/slack/message-formatter.ts
+function markdownToSlack(markdown) {
+  let text = markdown;
+  text = text.replace(/\*\*(.+?)\*\*/g, "*$1*");
+  text = text.replace(/^#{1,6}\s+(.+)$/gm, "*$1*");
+  text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "<$2|$1>");
+  text = text.replace(/~~(.+?)~~/g, "~$1~");
+  return text;
+}
+function chunkMessage(text, maxLength = 39e3) {
+  if (text.length <= maxLength) return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLength) {
+      chunks.push(remaining);
+      break;
+    }
+    let breakPoint = remaining.lastIndexOf("\n", maxLength);
+    if (breakPoint === -1 || breakPoint < maxLength / 2) {
+      breakPoint = remaining.lastIndexOf(" ", maxLength);
+    }
+    if (breakPoint === -1 || breakPoint < maxLength / 2) {
+      breakPoint = maxLength;
+    }
+    chunks.push(remaining.slice(0, breakPoint));
+    remaining = remaining.slice(breakPoint).trimStart();
+  }
+  return chunks;
+}
+function formatSessionStatus(status) {
+  const icons = {
+    running: ":hourglass_flowing_sand:",
+    idle: ":white_check_mark:",
+    ended: ":stop_sign:"
+  };
+  const labels = {
+    running: "Running",
+    idle: "Idle",
+    ended: "Ended"
+  };
+  return `${icons[status]} ${labels[status]}`;
+}
+function formatTodos(todos) {
+  if (todos.length === 0) return "";
+  const icons = {
+    pending: ":white_circle:",
+    in_progress: ":large_blue_circle:",
+    completed: ":white_check_mark:"
+  };
+  return todos.map((t) => {
+    const icon = icons[t.status] || ":white_circle:";
+    const text = t.status === "in_progress" && t.activeForm ? t.activeForm : t.content;
+    return `${icon} ${text}`;
+  }).join("\n");
+}
+var init_message_formatter = __esm({
+  "src/slack/message-formatter.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/image-extractor.ts
+import { existsSync, statSync } from "fs";
+import { resolve } from "path";
+import { homedir as homedir2 } from "os";
+function extractImagePaths(content, cwd) {
+  const images = [];
+  const seen = /* @__PURE__ */ new Set();
+  PATH_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = PATH_PATTERN.exec(content)) !== null) {
+    const originalPath = (match[1] || match[2]).trim();
+    if (!originalPath || seen.has(originalPath)) continue;
+    seen.add(originalPath);
+    let resolvedPath = originalPath;
+    if (resolvedPath.startsWith("~/")) {
+      resolvedPath = resolve(homedir2(), resolvedPath.slice(2));
+    } else if (resolvedPath.startsWith("./") || resolvedPath.startsWith("../")) {
+      resolvedPath = resolve(cwd || process.cwd(), resolvedPath);
+    } else if (!resolvedPath.startsWith("/")) {
+      continue;
+    }
+    try {
+      if (existsSync(resolvedPath)) {
+        const stat2 = statSync(resolvedPath);
+        if (stat2.isFile()) {
+          const ext = resolvedPath.toLowerCase().slice(resolvedPath.lastIndexOf("."));
+          if (IMAGE_EXTENSIONS.has(ext)) {
+            images.push({ originalPath, resolvedPath });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return images;
+}
+var IMAGE_EXTENSIONS, PATH_PATTERN;
+var init_image_extractor = __esm({
+  "src/utils/image-extractor.ts"() {
+    "use strict";
+    IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".png",
+      ".jpg",
+      ".jpeg",
+      ".gif",
+      ".webp",
+      ".svg",
+      ".bmp",
+      ".ico",
+      ".tiff",
+      ".tif"
+    ]);
+    PATH_PATTERN = /(?:["'`]([^"'`\n]+\.(?:png|jpe?g|gif|webp|svg|bmp|ico|tiff?))|(?:^|[\s(])([~./][^\s)"'`\n]*\.(?:png|jpe?g|gif|webp|svg|bmp|ico|tiff?)))/gi;
+  }
+});
+
+// src/slack/slack-app.ts
+var slack_app_exports = {};
+__export(slack_app_exports, {
+  createSlackApp: () => createSlackApp
+});
+import { App, LogLevel } from "@slack/bolt";
+import { createReadStream } from "fs";
+function createSlackApp(config) {
+  const app = new App({
+    token: config.botToken,
+    appToken: config.appToken,
+    socketMode: true,
+    logLevel: LogLevel.INFO
+  });
+  const channelManager = new ChannelManager(app.client, config.userId);
+  const messageQueue = new MessageQueue();
+  const slackSentMessages = /* @__PURE__ */ new Set();
+  const sessionManager = new SessionManager({
+    onSessionStart: async (session) => {
+      const channel = await channelManager.createChannel(session.id, session.name, session.cwd);
+      if (channel) {
+        await messageQueue.add(
+          () => app.client.chat.postMessage({
+            channel: channel.channelId,
+            text: `${formatSessionStatus(session.status)} *Session started*
+\`${session.cwd}\``,
+            mrkdwn: true
+          })
+        );
+      }
+    },
+    onSessionEnd: async (sessionId) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (channel) {
+        channelManager.updateStatus(sessionId, "ended");
+        await messageQueue.add(
+          () => app.client.chat.postMessage({
+            channel: channel.channelId,
+            text: ":stop_sign: *Session ended* - this channel will be archived"
+          })
+        );
+        await channelManager.archiveChannel(sessionId);
+      }
+    },
+    onSessionUpdate: async (sessionId, name) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (channel) {
+        channelManager.updateName(sessionId, name);
+        try {
+          await app.client.conversations.setTopic({
+            channel: channel.channelId,
+            topic: `Claude Code session: ${name}`
+          });
+        } catch (err) {
+          console.error("[Slack] Failed to update channel topic:", err);
+        }
+      }
+    },
+    onSessionStatus: async (sessionId, status) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (channel) {
+        channelManager.updateStatus(sessionId, status);
+      }
+    },
+    onMessage: async (sessionId, role, content) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (channel) {
+        const formatted = markdownToSlack(content);
+        if (role === "user") {
+          const contentKey = content.trim();
+          if (slackSentMessages.has(contentKey)) {
+            slackSentMessages.delete(contentKey);
+            return;
+          }
+          const chunks = chunkMessage(formatted);
+          for (const chunk of chunks) {
+            try {
+              const userInfo = await app.client.users.info({ user: config.userId });
+              const userName = userInfo.user?.real_name || userInfo.user?.name || "User";
+              const userIcon = userInfo.user?.profile?.image_72;
+              await messageQueue.add(
+                () => app.client.chat.postMessage({
+                  channel: channel.channelId,
+                  text: chunk,
+                  username: userName,
+                  icon_url: userIcon,
+                  mrkdwn: true
+                })
+              );
+            } catch (err) {
+              console.error("[Slack] Failed to post message:", err);
+            }
+          }
+        } else {
+          const chunks = chunkMessage(formatted);
+          for (const chunk of chunks) {
+            try {
+              await messageQueue.add(
+                () => app.client.chat.postMessage({
+                  channel: channel.channelId,
+                  text: chunk,
+                  username: "Claude Code",
+                  icon_url: "https://claude.ai/favicon.ico",
+                  mrkdwn: true
+                })
+              );
+            } catch (err) {
+              console.error("[Slack] Failed to post message:", err);
+            }
+          }
+          const session = sessionManager.getSession(sessionId);
+          const images = extractImagePaths(content, session?.cwd);
+          for (const image of images) {
+            try {
+              console.log(`[Slack] Uploading image: ${image.resolvedPath}`);
+              await messageQueue.add(
+                () => app.client.files.uploadV2({
+                  channel_id: channel.channelId,
+                  file: createReadStream(image.resolvedPath),
+                  filename: image.resolvedPath.split("/").pop() || "image",
+                  initial_comment: `\u{1F4CE} ${image.originalPath}`
+                })
+              );
+            } catch (err) {
+              console.error("[Slack] Failed to upload image:", err);
+            }
+          }
+        }
+      }
+    },
+    onTodos: async (sessionId, todos) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (channel && todos.length > 0) {
+        const todosText = formatTodos(todos);
+        try {
+          await messageQueue.add(
+            () => app.client.chat.postMessage({
+              channel: channel.channelId,
+              text: `*Tasks:*
+${todosText}`,
+              mrkdwn: true
+            })
+          );
+        } catch (err) {
+          console.error("[Slack] Failed to post todos:", err);
+        }
+      }
+    },
+    onToolCall: async (_sessionId, _tool) => {
+    },
+    onToolResult: async (_sessionId, _result) => {
+    },
+    onPlanModeChange: async (sessionId, inPlanMode) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (!channel) return;
+      const emoji = inPlanMode ? ":clipboard:" : ":hammer:";
+      const status = inPlanMode ? "Planning mode - Claude is designing a solution" : "Execution mode - Claude is implementing";
+      try {
+        await messageQueue.add(
+          () => app.client.chat.postMessage({
+            channel: channel.channelId,
+            text: `${emoji} ${status}`,
+            mrkdwn: true
+          })
+        );
+      } catch (err) {
+        console.error("[Slack] Failed to post plan mode change:", err);
+      }
+    }
+  });
+  app.message(async ({ message, say }) => {
+    if ("subtype" in message && message.subtype) return;
+    if (!("text" in message) || !message.text) return;
+    if (!("channel" in message) || !message.channel) return;
+    if ("bot_id" in message && message.bot_id) return;
+    if ("thread_ts" in message && message.thread_ts) return;
+    const sessionId = channelManager.getSessionByChannel(message.channel);
+    if (!sessionId) return;
+    const channel = channelManager.getChannel(sessionId);
+    if (!channel || channel.status === "ended") {
+      await say(":warning: This session has ended.");
+      return;
+    }
+    console.log(`[Slack] Sending input to session ${sessionId}: ${message.text.slice(0, 50)}...`);
+    slackSentMessages.add(message.text.trim());
+    const sent = sessionManager.sendInput(sessionId, message.text);
+    if (!sent) {
+      slackSentMessages.delete(message.text.trim());
+      await say(":warning: Failed to send input - session not connected.");
+    }
+  });
+  app.command("/afk", async ({ command: command2, ack, respond }) => {
+    await ack();
+    const subcommand = command2.text.trim().split(" ")[0];
+    if (subcommand === "sessions" || !subcommand) {
+      const active = channelManager.getAllActive();
+      if (active.length === 0) {
+        await respond("No active sessions. Start a session with `afk-code run -- claude`");
+        return;
+      }
+      const text = active.map((c) => `<#${c.channelId}> - ${formatSessionStatus(c.status)}`).join("\n");
+      await respond({
+        text: `*Active Sessions:*
+${text}`,
+        mrkdwn: true
+      });
+    } else {
+      await respond("Unknown command. Available: `/afk sessions`");
+    }
+  });
+  app.command("/background", async ({ command: command2, ack, respond }) => {
+    await ack();
+    const sessionId = channelManager.getSessionByChannel(command2.channel_id);
+    if (!sessionId) {
+      await respond(":warning: This channel is not associated with an active session.");
+      return;
+    }
+    const channel = channelManager.getChannel(sessionId);
+    if (!channel || channel.status === "ended") {
+      await respond(":warning: This session has ended.");
+      return;
+    }
+    const sent = sessionManager.sendInput(sessionId, "");
+    if (sent) {
+      await respond(":arrow_heading_down: Sent background command (Ctrl+B)");
+    } else {
+      await respond(":warning: Failed to send command - session not connected.");
+    }
+  });
+  app.command("/interrupt", async ({ command: command2, ack, respond }) => {
+    await ack();
+    const sessionId = channelManager.getSessionByChannel(command2.channel_id);
+    if (!sessionId) {
+      await respond(":warning: This channel is not associated with an active session.");
+      return;
+    }
+    const channel = channelManager.getChannel(sessionId);
+    if (!channel || channel.status === "ended") {
+      await respond(":warning: This session has ended.");
+      return;
+    }
+    const sent = sessionManager.sendInput(sessionId, "\x1B");
+    if (sent) {
+      await respond(":stop_sign: Sent interrupt (Escape)");
+    } else {
+      await respond(":warning: Failed to send command - session not connected.");
+    }
+  });
+  app.command("/mode", async ({ command: command2, ack, respond }) => {
+    await ack();
+    const sessionId = channelManager.getSessionByChannel(command2.channel_id);
+    if (!sessionId) {
+      await respond(":warning: This channel is not associated with an active session.");
+      return;
+    }
+    const channel = channelManager.getChannel(sessionId);
+    if (!channel || channel.status === "ended") {
+      await respond(":warning: This session has ended.");
+      return;
+    }
+    const sent = sessionManager.sendInput(sessionId, "\x1B[Z");
+    if (sent) {
+      await respond(":arrows_counterclockwise: Sent mode toggle (Shift+Tab)");
+    } else {
+      await respond(":warning: Failed to send command - session not connected.");
+    }
+  });
+  app.event("app_home_opened", async ({ event, client }) => {
+    const active = channelManager.getAllActive();
+    const blocks = [
+      {
+        type: "header",
+        text: { type: "plain_text", text: "AFK Code Sessions", emoji: true }
+      },
+      { type: "divider" }
+    ];
+    if (active.length === 0) {
+      blocks.push({
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: "_No active sessions_\n\nStart a session with `afk-code run -- claude`"
+        }
+      });
+    } else {
+      for (const c of active) {
+        blocks.push({
+          type: "section",
+          text: {
+            type: "mrkdwn",
+            text: `*${c.sessionName}*
+${formatSessionStatus(c.status)}
+<#${c.channelId}>`
+          }
+        });
+      }
+    }
+    try {
+      await client.views.publish({
+        user_id: event.user,
+        view: {
+          type: "home",
+          blocks
+        }
+      });
+    } catch (err) {
+      console.error("[Slack] Failed to publish home view:", err);
+    }
+  });
+  return { app, sessionManager, channelManager };
+}
+var MessageQueue;
+var init_slack_app = __esm({
+  "src/slack/slack-app.ts"() {
+    "use strict";
+    init_session_manager();
+    init_channel_manager();
+    init_message_formatter();
+    init_image_extractor();
+    MessageQueue = class {
+      queue = [];
+      processing = false;
+      minDelay = 350;
+      // ms between messages (Slack allows ~1/sec but be safe)
+      async add(fn) {
+        return new Promise((resolve2, reject) => {
+          this.queue.push(async () => {
+            try {
+              const result = await fn();
+              resolve2(result);
+            } catch (err) {
+              reject(err);
+            }
+          });
+          this.process();
+        });
+      }
+      async process() {
+        if (this.processing) return;
+        this.processing = true;
+        while (this.queue.length > 0) {
+          const fn = this.queue.shift();
+          if (fn) {
+            await fn();
+            if (this.queue.length > 0) {
+              await new Promise((r) => setTimeout(r, this.minDelay));
+            }
+          }
+        }
+        this.processing = false;
+      }
+    };
+  }
+});
+
+// src/discord/channel-manager.ts
+import { ChannelType } from "discord.js";
+function sanitizeChannelName2(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-_\s]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 90);
+}
+var ChannelManager2;
+var init_channel_manager2 = __esm({
+  "src/discord/channel-manager.ts"() {
+    "use strict";
+    ChannelManager2 = class {
+      channels = /* @__PURE__ */ new Map();
+      channelToSession = /* @__PURE__ */ new Map();
+      client;
+      userId;
+      guild = null;
+      category = null;
+      constructor(client, userId) {
+        this.client = client;
+        this.userId = userId;
+      }
+      async initialize() {
+        const guilds = await this.client.guilds.fetch();
+        if (guilds.size === 0) {
+          throw new Error("Bot is not in any servers. Please invite the bot first.");
+        }
+        const guildId = guilds.first().id;
+        this.guild = await this.client.guilds.fetch(guildId);
+        const existingCategory = this.guild.channels.cache.find(
+          (ch) => ch.type === ChannelType.GuildCategory && ch.name.toLowerCase() === "afk code sessions"
+        );
+        if (existingCategory) {
+          this.category = existingCategory;
+        } else {
+          this.category = await this.guild.channels.create({
+            name: "AFK Code Sessions",
+            type: ChannelType.GuildCategory
+          });
+        }
+        console.log(`[ChannelManager] Using guild: ${this.guild.name}`);
+        console.log(`[ChannelManager] Using category: ${this.category.name}`);
+      }
+      async createChannel(sessionId, sessionName, cwd) {
+        if (!this.guild || !this.category) {
+          console.error("[ChannelManager] Not initialized");
+          return null;
+        }
+        if (this.channels.has(sessionId)) {
+          return this.channels.get(sessionId);
+        }
+        const folderName = cwd.split("/").filter(Boolean).pop() || "session";
+        const baseName = `afk-${sanitizeChannelName2(folderName)}`;
+        let channelName = baseName;
+        let suffix = 1;
+        let channel = null;
+        while (true) {
+          const nameToTry = channelName.length > 100 ? channelName.slice(0, 100) : channelName;
+          const existing = this.guild.channels.cache.find(
+            (ch) => ch.name === nameToTry && ch.parentId === this.category.id
+          );
+          if (!existing) {
+            try {
+              channel = await this.guild.channels.create({
+                name: nameToTry,
+                type: ChannelType.GuildText,
+                parent: this.category,
+                topic: `Claude Code session: ${sessionName}`
+              });
+              channelName = nameToTry;
+              break;
+            } catch (err) {
+              console.error("[ChannelManager] Failed to create channel:", err.message);
+              return null;
+            }
+          } else {
+            suffix++;
+            channelName = `${baseName}-${suffix}`;
+          }
+        }
+        if (!channel) {
+          return null;
+        }
+        const mapping = {
+          sessionId,
+          channelId: channel.id,
+          channelName,
+          sessionName,
+          status: "running",
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        this.channels.set(sessionId, mapping);
+        this.channelToSession.set(channel.id, sessionId);
+        console.log(`[ChannelManager] Created channel #${channelName} for session ${sessionId}`);
+        return mapping;
+      }
+      async archiveChannel(sessionId) {
+        if (!this.guild) return false;
+        const mapping = this.channels.get(sessionId);
+        if (!mapping) return false;
+        try {
+          const channel = await this.guild.channels.fetch(mapping.channelId);
+          if (channel && channel.type === ChannelType.GuildText) {
+            const timestamp = Date.now().toString(36);
+            const archivedName = `${mapping.channelName}-archived-${timestamp}`.slice(0, 100);
+            await channel.setName(archivedName);
+            console.log(`[ChannelManager] Archived channel #${mapping.channelName}`);
+          }
+          return true;
+        } catch (err) {
+          console.error("[ChannelManager] Failed to archive channel:", err.message);
+          return false;
+        }
+      }
+      getChannel(sessionId) {
+        return this.channels.get(sessionId);
+      }
+      getSessionByChannel(channelId) {
+        return this.channelToSession.get(channelId);
+      }
+      updateStatus(sessionId, status) {
+        const mapping = this.channels.get(sessionId);
+        if (mapping) {
+          mapping.status = status;
+        }
+      }
+      updateName(sessionId, name) {
+        const mapping = this.channels.get(sessionId);
+        if (mapping) {
+          mapping.sessionName = name;
+        }
+      }
+      getAllActive() {
+        return Array.from(this.channels.values()).filter((c) => c.status !== "ended");
+      }
+    };
+  }
+});
+
+// src/discord/discord-app.ts
+var discord_app_exports = {};
+__export(discord_app_exports, {
+  createDiscordApp: () => createDiscordApp
+});
+import { Client, GatewayIntentBits, Events, ChannelType as ChannelType2, AttachmentBuilder, REST, Routes, SlashCommandBuilder } from "discord.js";
+function createDiscordApp(config) {
+  const client = new Client({
+    intents: [
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.MessageContent
+    ]
+  });
+  const channelManager = new ChannelManager2(client, config.userId);
+  const discordSentMessages = /* @__PURE__ */ new Set();
+  const toolCallMessages = /* @__PURE__ */ new Map();
+  const sessionManager = new SessionManager({
+    onSessionStart: async (session) => {
+      const channel = await channelManager.createChannel(session.id, session.name, session.cwd);
+      if (channel) {
+        const discordChannel = await client.channels.fetch(channel.channelId);
+        if (discordChannel?.type === ChannelType2.GuildText) {
+          await discordChannel.send(
+            `${formatSessionStatus(session.status)} **Session started**
+\`${session.cwd}\``
+          );
+        }
+      }
+    },
+    onSessionEnd: async (sessionId) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (channel) {
+        channelManager.updateStatus(sessionId, "ended");
+        const discordChannel = await client.channels.fetch(channel.channelId);
+        if (discordChannel?.type === ChannelType2.GuildText) {
+          await discordChannel.send("\u{1F6D1} **Session ended** - this channel will be archived");
+        }
+        await channelManager.archiveChannel(sessionId);
+      }
+    },
+    onSessionUpdate: async (sessionId, name) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (channel) {
+        channelManager.updateName(sessionId, name);
+        try {
+          const discordChannel = await client.channels.fetch(channel.channelId);
+          if (discordChannel?.type === ChannelType2.GuildText) {
+            await discordChannel.setTopic(`Claude Code session: ${name}`);
+          }
+        } catch (err) {
+          console.error("[Discord] Failed to update channel topic:", err);
+        }
+      }
+    },
+    onSessionStatus: async (sessionId, status) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (channel) {
+        channelManager.updateStatus(sessionId, status);
+      }
+    },
+    onMessage: async (sessionId, role, content) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (channel) {
+        const formatted = content;
+        if (role === "user") {
+          const contentKey = content.trim();
+          if (discordSentMessages.has(contentKey)) {
+            discordSentMessages.delete(contentKey);
+            return;
+          }
+          const discordChannel = await client.channels.fetch(channel.channelId);
+          if (discordChannel?.type === ChannelType2.GuildText) {
+            const chunks = chunkMessage(formatted);
+            for (const chunk of chunks) {
+              await discordChannel.send(`**User:** ${chunk}`);
+            }
+          }
+        } else {
+          const discordChannel = await client.channels.fetch(channel.channelId);
+          if (discordChannel?.type === ChannelType2.GuildText) {
+            const chunks = chunkMessage(formatted);
+            for (const chunk of chunks) {
+              await discordChannel.send(chunk);
+            }
+            const session = sessionManager.getSession(sessionId);
+            const images = extractImagePaths(content, session?.cwd);
+            for (const image of images) {
+              try {
+                console.log(`[Discord] Uploading image: ${image.resolvedPath}`);
+                const attachment = new AttachmentBuilder(image.resolvedPath);
+                await discordChannel.send({
+                  content: `\u{1F4CE} ${image.originalPath}`,
+                  files: [attachment]
+                });
+              } catch (err) {
+                console.error("[Discord] Failed to upload image:", err);
+              }
+            }
+          }
+        }
+      }
+    },
+    onTodos: async (sessionId, todos) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (channel && todos.length > 0) {
+        const todosText = formatTodos(todos);
+        try {
+          const discordChannel = await client.channels.fetch(channel.channelId);
+          if (discordChannel?.type === ChannelType2.GuildText) {
+            await discordChannel.send(`**Tasks:**
+${todosText}`);
+          }
+        } catch (err) {
+          console.error("[Discord] Failed to post todos:", err);
+        }
+      }
+    },
+    onToolCall: async (sessionId, tool) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (!channel) return;
+      let inputSummary = "";
+      if (tool.name === "Bash" && tool.input.command) {
+        inputSummary = `\`${tool.input.command.slice(0, 100)}${tool.input.command.length > 100 ? "..." : ""}\``;
+      } else if (tool.name === "Read" && tool.input.file_path) {
+        inputSummary = `\`${tool.input.file_path}\``;
+      } else if (tool.name === "Edit" && tool.input.file_path) {
+        inputSummary = `\`${tool.input.file_path}\``;
+      } else if (tool.name === "Write" && tool.input.file_path) {
+        inputSummary = `\`${tool.input.file_path}\``;
+      } else if (tool.name === "Grep" && tool.input.pattern) {
+        inputSummary = `\`${tool.input.pattern}\``;
+      } else if (tool.name === "Glob" && tool.input.pattern) {
+        inputSummary = `\`${tool.input.pattern}\``;
+      } else if (tool.name === "Task" && tool.input.description) {
+        inputSummary = tool.input.description;
+      }
+      const text = inputSummary ? `\u{1F527} **${tool.name}**: ${inputSummary}` : `\u{1F527} **${tool.name}**`;
+      try {
+        const discordChannel = await client.channels.fetch(channel.channelId);
+        if (discordChannel?.type === ChannelType2.GuildText) {
+          const message = await discordChannel.send(text);
+          toolCallMessages.set(tool.id, message.id);
+        }
+      } catch (err) {
+        console.error("[Discord] Failed to post tool call:", err);
+      }
+    },
+    onToolResult: async (sessionId, result) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (!channel) return;
+      const parentMessageId = toolCallMessages.get(result.toolUseId);
+      if (!parentMessageId) return;
+      const maxLen = 1800;
+      let content = result.content;
+      if (content.length > maxLen) {
+        content = content.slice(0, maxLen) + "\n... (truncated)";
+      }
+      const prefix = result.isError ? "\u274C Error:" : "\u2705 Result:";
+      const text = `${prefix}
+\`\`\`
+${content}
+\`\`\``;
+      try {
+        const discordChannel = await client.channels.fetch(channel.channelId);
+        if (discordChannel?.type === ChannelType2.GuildText) {
+          const parentMessage = await discordChannel.messages.fetch(parentMessageId);
+          if (parentMessage) {
+            let thread = parentMessage.thread;
+            if (!thread) {
+              thread = await parentMessage.startThread({
+                name: "Result",
+                autoArchiveDuration: 60
+              });
+            }
+            await thread.send(text);
+          }
+          toolCallMessages.delete(result.toolUseId);
+        }
+      } catch (err) {
+        console.error("[Discord] Failed to post tool result:", err);
+      }
+    },
+    onPlanModeChange: async (sessionId, inPlanMode) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (!channel) return;
+      const emoji = inPlanMode ? "\u{1F4CB}" : "\u{1F528}";
+      const status = inPlanMode ? "Planning mode - Claude is designing a solution" : "Execution mode - Claude is implementing";
+      try {
+        const discordChannel = await client.channels.fetch(channel.channelId);
+        if (discordChannel?.type === ChannelType2.GuildText) {
+          await discordChannel.send(`${emoji} ${status}`);
+        }
+      } catch (err) {
+        console.error("[Discord] Failed to post plan mode change:", err);
+      }
+    }
+  });
+  client.on(Events.MessageCreate, async (message) => {
+    if (message.author.bot) return;
+    if (!message.guild) return;
+    const sessionId = channelManager.getSessionByChannel(message.channelId);
+    if (!sessionId) return;
+    const channel = channelManager.getChannel(sessionId);
+    if (!channel || channel.status === "ended") {
+      await message.reply("\u26A0\uFE0F This session has ended.");
+      return;
+    }
+    console.log(`[Discord] Sending input to session ${sessionId}: ${message.content.slice(0, 50)}...`);
+    discordSentMessages.add(message.content.trim());
+    const sent = sessionManager.sendInput(sessionId, message.content);
+    if (!sent) {
+      discordSentMessages.delete(message.content.trim());
+      await message.reply("\u26A0\uFE0F Failed to send input - session not connected.");
+    }
+  });
+  client.once(Events.ClientReady, async (c) => {
+    console.log(`[Discord] Logged in as ${c.user.tag}`);
+    await channelManager.initialize();
+    const commands = [
+      new SlashCommandBuilder().setName("background").setDescription("Send Claude to background mode (Ctrl+B)"),
+      new SlashCommandBuilder().setName("interrupt").setDescription("Interrupt Claude (Escape)"),
+      new SlashCommandBuilder().setName("mode").setDescription("Toggle Claude mode (Shift+Tab)"),
+      new SlashCommandBuilder().setName("afk").setDescription("List active Claude Code sessions")
+    ];
+    try {
+      const rest = new REST({ version: "10" }).setToken(config.botToken);
+      await rest.put(Routes.applicationCommands(c.user.id), {
+        body: commands.map((cmd) => cmd.toJSON())
+      });
+      console.log("[Discord] Slash commands registered");
+    } catch (err) {
+      console.error("[Discord] Failed to register slash commands:", err);
+    }
+  });
+  client.on(Events.InteractionCreate, async (interaction) => {
+    if (!interaction.isChatInputCommand()) return;
+    const { commandName, channelId } = interaction;
+    if (commandName === "afk") {
+      const active = channelManager.getAllActive();
+      if (active.length === 0) {
+        await interaction.reply("No active sessions. Start a session with `afk-code run -- claude`");
+        return;
+      }
+      const text = active.map((c) => `<#${c.channelId}> - ${formatSessionStatus(c.status)}`).join("\n");
+      await interaction.reply(`**Active Sessions:**
+${text}`);
+      return;
+    }
+    if (commandName === "background" || commandName === "interrupt" || commandName === "mode") {
+      const sessionId = channelManager.getSessionByChannel(channelId);
+      if (!sessionId) {
+        await interaction.reply("\u26A0\uFE0F This channel is not associated with an active session.");
+        return;
+      }
+      const channel = channelManager.getChannel(sessionId);
+      if (!channel || channel.status === "ended") {
+        await interaction.reply("\u26A0\uFE0F This session has ended.");
+        return;
+      }
+      let key;
+      let message;
+      if (commandName === "background") {
+        key = "";
+        message = "\u2B07\uFE0F Sent background command (Ctrl+B)";
+      } else if (commandName === "interrupt") {
+        key = "\x1B";
+        message = "\u{1F6D1} Sent interrupt (Escape)";
+      } else {
+        key = "\x1B[Z";
+        message = "\u{1F504} Sent mode toggle (Shift+Tab)";
+      }
+      const sent = sessionManager.sendInput(sessionId, key);
+      if (sent) {
+        await interaction.reply(message);
+      } else {
+        await interaction.reply("\u26A0\uFE0F Failed to send command - session not connected.");
+      }
+    }
+  });
+  return { client, sessionManager, channelManager };
+}
+var init_discord_app = __esm({
+  "src/discord/discord-app.ts"() {
+    "use strict";
+    init_session_manager();
+    init_channel_manager2();
+    init_message_formatter();
+    init_image_extractor();
+  }
+});
+
+// src/cli/run.ts
+import { randomUUID } from "crypto";
+import { homedir } from "os";
+import { createConnection } from "net";
+import * as pty from "node-pty";
+var DAEMON_SOCKET = "/tmp/afk-code-daemon.sock";
+function getClaudeProjectDir(cwd) {
+  const encodedPath = cwd.replace(/\//g, "-");
+  return `${homedir()}/.claude/projects/${encodedPath}`;
+}
+function connectToDaemon(sessionId, projectDir, cwd, command2, onInput) {
+  return new Promise((resolve2) => {
+    const socket = createConnection(DAEMON_SOCKET);
+    let messageBuffer = "";
+    socket.on("connect", () => {
+      socket.write(JSON.stringify({
+        type: "session_start",
+        id: sessionId,
+        projectDir,
+        cwd,
+        command: command2,
+        name: command2.join(" ")
+      }) + "\n");
+      resolve2({
+        close: () => {
+          socket.write(JSON.stringify({ type: "session_end", sessionId }) + "\n");
+          socket.end();
+        }
+      });
+    });
+    socket.on("data", (data) => {
+      messageBuffer += data.toString();
+      const lines = messageBuffer.split("\n");
+      messageBuffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const msg = JSON.parse(line);
+          if (msg.type === "input" && msg.text) {
+            onInput(msg.text);
+          }
+        } catch {
+        }
+      }
+    });
+    socket.on("error", (error) => {
+      resolve2(null);
+    });
+  });
+}
+async function run(command2) {
+  const sessionId = randomUUID().slice(0, 8);
+  const cwd = process.cwd();
+  const projectDir = getClaudeProjectDir(cwd);
+  const cols = process.stdout.columns || 80;
+  const rows = process.stdout.rows || 24;
+  const ptyProcess = pty.spawn(command2[0], command2.slice(1), {
+    name: process.env.TERM || "xterm-256color",
+    cols,
+    rows,
+    cwd,
+    env: process.env
+  });
+  const daemon = await connectToDaemon(
+    sessionId,
+    projectDir,
+    cwd,
+    command2,
+    (text) => {
+      ptyProcess.write(text);
+    }
+  );
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  ptyProcess.onData((data) => {
+    process.stdout.write(data);
+  });
+  const onStdinData = (data) => {
+    ptyProcess.write(data.toString());
+  };
+  process.stdin.on("data", onStdinData);
+  process.stdout.on("resize", () => {
+    ptyProcess.resize(process.stdout.columns || 80, process.stdout.rows || 24);
+  });
+  await new Promise((resolve2) => {
+    ptyProcess.onExit(() => {
+      process.stdin.removeListener("data", onStdinData);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      if (typeof process.stdin.unref === "function") {
+        process.stdin.unref();
+      }
+      daemon?.close();
+      resolve2();
+    });
+  });
+}
+
+// src/cli/slack.ts
+import { homedir as homedir3 } from "os";
+import { mkdir, writeFile, readFile as readFile2, access } from "fs/promises";
+import * as readline from "readline";
+var CONFIG_DIR = `${homedir3()}/.afk-code`;
+var SLACK_CONFIG_FILE = `${CONFIG_DIR}/slack.env`;
+var MANIFEST_URL = "https://github.com/clharman/afk-code/blob/main/slack-manifest.json";
+function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+}
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function slackSetup() {
+  console.log(`
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502                  AFK Code Slack Setup                       \u2502
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+
+This will guide you through setting up the Slack bot for
+monitoring Claude Code sessions.
+
+Step 1: Create a Slack App
+\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+1. Go to: https://api.slack.com/apps
+2. Click "Create New App" \u2192 "From manifest"
+3. Select your workspace
+4. Paste the manifest from: ${MANIFEST_URL}
+   (Or copy from slack-manifest.json in this repo)
+5. Click "Create"
+
+Step 2: Install the App
+\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+1. Go to "Install App" in the sidebar
+2. Click "Install to Workspace"
+3. Authorize the app
+
+Step 3: Get Your Tokens
+\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+`);
+  await prompt("Press Enter when you have created and installed the app...");
+  console.log(`
+Now let's collect your tokens:
+
+\u2022 Bot Token: "OAuth & Permissions" \u2192 "Bot User OAuth Token" (starts with xoxb-)
+\u2022 App Token: "Basic Information" \u2192 "App-Level Tokens" \u2192 Generate one with
+  "connections:write" scope (starts with xapp-)
+\u2022 User ID: Click your profile in Slack \u2192 "..." \u2192 "Copy member ID"
+`);
+  const botToken = await prompt("Bot Token (xoxb-...): ");
+  if (!botToken.startsWith("xoxb-")) {
+    console.error("Invalid bot token. Should start with xoxb-");
+    process.exit(1);
+  }
+  const appToken = await prompt("App Token (xapp-...): ");
+  if (!appToken.startsWith("xapp-")) {
+    console.error("Invalid app token. Should start with xapp-");
+    process.exit(1);
+  }
+  const userId = await prompt("Your Slack User ID (U...): ");
+  if (!userId.startsWith("U")) {
+    console.error("Invalid user ID. Should start with U");
+    process.exit(1);
+  }
+  await mkdir(CONFIG_DIR, { recursive: true });
+  const envContent = `# AFK Code Slack Configuration
+SLACK_BOT_TOKEN=${botToken}
+SLACK_APP_TOKEN=${appToken}
+SLACK_USER_ID=${userId}
+`;
+  await writeFile(SLACK_CONFIG_FILE, envContent);
+  console.log(`
+\u2713 Configuration saved to ${SLACK_CONFIG_FILE}
+
+To start the Slack bot, run:
+  afk-code slack
+
+Then start a Claude Code session with:
+  afk-code run -- claude
+`);
+}
+async function loadEnvFile(path) {
+  if (!await fileExists(path)) return {};
+  const content = await readFile2(path, "utf-8");
+  const config = {};
+  for (const line of content.split("\n")) {
+    if (line.startsWith("#") || !line.includes("=")) continue;
+    const [key, ...valueParts] = line.split("=");
+    config[key.trim()] = valueParts.join("=").trim();
+  }
+  return config;
+}
+async function slackRun() {
+  const globalConfig = await loadEnvFile(SLACK_CONFIG_FILE);
+  const localConfig = await loadEnvFile(`${process.cwd()}/.env`);
+  const config = {
+    ...globalConfig,
+    ...localConfig
+  };
+  if (process.env.SLACK_BOT_TOKEN) config.SLACK_BOT_TOKEN = process.env.SLACK_BOT_TOKEN;
+  if (process.env.SLACK_APP_TOKEN) config.SLACK_APP_TOKEN = process.env.SLACK_APP_TOKEN;
+  if (process.env.SLACK_USER_ID) config.SLACK_USER_ID = process.env.SLACK_USER_ID;
+  const required = ["SLACK_BOT_TOKEN", "SLACK_APP_TOKEN", "SLACK_USER_ID"];
+  const missing = required.filter((key) => !config[key]);
+  if (missing.length > 0) {
+    console.error(`Missing config: ${missing.join(", ")}`);
+    console.error("");
+    console.error("Provide tokens via:");
+    console.error("  - Environment variables (SLACK_BOT_TOKEN, SLACK_APP_TOKEN, SLACK_USER_ID)");
+    console.error("  - Local .env file");
+    console.error('  - Run "afk-code slack setup" for guided configuration');
+    process.exit(1);
+  }
+  process.env.SLACK_BOT_TOKEN = config.SLACK_BOT_TOKEN;
+  process.env.SLACK_APP_TOKEN = config.SLACK_APP_TOKEN;
+  process.env.SLACK_USER_ID = config.SLACK_USER_ID;
+  const { createSlackApp: createSlackApp2 } = await Promise.resolve().then(() => (init_slack_app(), slack_app_exports));
+  const localEnvExists = await fileExists(`${process.cwd()}/.env`);
+  const globalEnvExists = await fileExists(SLACK_CONFIG_FILE);
+  const source = localEnvExists ? ".env" : globalEnvExists ? SLACK_CONFIG_FILE : "environment";
+  console.log(`[AFK Code] Loaded config from ${source}`);
+  console.log("[AFK Code] Starting Slack bot...");
+  const slackConfig = {
+    botToken: config.SLACK_BOT_TOKEN,
+    appToken: config.SLACK_APP_TOKEN,
+    signingSecret: "",
+    userId: config.SLACK_USER_ID
+  };
+  const { app, sessionManager } = createSlackApp2(slackConfig);
+  try {
+    await sessionManager.start();
+    console.log("[AFK Code] Session manager started");
+  } catch (err) {
+    console.error("[AFK Code] Failed to start session manager:", err);
+    process.exit(1);
+  }
+  try {
+    await app.start();
+    console.log("[AFK Code] Slack bot is running!");
+    console.log("");
+    console.log("Start a Claude Code session with: afk-code run -- claude");
+    console.log("Each session will create a private #afk-* channel");
+  } catch (err) {
+    console.error("[AFK Code] Failed to start Slack app:", err);
+    process.exit(1);
+  }
+}
+
+// src/cli/discord.ts
+import { homedir as homedir4 } from "os";
+import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile3, access as access2 } from "fs/promises";
+import * as readline2 from "readline";
+var CONFIG_DIR2 = `${homedir4()}/.afk-code`;
+var DISCORD_CONFIG_FILE = `${CONFIG_DIR2}/discord.env`;
+function prompt2(question) {
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+}
+async function fileExists2(path) {
+  try {
+    await access2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function discordSetup() {
+  console.log(`
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502                 AFK Code Discord Setup                      \u2502
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+
+This will guide you through setting up the Discord bot for
+monitoring Claude Code sessions.
+
+Step 1: Create a Discord Application
+\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+1. Go to: https://discord.com/developers/applications
+2. Click "New Application"
+3. Give it a name (e.g., "AFK Code")
+4. Click "Create"
+
+Step 2: Create a Bot
+\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+1. Go to "Bot" in the sidebar
+2. Click "Add Bot" \u2192 "Yes, do it!"
+3. Under "Privileged Gateway Intents", enable:
+   \u2022 MESSAGE CONTENT INTENT
+4. Click "Reset Token" and copy the token
+
+Step 3: Invite the Bot
+\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+1. Go to "OAuth2" \u2192 "URL Generator"
+2. Select scopes: "bot"
+3. Select permissions:
+   \u2022 Send Messages
+   \u2022 Manage Channels
+   \u2022 Read Message History
+4. Copy the URL and open it to invite the bot to your server
+`);
+  await prompt2("Press Enter when you have created and invited the bot...");
+  console.log(`
+Now let's collect your credentials:
+
+\u2022 Bot Token: "Bot" \u2192 "Token" (click "Reset Token" if needed)
+\u2022 Your User ID: Enable Developer Mode in Discord settings,
+  then right-click your name \u2192 "Copy User ID"
+`);
+  const botToken = await prompt2("Bot Token: ");
+  if (!botToken || botToken.length < 50) {
+    console.error("Invalid bot token.");
+    process.exit(1);
+  }
+  const userId = await prompt2("Your Discord User ID: ");
+  if (!userId || !/^\d+$/.test(userId)) {
+    console.error("Invalid user ID. Should be a number.");
+    process.exit(1);
+  }
+  await mkdir2(CONFIG_DIR2, { recursive: true });
+  const envContent = `# AFK Code Discord Configuration
+DISCORD_BOT_TOKEN=${botToken}
+DISCORD_USER_ID=${userId}
+`;
+  await writeFile2(DISCORD_CONFIG_FILE, envContent);
+  console.log(`
+\u2713 Configuration saved to ${DISCORD_CONFIG_FILE}
+
+To start the Discord bot, run:
+  afk-code discord
+
+Then start a Claude Code session with:
+  afk-code run -- claude
+`);
+}
+async function loadEnvFile2(path) {
+  if (!await fileExists2(path)) return {};
+  const content = await readFile3(path, "utf-8");
+  const config = {};
+  for (const line of content.split("\n")) {
+    if (line.startsWith("#") || !line.includes("=")) continue;
+    const [key, ...valueParts] = line.split("=");
+    config[key.trim()] = valueParts.join("=").trim();
+  }
+  return config;
+}
+async function discordRun() {
+  const globalConfig = await loadEnvFile2(DISCORD_CONFIG_FILE);
+  const localConfig = await loadEnvFile2(`${process.cwd()}/.env`);
+  const config = {
+    ...globalConfig,
+    ...localConfig
+  };
+  if (process.env.DISCORD_BOT_TOKEN) config.DISCORD_BOT_TOKEN = process.env.DISCORD_BOT_TOKEN;
+  if (process.env.DISCORD_USER_ID) config.DISCORD_USER_ID = process.env.DISCORD_USER_ID;
+  const required = ["DISCORD_BOT_TOKEN", "DISCORD_USER_ID"];
+  const missing = required.filter((key) => !config[key]);
+  if (missing.length > 0) {
+    console.error(`Missing config: ${missing.join(", ")}`);
+    console.error("");
+    console.error("Provide tokens via:");
+    console.error("  - Environment variables (DISCORD_BOT_TOKEN, DISCORD_USER_ID)");
+    console.error("  - Local .env file");
+    console.error('  - Run "afk-code discord setup" for guided configuration');
+    process.exit(1);
+  }
+  const { createDiscordApp: createDiscordApp2 } = await Promise.resolve().then(() => (init_discord_app(), discord_app_exports));
+  const localEnvExists = await fileExists2(`${process.cwd()}/.env`);
+  const globalEnvExists = await fileExists2(DISCORD_CONFIG_FILE);
+  const source = localEnvExists ? ".env" : globalEnvExists ? DISCORD_CONFIG_FILE : "environment";
+  console.log(`[AFK Code] Loaded config from ${source}`);
+  console.log("[AFK Code] Starting Discord bot...");
+  const discordConfig = {
+    botToken: config.DISCORD_BOT_TOKEN,
+    userId: config.DISCORD_USER_ID
+  };
+  const { client, sessionManager } = createDiscordApp2(discordConfig);
+  try {
+    await sessionManager.start();
+    console.log("[AFK Code] Session manager started");
+  } catch (err) {
+    console.error("[AFK Code] Failed to start session manager:", err);
+    process.exit(1);
+  }
+  try {
+    await client.login(config.DISCORD_BOT_TOKEN);
+    console.log("[AFK Code] Discord bot is running!");
+    console.log("");
+    console.log("Start a Claude Code session with: afk-code run -- claude");
+    console.log("Each session will create an #afk-* channel");
+  } catch (err) {
+    console.error("[AFK Code] Failed to start Discord bot:", err);
+    process.exit(1);
+  }
+}
+
+// src/cli/index.ts
+var args = process.argv.slice(2);
+var command = args[0];
+async function main() {
+  switch (command) {
+    case "run": {
+      const separatorIndex = args.indexOf("--");
+      if (separatorIndex === -1) {
+        console.error("Usage: afk-code run -- <command> [args...]");
+        console.error("Example: afk-code run -- claude");
+        process.exit(1);
+      }
+      const cmd = args.slice(separatorIndex + 1);
+      if (cmd.length === 0) {
+        console.error("No command specified after --");
+        process.exit(1);
+      }
+      await run(cmd);
+      break;
+    }
+    case "slack": {
+      if (args[1] === "setup") {
+        await slackSetup();
+      } else {
+        await slackRun();
+      }
+      break;
+    }
+    case "discord": {
+      if (args[1] === "setup") {
+        await discordSetup();
+      } else {
+        await discordRun();
+      }
+      break;
+    }
+    case "help":
+    case "--help":
+    case "-h":
+    case void 0: {
+      console.log(`
+AFK Code - Monitor Claude Code sessions from Slack/Discord
+
+Commands:
+  slack              Run the Slack bot
+  slack setup        Configure Slack integration
+  discord            Run the Discord bot
+  discord setup      Configure Discord integration
+  run -- <command>   Start a monitored session
+  help               Show this help message
+
+Examples:
+  afk-code slack setup    # First-time Slack configuration
+  afk-code slack          # Start the Slack bot
+  afk-code discord setup  # First-time Discord configuration
+  afk-code discord        # Start the Discord bot
+  afk-code run -- claude  # Start a Claude Code session
+`);
+      break;
+    }
+    default: {
+      console.error(`Unknown command: ${command}`);
+      console.error('Run "afk-code help" for usage');
+      process.exit(1);
+    }
+  }
+}
+main().catch((err) => {
+  console.error("Error:", err.message);
+  process.exit(1);
+});