@gonzih/cc-discord 0.2.39 → 0.2.40

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

@@ -65,21 +65,6 @@ export interface MetaAgentManager {
     /** Write a raw line to the stdin of the running session, if any. */
     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.
- *
- * On process exit: remove from sessions map. Next message triggers a respawn.
- *
- * The 3-second poll loop drains any messages that arrived while a session was
- * starting up or temporarily unavailable.
- */
 export declare function createMetaAgentManager(): MetaAgentManager;
 /**
  * Migrate the old cc-agent meta input key to the new cc-discord key.

package/dist/meta-agent-manager.js

@@ -293,7 +293,7 @@ export function spawnSession(ns, message, token, wire) {
  * Stdout is wired to Redis via wireStdoutToRedis.
  * Returns the ChildProcess.
  */
-function spawnPersistentSession(ns, token, wire, onExit) {
+function spawnPersistentSession(ns, token, wire, onExit, onOutput) {
     const wsPath = workspacePath(ns);
     const claudeBin = resolveClaude();
     const env = buildEnv(token);
@@ -312,6 +312,9 @@ function spawnPersistentSession(ns, token, wire, onExit) {
     ], { cwd: wsPath, env, stdio: ["pipe", "pipe", "pipe"] });
     proc.stdin.setDefaultEncoding("utf8");
     wireStdoutToRedis(proc, ns, wire);
+    if (onOutput) {
+        proc.stdout.on("data", onOutput);
+    }
     proc.on("exit", (code) => {
         console.log(`[meta-agent-manager] persistent session exited (ns=${ns}, code=${code})`);
         onExit();
@@ -337,15 +340,22 @@ function spawnPersistentSession(ns, token, wire, onExit) {
  * The 3-second poll loop drains any messages that arrived while a session was
  * starting up or temporarily unavailable.
  */
+/** Kill a session after this many ms of no stdout (or no new stdin). */
+const SESSION_INACTIVITY_MS = 5 * 60_000; // 5 minutes
 export function createMetaAgentManager() {
     let pollInterval = null;
+    let watchdogInterval = null;
     /** One persistent ChildProcess per namespace. */
     const sessions = new Map();
     /** Namespaces currently being set up (workspace clone / first spawn). */
     const startingUp = new Set();
+    /** Wire reference needed for watchdog notifications. Set in startPolling. */
+    let wireRef = null;
     /**
      * Write a line to the stdin of the persistent session for ns.
      * Silently no-ops if no session exists.
+     * Resets the inactivity timer so the watchdog doesn't kill a session
+     * that just received a message but hasn't responded yet.
      */
     function writeToStdin(ns, line) {
         const session = sessions.get(ns);
@@ -354,11 +364,54 @@ export function createMetaAgentManager() {
         try {
             // Interactive mode: plain text line, Claude reads it as user input
             session.proc.stdin.write(`${line}\n`);
+            // Reset inactivity timer — the session now has SESSION_INACTIVITY_MS to respond
+            session.lastOutputAt = Date.now();
         }
         catch (err) {
             console.warn(`[meta-agent-manager] stdin write failed (ns=${ns}):`, err.message);
         }
     }
+    /**
+     * Watchdog: scan all sessions every 60s. If any session has been silent
+     * (no stdout and no new stdin) for SESSION_INACTIVITY_MS, kill it and
+     * notify Discord so the user can see why the session went quiet.
+     */
+    function startWatchdog() {
+        if (watchdogInterval)
+            return;
+        watchdogInterval = setInterval(() => {
+            if (!wireRef)
+                return;
+            const now = Date.now();
+            for (const [ns, session] of sessions) {
+                const idleMs = now - session.lastOutputAt;
+                if (idleMs < SESSION_INACTIVITY_MS)
+                    continue;
+                const idleMin = Math.round(idleMs / 60_000);
+                console.warn(`[meta-agent-manager] watchdog: ns=${ns} idle ${idleMin}m, killing stuck session`);
+                // Notify Discord before killing so the user knows what happened
+                const alertMsg = {
+                    id: crypto.randomUUID(),
+                    source: "claude",
+                    role: "assistant",
+                    content: `⚠️ Session for **${ns}** was idle for ${idleMin} minutes (likely stuck on a tool call). Killed and removed — send any message to restart.`,
+                    timestamp: new Date().toISOString(),
+                    chatId: 0,
+                };
+                wireRef.discord.publishOutgoing(ns, alertMsg).catch((err) => {
+                    console.warn(`[meta-agent-manager] watchdog publishOutgoing failed (ns=${ns}):`, err.message);
+                });
+                try {
+                    session.proc.stdin.end();
+                    session.proc.kill("SIGTERM");
+                }
+                catch {
+                    // ignore kill errors
+                }
+                sessions.delete(ns);
+            }
+        }, 60_000);
+    }
     /**
      * Drain all pending messages from the Redis input queue into the session's stdin.
      */
@@ -405,12 +458,19 @@ export function createMetaAgentManager() {
             const wsPath = workspacePath(ns);
             await ensureWorkspace(ns, repoUrl);
             injectMcp(ns, wsPath, token);
+            // Placeholder — filled in after proc is known so the onOutput closure can update it
+            let session;
             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})`);
+            }, () => {
+                // Reset inactivity timer on any stdout data
+                if (session)
+                    session.lastOutputAt = Date.now();
             });
-            sessions.set(ns, { proc, ns });
+            session = { proc, ns, lastOutputAt: Date.now() };
+            sessions.set(ns, session);
             // Drain any messages that arrived before this session started
             await drainQueue(ns, wire);
             // Write the triggering message last (after queue drain, in order)
@@ -443,6 +503,8 @@ export function createMetaAgentManager() {
         startPolling(wire, getNamespaces, instanceId) {
             if (pollInterval)
                 return; // already running
+            wireRef = wire;
+            startWatchdog();
             pollInterval = setInterval(() => {
                 const namespaces = getNamespaces();
                 if (namespaces.length === 0)
@@ -499,6 +561,10 @@ export function createMetaAgentManager() {
                 pollInterval = null;
                 console.log("[meta-agent-manager] polling stopped");
             }
+            if (watchdogInterval) {
+                clearInterval(watchdogInterval);
+                watchdogInterval = null;
+            }
             // Kill all active sessions
             for (const [ns, session] of sessions) {
                 try {

package/dist/notifier.js

@@ -279,11 +279,6 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
         if (!buf || !buf.text.trim())
             return;
         const text = `← [${ns}] ` + stripAnsi(buf.text.trim());
-        if (text.length < 30) {
-            buf.text = "";
-            buf.timer = null;
-            return;
-        }
         buf.text = "";
         buf.timer = null;
         // During an active loop, route meta-agent output to the thread rather than main channel

package/package.json

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