@gonzih/cc-discord 0.2.40 → 0.2.42

package/dist/bot.d.ts

@@ -2,6 +2,7 @@
  * Discord bot that routes messages to/from a Claude Code subprocess.
  * One ClaudeProcess per channel (or channel:thread) — sessions are isolated per channel.
  */
+import { Message } from "discord.js";
 import { Redis } from "ioredis";
 /** Returns true if the attachment name/contentType indicates an audio file. */
 export declare function isAudioAttachment(name: string, contentType: string): boolean;
@@ -56,10 +57,30 @@ export declare class CcDiscordBot {
     loadChannelMappings(): Promise<void>;
     /** Typing intervals for meta-agent routed channels — keyed by channelId. */
     private metaAgentTypingTimers;
+    /** Live Discord messages per channel — edited in-place as Claude streams output. */
+    private liveMessages;
     /** Start (or reset) the typing indicator for a meta-agent–routed channel. */
     private startMetaAgentTyping;
     /** Stop the typing indicator for a meta-agent–routed channel. Called by the notifier on flush. */
     stopMetaAgentTyping(channelId: string): void;
+    /**
+     * Get or create a live Discord message for `channelId`.
+     * If a live message already exists (e.g. from a tool_start), returns it (for reuse).
+     * Otherwise sends `initial` to create the placeholder and stops the typing indicator.
+     */
+    startOrGetLiveMessage(channelId: string, initial: string): Promise<Message | null>;
+    /**
+     * Throttled edit of the live message for `channelId`.
+     * Safe to call on every token/chunk — edits are coalesced at 750ms intervals.
+     * The latest `text` always wins (older pending updates are replaced).
+     */
+    updateLiveMessage(channelId: string, text: string): void;
+    /**
+     * Final edit of the live message — applies `text` without cursor, clears tracker.
+     * If no live message exists, falls back to sendWithFileDetection (new message).
+     * Overflow past 2000 chars spawns continuation messages via sendToChannelById.
+     */
+    finalizeLiveMessage(channelId: string, text: string): Promise<void>;
     /** Session key: "channelId" or "channelId:threadId" for threads */
     private sessionKey;
     /** Get the channel/thread for sending messages */

package/dist/bot.js

@@ -231,6 +231,8 @@ export class CcDiscordBot {
     }
     /** Typing intervals for meta-agent routed channels — keyed by channelId. */
     metaAgentTypingTimers = new Map();
+    /** Live Discord messages per channel — edited in-place as Claude streams output. */
+    liveMessages = new Map();
     /** Start (or reset) the typing indicator for a meta-agent–routed channel. */
     startMetaAgentTyping(channelId, channel) {
         this.stopMetaAgentTyping(channelId);
@@ -245,6 +247,96 @@ export class CcDiscordBot {
             this.metaAgentTypingTimers.delete(channelId);
         }
     }
+    /**
+     * Get or create a live Discord message for `channelId`.
+     * If a live message already exists (e.g. from a tool_start), returns it (for reuse).
+     * Otherwise sends `initial` to create the placeholder and stops the typing indicator.
+     */
+    async startOrGetLiveMessage(channelId, initial) {
+        const existing = this.liveMessages.get(channelId);
+        if (existing)
+            return existing.msg;
+        const channel = await this.getChannel(channelId);
+        if (!channel)
+            return null;
+        this.stopMetaAgentTyping(channelId);
+        try {
+            const msg = await channel.send(initial || "▋");
+            this.liveMessages.set(channelId, { msg, lastEditAt: Date.now(), editTimer: null, pendingText: null });
+            return msg;
+        }
+        catch (err) {
+            console.warn(`[bot] startOrGetLiveMessage failed (${channelId}):`, err.message);
+            return null;
+        }
+    }
+    /**
+     * Throttled edit of the live message for `channelId`.
+     * Safe to call on every token/chunk — edits are coalesced at 750ms intervals.
+     * The latest `text` always wins (older pending updates are replaced).
+     */
+    updateLiveMessage(channelId, text) {
+        const entry = this.liveMessages.get(channelId);
+        if (!entry)
+            return;
+        entry.pendingText = text;
+        if (entry.editTimer)
+            return; // timer already scheduled; will pick up pendingText when it fires
+        const msUntilSafe = Math.max(0, 750 - (Date.now() - entry.lastEditAt));
+        entry.editTimer = setTimeout(async () => {
+            entry.editTimer = null;
+            const t = entry.pendingText;
+            if (t == null)
+                return;
+            entry.pendingText = null;
+            try {
+                await entry.msg.edit(t.slice(0, 1990));
+                entry.lastEditAt = Date.now();
+            }
+            catch {
+                this.liveMessages.delete(channelId); // message deleted or perms lost — give up
+            }
+        }, msUntilSafe);
+    }
+    /**
+     * Final edit of the live message — applies `text` without cursor, clears tracker.
+     * If no live message exists, falls back to sendWithFileDetection (new message).
+     * Overflow past 2000 chars spawns continuation messages via sendToChannelById.
+     */
+    async finalizeLiveMessage(channelId, text) {
+        const entry = this.liveMessages.get(channelId);
+        if (entry?.editTimer) {
+            clearTimeout(entry.editTimer);
+            entry.editTimer = null;
+        }
+        this.liveMessages.delete(channelId);
+        if (!entry) {
+            if (text.trim())
+                await this.sendWithFileDetection(channelId, text);
+            return;
+        }
+        if (!text.trim()) {
+            // Nothing to show — delete the placeholder message
+            entry.msg.delete().catch(() => { });
+            return;
+        }
+        const formatted = formatForDiscord(text);
+        const chunks = splitLongMessage(formatted);
+        try {
+            await entry.msg.edit(chunks[0]);
+            for (const chunk of chunks.slice(1)) {
+                if (chunk.trim())
+                    await this.sendToChannelById(channelId, chunk);
+            }
+        }
+        catch {
+            // Message was deleted or edit failed — send as new messages
+            for (const chunk of chunks) {
+                if (chunk.trim())
+                    await this.sendWithFileDetection(channelId, chunk).catch(() => { });
+            }
+        }
+    }
     /** Session key: "channelId" or "channelId:threadId" for threads */
     sessionKey(channelId, threadId) {
         return threadId ? `${channelId}:${threadId}` : channelId;

package/dist/meta-agent-manager.js

@@ -16,7 +16,7 @@ import { spawn, execSync } from "child_process";
 import { existsSync, mkdirSync, writeFileSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
-import { CC_DISCORD_WORKSPACE_ROOT, TIMING, DISCORD_INSTANCE_KEY, discordMetaInputKey, metaStreamChannel as ccWireMetaStreamChannel, metaLogKey as ccWireMetaLogKey, } from "@gonzih/cc-wire";
+import { CC_DISCORD_WORKSPACE_ROOT, TIMING, DISCORD_INSTANCE_KEY, discordMetaInputKey, discordChatOutgoing, metaStreamChannel as ccWireMetaStreamChannel, metaLogKey as ccWireMetaLogKey, } from "@gonzih/cc-wire";
 const WORKSPACE_ROOT = join(homedir(), CC_DISCORD_WORKSPACE_ROOT);
 /**
  * Returns the path to the workspace for the given namespace.
@@ -193,17 +193,28 @@ function wireStdoutToRedis(proc, ns, wire) {
                 }
             }
             else if (type === "tool_use") {
+                const toolName = parsed.name ?? "tool";
                 structuredEvent = {
                     type: "tool_use",
-                    name: parsed.name ?? "",
+                    name: toolName,
                     input: parsed.input ?? {},
                 };
+                // Ephemeral signal: notifier shows tool activity overlay in the live message
+                rawRedis.publish(discordChatOutgoing(ns), JSON.stringify({
+                    id: crypto.randomUUID(), source: "claude", role: "assistant",
+                    content: toolName, event: "tool_start", timestamp: new Date().toISOString(), chatId: 0,
+                })).catch(() => { });
             }
             else if (type === "tool_result") {
                 structuredEvent = {
                     type: "tool_result",
                     content: parsed.content ?? "",
                 };
+                // Ephemeral signal: tool finished, notifier can restart finalize timer
+                rawRedis.publish(discordChatOutgoing(ns), JSON.stringify({
+                    id: crypto.randomUUID(), source: "claude", role: "assistant",
+                    content: "", event: "tool_end", timestamp: new Date().toISOString(), chatId: 0,
+                })).catch(() => { });
             }
             else if (type === "result") {
                 const resultText = typeof parsed.result === "string" ? parsed.result : JSON.stringify(parsed.result ?? "");
@@ -212,7 +223,7 @@ function wireStdoutToRedis(proc, ns, wire) {
                     result: resultText,
                     is_error: parsed.is_error ?? false,
                 };
-                if (resultText) {
+                if (resultText && !parsed.is_error) {
                     const msg = {
                         id: crypto.randomUUID(),
                         source: "claude",
@@ -221,10 +232,44 @@ function wireStdoutToRedis(proc, ns, wire) {
                         timestamp: new Date().toISOString(),
                         chatId: 0,
                     };
-                    wire.discord.publishOutgoing(ns, msg).catch((err) => {
+                    // Publish text first (logs to chat history), then signal done for immediate finalization
+                    wire.discord.publishOutgoing(ns, msg).then(() => {
+                        rawRedis.publish(discordChatOutgoing(ns), JSON.stringify({
+                            id: crypto.randomUUID(), source: "claude", role: "assistant",
+                            content: "", event: "done", timestamp: new Date().toISOString(), chatId: 0,
+                        })).catch(() => { });
+                    }).catch((err) => {
                         console.warn(`[meta-agent-manager] publishOutgoing (result) failed (ns=${ns}):`, err.message);
+                        // Still signal done even if text publish failed
+                        rawRedis.publish(discordChatOutgoing(ns), JSON.stringify({
+                            id: crypto.randomUUID(), source: "claude", role: "assistant",
+                            content: "", event: "done", timestamp: new Date().toISOString(), chatId: 0,
+                        })).catch(() => { });
                     });
                 }
+                else if (parsed.is_error) {
+                    // Error result: publish error text and signal done
+                    const errMsg = {
+                        id: crypto.randomUUID(),
+                        source: "claude",
+                        role: "assistant",
+                        content: `⚠️ Error: ${resultText || "unknown error"}`,
+                        timestamp: new Date().toISOString(),
+                        chatId: 0,
+                    };
+                    wire.discord.publishOutgoing(ns, errMsg).catch(() => { });
+                    rawRedis.publish(discordChatOutgoing(ns), JSON.stringify({
+                        id: crypto.randomUUID(), source: "claude", role: "assistant",
+                        content: "", event: "done", timestamp: new Date().toISOString(), chatId: 0,
+                    })).catch(() => { });
+                }
+                else {
+                    // Empty result — just signal done
+                    rawRedis.publish(discordChatOutgoing(ns), JSON.stringify({
+                        id: crypto.randomUUID(), source: "claude", role: "assistant",
+                        content: "", event: "done", timestamp: new Date().toISOString(), chatId: 0,
+                    })).catch(() => { });
+                }
             }
             else {
                 structuredEvent = parsed;
@@ -298,15 +343,15 @@ function spawnPersistentSession(ns, token, wire, onExit, onOutput) {
     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.
+    // --input-format stream-json: Claude reads newline-delimited JSON messages from stdin.
+    // Each message must be: {"type":"user","message":{"role":"user","content":"..."}}
+    // Claude responds immediately to each message and stays alive waiting for the next one.
+    // DO NOT omit --input-format stream-json: without it, Claude ignores stdin when the
+    // pipe stays open (no TTY), producing no output until stdin is closed (EOF).
     const proc = spawn(claudeBin, [
         "--continue",
         "--output-format", "stream-json",
+        "--input-format", "stream-json",
         "--verbose",
         "--dangerously-skip-permissions",
     ], { cwd: wsPath, env, stdio: ["pipe", "pipe", "pipe"] });
@@ -357,13 +402,14 @@ export function createMetaAgentManager() {
      * 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) {
+    function writeToStdin(ns, content) {
         const session = sessions.get(ns);
         if (!session)
             return;
         try {
-            // Interactive mode: plain text line, Claude reads it as user input
-            session.proc.stdin.write(`${line}\n`);
+            // --input-format stream-json: each message must be a newline-delimited JSON object.
+            const jsonMsg = JSON.stringify({ type: "user", message: { role: "user", content } });
+            session.proc.stdin.write(`${jsonMsg}\n`);
             // Reset inactivity timer — the session now has SESSION_INACTIVITY_MS to respond
             session.lastOutputAt = Date.now();
         }

package/dist/notifier.js

@@ -12,7 +12,7 @@
  */
 import { createHash } from "crypto";
 import { discordChatLog, discordChatOutgoing, discordNotify, notifyChannel, chatIncomingChannel, createCcWire, TIMING, dedupKey, } from "@gonzih/cc-wire";
-import { splitLongMessage, stripAnsi } from "./formatter.js";
+import { stripAnsi } from "./formatter.js";
 /**
  * Parse an `eval_report` object embedded in a raw notification JSON string.
  * Returns null when the field is absent, malformed, or the input is not JSON.
@@ -270,25 +270,37 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
             log("info", `psubscribed to ${outgoingPattern}`);
         }
     });
-    // Buffer for meta-agent streaming output — debounced before sending to Discord
-    const metaAgentBuffers = new Map();
-    function flushMetaAgentBuffer(ns, targetChannelId) {
-        const loopThreadId = bot.getLoopThreadId(targetChannelId);
-        bot.stopMetaAgentTyping(loopThreadId ?? targetChannelId);
-        const buf = metaAgentBuffers.get(ns);
-        if (!buf || !buf.text.trim())
+    const liveStates = new Map();
+    function getLiveState(ns, targetChannelId) {
+        let state = liveStates.get(ns);
+        if (!state) {
+            state = { text: "", toolStatus: "", targetChannelId, starting: false, liveStarted: false, finalTimer: null };
+            liveStates.set(ns, state);
+        }
+        return state;
+    }
+    async function finalizeState(ns, state) {
+        if (state.finalTimer) {
+            clearTimeout(state.finalTimer);
+            state.finalTimer = null;
+        }
+        liveStates.delete(ns);
+        const deliverTo = bot.getLoopThreadId(state.targetChannelId) ?? state.targetChannelId;
+        bot.stopMetaAgentTyping(deliverTo);
+        const trimmed = state.text.trim();
+        if (!trimmed && !state.liveStarted)
             return;
-        const text = `← [${ns}] ` + stripAnsi(buf.text.trim());
-        buf.text = "";
-        buf.timer = null;
-        // During an active loop, route meta-agent output to the thread rather than main channel
-        const deliverTo = bot.getLoopThreadId(targetChannelId) ?? targetChannelId;
-        const chunks = splitLongMessage(text);
-        for (const chunk of chunks) {
-            bot.sendWithFileDetection(deliverTo, chunk).catch((err) => {
-                log("warn", `meta-agent flush sendWithFileDetection failed (ns=${ns}):`, err.message);
+        const fullText = trimmed ? `← [${ns}]\n${stripAnsi(trimmed)}` : "";
+        await bot.finalizeLiveMessage(deliverTo, fullText);
+    }
+    function scheduleFinal(ns, state) {
+        if (state.finalTimer)
+            clearTimeout(state.finalTimer);
+        state.finalTimer = setTimeout(() => {
+            finalizeState(ns, state).catch((err) => {
+                log("warn", `meta-agent finalize failed (ns=${ns}):`, err.message);
             });
-        }
+        }, TIMING.META_AGENT_FLUSH_DELAY_MS);
     }
     sub.on("pmessage", (pattern, channel, message) => {
         void pattern;
@@ -300,28 +312,78 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
         catch {
             return;
         }
-        if (parsed.source !== "claude")
-            return;
-        const content = parsed.content;
-        if (!content)
+        if (parsed?.source !== "claude")
             return;
-        // For the primary namespace: deliver to the primary Discord channel.
-        // For other (routed) namespaces: only deliver to explicitly registered channelIds.
         const targetChannelId = routedChannelIds.get(ns) ??
             (ns === namespace ? (notifyChannelId ?? getActiveChannelId?.()) : undefined);
         if (targetChannelId == null) {
-            log("warn", `meta-agent output: no channelId for namespace=${ns}, dropping line`);
+            log("warn", `meta-agent output: no channelId for namespace=${ns}, dropping`);
             return;
         }
-        let buf = metaAgentBuffers.get(ns);
-        if (!buf) {
-            buf = { text: "", timer: null };
-            metaAgentBuffers.set(ns, buf);
+        const deliverTo = bot.getLoopThreadId(targetChannelId) ?? targetChannelId;
+        const state = getLiveState(ns, targetChannelId);
+        const event = parsed.event;
+        // tool_start: show activity overlay, suspend finalize timer
+        if (event === "tool_start") {
+            const toolName = parsed.content || "tool";
+            state.toolStatus = toolName;
+            if (state.finalTimer) {
+                clearTimeout(state.finalTimer);
+                state.finalTimer = null;
+            }
+            if (state.liveStarted) {
+                const textPart = state.text.trim() ? `← [${ns}]\n${stripAnsi(state.text.trim())}\n\n` : "";
+                bot.updateLiveMessage(deliverTo, `${textPart}⚙️ \`${toolName}\`...`);
+            }
+            else if (!state.starting) {
+                state.starting = true;
+                bot.startOrGetLiveMessage(deliverTo, `⚙️ \`${toolName}\`...`).then((msg) => {
+                    state.starting = false;
+                    if (msg)
+                        state.liveStarted = true;
+                }).catch(() => { state.starting = false; });
+            }
+            return;
+        }
+        // tool_end: clear overlay, resume finalize timer if text is pending
+        if (event === "tool_end") {
+            state.toolStatus = "";
+            if (state.text.trim())
+                scheduleFinal(ns, state);
+            return;
+        }
+        // done: immediate finalization (fired by meta-agent-manager after result event)
+        if (event === "done") {
+            finalizeState(ns, state).catch((err) => {
+                log("warn", `meta-agent done finalize failed (ns=${ns}):`, err.message);
+            });
+            return;
+        }
+        // Regular text chunk: accumulate, update live message
+        const content = parsed.content;
+        if (!content)
+            return;
+        state.toolStatus = ""; // text arrived — clear any tool overlay
+        state.text += (state.text ? "\n" : "") + content;
+        const textDisplay = `← [${ns}]\n${stripAnsi(state.text)} ▋`;
+        if (!state.liveStarted) {
+            if (!state.starting) {
+                state.starting = true;
+                // startOrGetLiveMessage reuses existing message if tool_start created one
+                bot.startOrGetLiveMessage(deliverTo, textDisplay).then((msg) => {
+                    state.starting = false;
+                    if (msg) {
+                        state.liveStarted = true;
+                        bot.updateLiveMessage(deliverTo, textDisplay);
+                    }
+                }).catch(() => { state.starting = false; });
+            }
+            // Text is buffered in state.text; applied when startOrGetLiveMessage resolves
+        }
+        else {
+            bot.updateLiveMessage(deliverTo, textDisplay);
         }
-        buf.text += (buf.text ? "\n" : "") + content;
-        if (buf.timer)
-            clearTimeout(buf.timer);
-        buf.timer = setTimeout(() => flushMetaAgentBuffer(ns, targetChannelId), TIMING.META_AGENT_FLUSH_DELAY_MS);
+        scheduleFinal(ns, state);
     });
     // Poll discordNotify(ns) LIST every 5 seconds — covers primary + all routed namespaces.
     const MAX_PER_CYCLE = 20;

package/package.json

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