@gonzih/cc-discord 0.2.35 → 0.2.37

package/dist/meta-agent-manager.d.ts

@@ -4,13 +4,12 @@
  * Flow per namespace:
  *   1. ensureWorkspace: git clone repo to ~/cc-discord-workspace/{ns}
  *   2. injectMcp: write .mcp.json so the claude subprocess has MCP tool access
- *   3. ensureSession: spawn one persistent `claude --continue` process per namespace
- *      (no -p flag — messages go via stdin)
- *   4. On new message: write "${message}\n" to stdin of the running process
- *   5. On process exit: remove from sessions map; next message respawns
+ *   3. ensureSession: add message to per-namespace queue, start processQueue
+ *   4. processQueue: spawn `claude --continue -p` (stdin+EOF) per message, one at a time
+ *   5. Context is maintained via --continue (JSONL session file in workspace)
  *
- * The polling loop now just drains any queued Redis messages into stdin.
- * No more per-message process spawn — Claude receives messages in sequence.
+ * Spawn-per-message with --continue maintains full conversation history.
+ * Messages queue up and process sequentially per namespace.
  */
 import type { createCcWire } from "@gonzih/cc-wire";
 type Wire = ReturnType<typeof createCcWire>;
@@ -44,12 +43,9 @@ export declare function injectMcp(ns: string, wsPath: string, token: string): vo
 export declare const metaStreamChannel: (ns: string) => string;
 export declare const metaLogKey: (ns: string) => string;
 /**
- * Spawn `claude --continue -p "{message}" --dangerously-skip-permissions` in the
- * namespace workspace. Pipes stdout line-by-line → wire.discord.publishOutgoing.
- * Also streams each chunk to Redis: PUBLISH cca:meta:{ns}:stream and LPUSH cca:meta:{ns}:log.
+ * Spawn `claude --continue -p` with message written to stdin, then close stdin (EOF).
+ * Claude responds and exits. Context is maintained via --continue (JSONL session file).
  * Returns a Promise that resolves when the process exits.
- *
- * Kept for backwards-compat and direct integration-test usage.
  */
 export declare function spawnSession(ns: string, message: string, token: string, wire: Wire): Promise<void>;
 export interface MetaAgentManager {
@@ -60,25 +56,20 @@ export interface MetaAgentManager {
         repoUrl: string;
     }>, instanceId?: string) => void;
     stop: () => void;
-    /** Kill and remove the persistent session for a namespace (e.g. on /clear). */
+    /** Clear the message queue for a namespace (e.g. on /clear). */
     killSession: (ns: string) => void;
-    /** Write a raw line to the stdin of the running session, if any. */
+    /** Queue a message for a namespace. */
     sendToSession: (ns: string, line: string) => void;
 }
 /**
- * Create a MetaAgentManager that maintains one persistent Claude process per namespace.
- *
- * On first message for a namespace:
- *   1. ensureWorkspace + injectMcp
- *   2. Drain any pending Redis queue entries to stdin
- *   3. Write the new message to stdin
- *
- * On subsequent messages: write directly to stdin of the running process.
+ * Create a MetaAgentManager that processes Discord messages via spawn-per-message.
  *
- * On process exit: remove from sessions map. Next message triggers a respawn.
+ * Each message spawns `claude --continue -p` with the message written to stdin,
+ * then stdin is closed (EOF) so Claude processes and exits. --continue maintains
+ * conversation history via the JSONL session file in the workspace.
  *
- * The 3-second poll loop drains any messages that arrived while a session was
- * starting up or temporarily unavailable.
+ * Messages queue per namespace and process sequentially — no concurrent spawns
+ * for the same namespace.
  */
 export declare function createMetaAgentManager(): MetaAgentManager;
 /**

package/dist/meta-agent-manager.js

@@ -4,13 +4,12 @@
  * Flow per namespace:
  *   1. ensureWorkspace: git clone repo to ~/cc-discord-workspace/{ns}
  *   2. injectMcp: write .mcp.json so the claude subprocess has MCP tool access
- *   3. ensureSession: spawn one persistent `claude --continue` process per namespace
- *      (no -p flag — messages go via stdin)
- *   4. On new message: write "${message}\n" to stdin of the running process
- *   5. On process exit: remove from sessions map; next message respawns
+ *   3. ensureSession: add message to per-namespace queue, start processQueue
+ *   4. processQueue: spawn `claude --continue -p` (stdin+EOF) per message, one at a time
+ *   5. Context is maintained via --continue (JSONL session file in workspace)
  *
- * The polling loop now just drains any queued Redis messages into stdin.
- * No more per-message process spawn — Claude receives messages in sequence.
+ * Spawn-per-message with --continue maintains full conversation history.
+ * Messages queue up and process sequentially per namespace.
  */
 import { spawn, execSync } from "child_process";
 import { existsSync, mkdirSync, writeFileSync } from "fs";
@@ -212,19 +211,7 @@ function wireStdoutToRedis(proc, ns, wire) {
                     result: resultText,
                     is_error: parsed.is_error ?? false,
                 };
-                if (resultText) {
-                    const msg = {
-                        id: crypto.randomUUID(),
-                        source: "claude",
-                        role: "assistant",
-                        content: resultText,
-                        timestamp: new Date().toISOString(),
-                        chatId: 0,
-                    };
-                    wire.discord.publishOutgoing(ns, msg).catch((err) => {
-                        console.warn(`[meta-agent-manager] publishOutgoing (result) failed (ns=${ns}):`, err.message);
-                    });
-                }
+                // Do not re-publish result text — assistant event already published it
             }
             else {
                 structuredEvent = parsed;
@@ -257,12 +244,9 @@ function wireStdoutToRedis(proc, ns, wire) {
     });
 }
 /**
- * Spawn `claude --continue -p "{message}" --dangerously-skip-permissions` in the
- * namespace workspace. Pipes stdout line-by-line → wire.discord.publishOutgoing.
- * Also streams each chunk to Redis: PUBLISH cca:meta:{ns}:stream and LPUSH cca:meta:{ns}:log.
+ * Spawn `claude --continue -p` with message written to stdin, then close stdin (EOF).
+ * Claude responds and exits. Context is maintained via --continue (JSONL session file).
  * Returns a Promise that resolves when the process exits.
- *
- * Kept for backwards-compat and direct integration-test usage.
  */
 export function spawnSession(ns, message, token, wire) {
     return new Promise((resolve, reject) => {
@@ -271,11 +255,15 @@ export function spawnSession(ns, message, token, wire) {
         const env = buildEnv(token);
         const proc = spawn(claudeBin, [
             "--continue",
-            "-p", message,
+            "-p",
             "--output-format", "stream-json",
             "--verbose",
             "--dangerously-skip-permissions",
-        ], { cwd: wsPath, env, stdio: ["ignore", "pipe", "pipe"] });
+        ], { cwd: wsPath, env, stdio: ["pipe", "pipe", "pipe"] });
+        // Write message to stdin, then close (EOF triggers Claude to process and respond)
+        proc.stdin.write(message + "\n", () => {
+            proc.stdin.end();
+        });
         wireStdoutToRedis(proc, ns, wire);
         proc.on("exit", (code) => {
             console.log(`[meta-agent-manager] session exited (ns=${ns}, code=${code})`);
@@ -288,149 +276,75 @@ export function spawnSession(ns, message, token, wire) {
     });
 }
 /**
- * Spawn a persistent `claude --continue` process for a namespace.
- * No -p flag — messages are delivered via stdin.
- * Stdout is wired to Redis via wireStdoutToRedis.
- * Returns the ChildProcess.
- */
-function spawnPersistentSession(ns, token, wire, onExit) {
-    const wsPath = workspacePath(ns);
-    const claudeBin = resolveClaude();
-    const env = buildEnv(token);
-    console.log(`[meta-agent-manager] spawning persistent session (ns=${ns})`);
-    // DO NOT ADD -p OR --input-format stream-json HERE.
-    // With -p + --input-format stream-json, Claude buffers all stdin until EOF before responding.
-    // Since the stdin pipe is never closed (it stays open for subsequent messages), Claude
-    // waits forever and never produces output. Interactive mode (no -p) reads one line at a
-    // time and responds immediately. Verified by direct test: `echo msg | claude --continue
-    // --output-format stream-json ...` responds correctly; the -p variant does not.
-    const proc = spawn(claudeBin, [
-        "--continue",
-        "--output-format", "stream-json",
-        "--verbose",
-        "--dangerously-skip-permissions",
-    ], { cwd: wsPath, env, stdio: ["pipe", "pipe", "pipe"] });
-    proc.stdin.setDefaultEncoding("utf8");
-    wireStdoutToRedis(proc, ns, wire);
-    proc.on("exit", (code) => {
-        console.log(`[meta-agent-manager] persistent session exited (ns=${ns}, code=${code})`);
-        onExit();
-    });
-    proc.on("error", (err) => {
-        console.error(`[meta-agent-manager] persistent session spawn error (ns=${ns}):`, err.message);
-        onExit();
-    });
-    return proc;
-}
-/**
- * Create a MetaAgentManager that maintains one persistent Claude process per namespace.
- *
- * On first message for a namespace:
- *   1. ensureWorkspace + injectMcp
- *   2. Drain any pending Redis queue entries to stdin
- *   3. Write the new message to stdin
- *
- * On subsequent messages: write directly to stdin of the running process.
+ * Create a MetaAgentManager that processes Discord messages via spawn-per-message.
  *
- * On process exit: remove from sessions map. Next message triggers a respawn.
+ * Each message spawns `claude --continue -p` with the message written to stdin,
+ * then stdin is closed (EOF) so Claude processes and exits. --continue maintains
+ * conversation history via the JSONL session file in the workspace.
  *
- * The 3-second poll loop drains any messages that arrived while a session was
- * starting up or temporarily unavailable.
+ * Messages queue per namespace and process sequentially — no concurrent spawns
+ * for the same namespace.
  */
 export function createMetaAgentManager() {
     let pollInterval = null;
-    /** One persistent ChildProcess per namespace. */
-    const sessions = new Map();
-    /** Namespaces currently being set up (workspace clone / first spawn). */
-    const startingUp = new Set();
+    // Per-namespace message queue (local, drained by processQueue)
+    const queues = new Map();
+    // Namespaces currently running a spawnSession (blocks concurrent spawns)
+    const processing = new Set();
+    // Cached session metadata (token, wire, repoUrl) per namespace
+    const sessionMeta = new Map();
     /**
-     * Write a line to the stdin of the persistent session for ns.
-     * Silently no-ops if no session exists.
+     * Drain the local queue for a namespace, spawning one session per message.
+     * No-ops if already processing or queue is empty.
      */
-    function writeToStdin(ns, line) {
-        const session = sessions.get(ns);
-        if (!session)
+    async function processQueue(ns) {
+        if (processing.has(ns))
+            return;
+        const queue = queues.get(ns);
+        if (!queue || queue.length === 0)
+            return;
+        const meta = sessionMeta.get(ns);
+        if (!meta)
             return;
+        processing.add(ns);
+        console.log(`[meta-agent-manager] processQueue started (ns=${ns})`);
         try {
-            // Interactive mode: plain text line, Claude reads it as user input
-            session.proc.stdin.write(`${line}\n`);
-        }
-        catch (err) {
-            console.warn(`[meta-agent-manager] stdin write failed (ns=${ns}):`, err.message);
-        }
-    }
-    /**
-     * Drain all pending messages from the Redis input queue into the session's stdin.
-     */
-    async function drainQueue(ns, wire) {
-        const inputKey = discordMetaInputKey(ns);
-        for (;;) {
-            let raw;
-            try {
-                raw = await wire._redis.lpop(inputKey);
-            }
-            catch {
-                break;
-            }
-            if (!raw)
-                break;
-            let content;
-            try {
-                content = JSON.parse(raw).content ?? raw;
-            }
-            catch {
-                content = raw;
+            while (true) {
+                const q = queues.get(ns);
+                if (!q || q.length === 0)
+                    break;
+                const message = q.shift();
+                const { token, wire } = sessionMeta.get(ns) ?? meta;
+                console.log(`[meta-agent-manager] spawning session for message (ns=${ns})`);
+                try {
+                    await spawnSession(ns, message, token, wire);
+                }
+                catch (err) {
+                    console.error(`[meta-agent-manager] spawnSession error (ns=${ns}):`, err.message);
+                }
             }
-            writeToStdin(ns, content);
+        }
+        finally {
+            processing.delete(ns);
+            console.log(`[meta-agent-manager] processQueue done (ns=${ns})`);
         }
     }
     /**
-     * Ensure a persistent session exists for ns.
-     * If one already exists, returns immediately.
-     * If not, spawns one, drains any queued messages, then writes `firstMessage` if provided.
+     * Ensure workspace + MCP are ready, add message to queue, start processing.
      */
     async function ensureSession(ns, repoUrl, token, wire, firstMessage) {
-        if (sessions.has(ns)) {
-            if (firstMessage !== undefined)
-                writeToStdin(ns, firstMessage);
-            return;
-        }
-        if (startingUp.has(ns)) {
-            // Already spinning up — queue the message so drainQueue picks it up
-            return;
-        }
-        startingUp.add(ns);
-        try {
-            // Ensure workspace exists
-            const wsPath = workspacePath(ns);
-            await ensureWorkspace(ns, repoUrl);
-            injectMcp(ns, wsPath, token);
-            const proc = spawnPersistentSession(ns, token, wire, () => {
-                // On exit: remove from map so next message triggers a respawn
-                sessions.delete(ns);
-                console.log(`[meta-agent-manager] session removed from map (ns=${ns})`);
-            });
-            sessions.set(ns, { proc, ns });
-            // Drain any messages that arrived before this session started
-            await drainQueue(ns, wire);
-            // Write the triggering message last (after queue drain, in order)
-            if (firstMessage !== undefined)
-                writeToStdin(ns, firstMessage);
-            await wire.discord.setStatus(ns, {
-                namespace: ns,
-                status: "running",
-                isTyping: true,
-                turnCount: 0,
-                updatedAt: new Date().toISOString(),
-            });
-        }
-        catch (err) {
-            console.error(`[meta-agent-manager] ensureSession failed (ns=${ns}):`, err.message);
-            sessions.delete(ns);
-        }
-        finally {
-            startingUp.delete(ns);
+        sessionMeta.set(ns, { token, wire, repoUrl });
+        const wsPath = workspacePath(ns);
+        await ensureWorkspace(ns, repoUrl);
+        injectMcp(ns, wsPath, token);
+        if (!queues.has(ns))
+            queues.set(ns, []);
+        if (firstMessage !== undefined) {
+            queues.get(ns).push(firstMessage);
         }
+        processQueue(ns).catch((err) => {
+            console.error(`[meta-agent-manager] processQueue error (ns=${ns}):`, err.message);
+        });
     }
     return {
         async ensureWorkspace(ns, repoUrl) {
@@ -442,7 +356,7 @@ export function createMetaAgentManager() {
         },
         startPolling(wire, getNamespaces, instanceId) {
             if (pollInterval)
-                return; // already running
+                return;
             pollInterval = setInterval(() => {
                 const namespaces = getNamespaces();
                 if (namespaces.length === 0)
@@ -457,25 +371,21 @@ export function createMetaAgentManager() {
                             }
                         }).catch(() => { });
                     }
-                    // If session exists, drain any queued messages
-                    if (sessions.has(ns)) {
-                        drainQueue(ns, wire).catch((err) => {
-                            console.warn(`[meta-agent-manager] drainQueue error (ns=${ns}):`, err.message);
-                        });
+                    // Skip if already processing
+                    if (processing.has(ns))
                         continue;
-                    }
-                    // Check if anything is queued for this namespace
+                    // Check Redis queue for pending messages
                     const inputKey = discordMetaInputKey(ns);
                     wire._redis.llen(inputKey).then(async (queueLen) => {
                         if (queueLen === 0)
                             return;
-                        // Resolve token
                         let token;
                         try {
                             token = await wire.token.getMaster();
                         }
                         catch {
-                            token = process.env.CLAUDE_CODE_OAUTH_TOKEN
+                            token = sessionMeta.get(ns)?.token
+                                ?? process.env.CLAUDE_CODE_OAUTH_TOKEN
                                 ?? process.env.CLAUDE_CODE_TOKEN
                                 ?? process.env.ANTHROPIC_API_KEY
                                 ?? "";
@@ -484,8 +394,31 @@ export function createMetaAgentManager() {
                             console.warn(`[meta-agent-manager] no token available, skipping session for ns=${ns}`);
                             return;
                         }
-                        // ensureSession will drain the queue itself
-                        await ensureSession(ns, repoUrl, token, wire);
+                        // Drain Redis queue into local queue
+                        if (!queues.has(ns))
+                            queues.set(ns, []);
+                        for (;;) {
+                            const raw = await wire._redis.lpop(inputKey).catch(() => null);
+                            if (!raw)
+                                break;
+                            let content;
+                            try {
+                                content = JSON.parse(raw).content ?? raw;
+                            }
+                            catch {
+                                content = raw;
+                            }
+                            queues.get(ns).push(content);
+                        }
+                        if (!sessionMeta.has(ns)) {
+                            sessionMeta.set(ns, { token, wire, repoUrl });
+                        }
+                        const wsPath = workspacePath(ns);
+                        await ensureWorkspace(ns, repoUrl);
+                        injectMcp(ns, wsPath, token);
+                        processQueue(ns).catch((err) => {
+                            console.error(`[meta-agent-manager] processQueue error (ns=${ns}):`, err.message);
+                        });
                     }).catch((err) => {
                         console.warn(`[meta-agent-manager] llen error (ns=${ns}):`, err.message);
                     });
@@ -499,35 +432,20 @@ export function createMetaAgentManager() {
                 pollInterval = null;
                 console.log("[meta-agent-manager] polling stopped");
             }
-            // Kill all active sessions
-            for (const [ns, session] of sessions) {
-                try {
-                    session.proc.stdin.end();
-                    session.proc.kill();
-                }
-                catch {
-                    // ignore errors during shutdown
-                }
-                sessions.delete(ns);
-                console.log(`[meta-agent-manager] killed session on stop (ns=${ns})`);
-            }
+            queues.clear();
         },
         killSession(ns) {
-            const session = sessions.get(ns);
-            if (!session)
-                return;
-            try {
-                session.proc.stdin.end();
-                session.proc.kill();
-            }
-            catch {
-                // ignore
-            }
-            sessions.delete(ns);
-            console.log(`[meta-agent-manager] killed session (ns=${ns})`);
+            // Clear local queue — any in-flight spawn will complete naturally
+            queues.delete(ns);
+            console.log(`[meta-agent-manager] killed session queue (ns=${ns})`);
         },
         sendToSession(ns, line) {
-            writeToStdin(ns, line);
+            if (!queues.has(ns))
+                queues.set(ns, []);
+            queues.get(ns).push(line);
+            processQueue(ns).catch((err) => {
+                console.error(`[meta-agent-manager] processQueue error (ns=${ns}):`, err.message);
+            });
         },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonzih/cc-discord",
-  "version": "0.2.35",
+  "version": "0.2.37",
   "description": "Claude Code Discord bot — chat with Claude Code via Discord",
   "type": "module",
   "bin": {