@gonzih/cc-discord 0.2.48 → 0.2.50

package/dist/notifier.d.ts

@@ -4,7 +4,7 @@
  * v0.2.0 channels (discord-scoped):
  *   cca:discord:notify:{ns}              — job completion notifications → forward to Discord channel
  *   cca:chat:incoming:{ns}              — messages from the web UI → echo to Discord + feed to meta-agent
- *   cca:discord:chat:outgoing:{ns}      — meta-agent stdout lines (source=claude) → buffer+debounce → Discord
+ *   cca:discord:chat:outgoing:{ns}      — meta-agent stdout lines (source=claude/codex) → buffer+debounce → Discord
  *
  * All messages (Discord incoming, Claude responses) are also written to:
  *   cca:discord:chat:log:{ns}           — LPUSH + LTRIM 0 499 (last 500 messages)
@@ -23,7 +23,7 @@ export interface EvalReport {
 import type { CcDiscordBot } from "./bot.js";
 export interface ChatMessage {
     id: string;
-    source: "discord" | "ui" | "claude" | "cc-tg" | "cc-discord";
+    source: "discord" | "ui" | "claude" | "codex" | "cc-tg" | "cc-discord";
     role: "user" | "assistant" | "tool";
     content: string;
     timestamp: string;

package/dist/notifier.js

@@ -4,7 +4,7 @@
  * v0.2.0 channels (discord-scoped):
  *   cca:discord:notify:{ns}              — job completion notifications → forward to Discord channel
  *   cca:chat:incoming:{ns}              — messages from the web UI → echo to Discord + feed to meta-agent
- *   cca:discord:chat:outgoing:{ns}      — meta-agent stdout lines (source=claude) → buffer+debounce → Discord
+ *   cca:discord:chat:outgoing:{ns}      — meta-agent stdout lines (source=claude/codex) → buffer+debounce → Discord
  *
  * All messages (Discord incoming, Claude responses) are also written to:
  *   cca:discord:chat:log:{ns}           — LPUSH + LTRIM 0 499 (last 500 messages)
@@ -270,15 +270,60 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
             log("info", `psubscribed to ${outgoingPattern}`);
         }
     });
+    const TOOL_SLOT = "tools";
+    const RESPONSE_SLOT = "response";
+    const showToolUsage = () => /^(1|true|yes)$/i.test(process.env.CC_DISCORD_SHOW_TOOL_USAGE ?? "");
     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, pendingDone: false };
+            state = {
+                text: "",
+                toolLog: [],
+                activeTool: "",
+                targetChannelId,
+                responseStarting: false,
+                responseStarted: false,
+                toolStarting: false,
+                toolStarted: false,
+                finalTimer: null,
+            };
             liveStates.set(ns, state);
         }
         return state;
     }
+    function toolLogText(ns, state, live) {
+        const visible = state.toolLog.slice(0, 20);
+        const body = visible.length > 0 ? visible.join("\n") : "waiting for tool activity";
+        return `← [${ns}] tools\n${body}${live ? " ▋" : ""}`;
+    }
+    function ensureToolLogMessage(ns, deliverTo, state) {
+        if (state.toolStarted) {
+            bot.updateLiveMessage(deliverTo, toolLogText(ns, state, true), TOOL_SLOT);
+            return Promise.resolve();
+        }
+        if (state.toolStarting)
+            return Promise.resolve();
+        state.toolStarting = true;
+        return bot.startOrGetLiveMessage(deliverTo, toolLogText(ns, state, true), TOOL_SLOT).then((msg) => {
+            state.toolStarting = false;
+            if (msg) {
+                state.toolStarted = true;
+                bot.updateLiveMessage(deliverTo, toolLogText(ns, state, true), TOOL_SLOT);
+            }
+        }).catch(() => {
+            state.toolStarting = false;
+        });
+    }
+    function replaceNewestActiveTool(state, replacement) {
+        const idx = state.toolLog.findIndex((line) => line.startsWith("⚙️"));
+        if (idx >= 0) {
+            state.toolLog[idx] = replacement;
+        }
+        else {
+            state.toolLog.unshift(replacement);
+        }
+    }
     async function finalizeState(ns, state) {
         if (state.finalTimer) {
             clearTimeout(state.finalTimer);
@@ -288,10 +333,18 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
         const deliverTo = bot.getLoopThreadId(state.targetChannelId) ?? state.targetChannelId;
         bot.stopMetaAgentTyping(deliverTo);
         const trimmed = state.text.trim();
-        if (!trimmed && !state.liveStarted)
+        const toolText = state.toolLog.length > 0 ? toolLogText(ns, state, false) : "";
+        if (showToolUsage() && (state.toolStarted || state.toolLog.length > 0)) {
+            await bot.finalizeLiveMessage(deliverTo, toolText, TOOL_SLOT);
+        }
+        if (!trimmed && !state.responseStarted)
             return;
         const fullText = trimmed ? `← [${ns}]\n${stripAnsi(trimmed)}` : "";
-        await bot.finalizeLiveMessage(deliverTo, fullText);
+        if (fullText.length > 0 && fullText.length < 30) {
+            await bot.finalizeLiveMessage(deliverTo, "", RESPONSE_SLOT);
+            return;
+        }
+        await bot.finalizeLiveMessage(deliverTo, fullText, RESPONSE_SLOT);
     }
     function scheduleFinal(ns, state) {
         if (state.finalTimer)
@@ -312,7 +365,7 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
         catch {
             return;
         }
-        if (parsed?.source !== "claude")
+        if (parsed?.source !== "claude" && parsed?.source !== "codex")
             return;
         const targetChannelId = routedChannelIds.get(ns) ??
             (ns === namespace ? (notifyChannelId ?? getActiveChannelId?.()) : undefined);
@@ -326,52 +379,33 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
         // tool_start: show activity overlay, suspend finalize timer
         if (event === "tool_start") {
             const toolName = parsed.content || "tool";
-            state.toolStatus = toolName;
+            state.activeTool = 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; });
+            if (showToolUsage()) {
+                state.toolLog.unshift(`⚙️ \`${toolName}\`...`);
+                void ensureToolLogMessage(ns, deliverTo, state);
             }
             return;
         }
         // tool_end: clear overlay, resume finalize timer if text is pending
         if (event === "tool_end") {
-            state.toolStatus = "";
+            const toolName = state.activeTool || "tool";
+            state.activeTool = "";
+            if (showToolUsage()) {
+                replaceNewestActiveTool(state, `✓ \`${toolName}\``);
+            }
+            if (showToolUsage() && state.toolStarted) {
+                bot.updateLiveMessage(deliverTo, toolLogText(ns, state, true), TOOL_SLOT);
+            }
             if (state.text.trim())
                 scheduleFinal(ns, state);
             return;
         }
-        // rate_limit: delivered after the current turn's "done" — send as a standalone message,
-        // never accumulate into live state text (which already finalized above via "done").
-        if (event === "rate_limit") {
-            const alertContent = parsed.content ?? "";
-            if (alertContent) {
-                bot.sendToChannelById(deliverTo, `← [${ns}]\n${alertContent}`).catch((err) => {
-                    log("warn", `rate_limit alert send failed (ns=${ns}):`, err.message);
-                });
-            }
-            return;
-        }
         // done: immediate finalization (fired by meta-agent-manager after result event)
         if (event === "done") {
-            if (state.starting) {
-                // startOrGetLiveMessage is still in flight — defer finalization to its .then() callback
-                // so we don't race: finalizeState runs before the Discord message exists → fallback
-                // sends a second plain message, leaving the live message orphaned with ▋.
-                state.pendingDone = true;
-                return;
-            }
             finalizeState(ns, state).catch((err) => {
                 log("warn", `meta-agent done finalize failed (ns=${ns}):`, err.message);
             });
@@ -381,31 +415,30 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
         const content = parsed.content;
         if (!content)
             return;
-        state.toolStatus = ""; // text arrived — clear any tool overlay
-        state.text += (state.text ? "\n" : "") + content;
+        state.text += parsed.source === "codex"
+            ? content
+            : (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 (!state.responseStarted) {
+            if (!state.responseStarting) {
+                state.responseStarting = true;
+                const beforeResponse = showToolUsage()
+                    ? ensureToolLogMessage(ns, deliverTo, state)
+                    : Promise.resolve();
+                beforeResponse.then(() => {
+                    return bot.startOrGetLiveMessage(deliverTo, textDisplay, RESPONSE_SLOT);
+                }).then((msg) => {
+                    state.responseStarting = false;
                     if (msg) {
-                        state.liveStarted = true;
-                        bot.updateLiveMessage(deliverTo, textDisplay);
-                    }
-                    // done arrived while we were creating the message — finalize now
-                    if (state.pendingDone) {
-                        finalizeState(ns, state).catch((err) => {
-                            log("warn", `meta-agent deferred done finalize failed (ns=${ns}):`, err.message);
-                        });
+                        state.responseStarted = true;
+                        bot.updateLiveMessage(deliverTo, textDisplay, RESPONSE_SLOT);
                     }
-                }).catch(() => { state.starting = false; });
+                }).catch(() => { state.responseStarting = false; });
             }
             // Text is buffered in state.text; applied when startOrGetLiveMessage resolves
         }
         else {
-            bot.updateLiveMessage(deliverTo, textDisplay);
+            bot.updateLiveMessage(deliverTo, textDisplay, RESPONSE_SLOT);
         }
         scheduleFinal(ns, state);
     });

package/dist/tokens.d.ts

@@ -4,7 +4,7 @@
  * Supports CLAUDE_CODE_OAUTH_TOKENS (comma-separated list of tokens).
  * Falls back to CLAUDE_CODE_OAUTH_TOKEN for single-token / backwards compat.
  *
- * cc-tg token pool rotates independently from cc-agent's pool. No coordination between them.
+ * cc-tg token pool rotates independently from cc-discord's local session pool.
  */
 /**
  * Load tokens from env vars. Called on startup; also re-callable in tests.

package/dist/tokens.js

@@ -4,7 +4,7 @@
  * Supports CLAUDE_CODE_OAUTH_TOKENS (comma-separated list of tokens).
  * Falls back to CLAUDE_CODE_OAUTH_TOKEN for single-token / backwards compat.
  *
- * cc-tg token pool rotates independently from cc-agent's pool. No coordination between them.
+ * cc-tg token pool rotates independently from cc-discord's local session pool.
  */
 let tokens = [];
 let currentIndex = 0;

package/dist/voice.js

@@ -4,22 +4,36 @@
  */
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { existsSync, createWriteStream } from "fs";
-import { unlink, readFile, access } from "fs/promises";
+import { existsSync, createWriteStream, readdirSync } from "fs";
+import { unlink, readFile, access, mkdir } from "fs/promises";
 import { tmpdir } from "os";
 import { join } from "path";
 import https from "https";
 import http from "http";
 const execFileAsync = promisify(execFile);
-// Env var overrides allow test injection: WHISPER_BIN, FFMPEG_BIN, WHISPER_MODEL
+// Env var overrides allow test injection: WHISPER_BIN, FFMPEG_BIN, WHISPER_MODEL.
+// WHISPER_MODEL may point to either a model file or a directory containing ggml*.bin.
+const WHISPER_MODEL_NAMES = [
+    "ggml-small.en.bin",
+    "ggml-small.bin",
+    "ggml-base.en.bin",
+    "ggml-base.bin",
+    "ggml-tiny.en.bin",
+    "ggml-tiny.bin",
+];
 const WHISPER_MODELS = [
     process.env.WHISPER_MODEL,
+    process.env.WHISPER_MODEL_DIR,
     "/opt/homebrew/share/whisper-cpp/ggml-small.en.bin",
     "/opt/homebrew/share/whisper-cpp/ggml-small.bin",
     "/opt/homebrew/share/whisper-cpp/ggml-base.en.bin",
     "/opt/homebrew/share/whisper-cpp/ggml-base.bin",
+    "/opt/homebrew/share/whisper-cpp",
+    "/usr/local/share/whisper-cpp",
     `${process.env.HOME}/.local/share/whisper-cpp/ggml-small.en.bin`,
     `${process.env.HOME}/.local/share/whisper-cpp/ggml-base.en.bin`,
+    `${process.env.HOME}/.local/share/whisper-cpp`,
+    `${process.env.HOME}/Library/Application Support/whisper-cpp`,
 ].filter(Boolean);
 const WHISPER_BIN_CANDIDATES = [
     process.env.WHISPER_BIN,
@@ -35,6 +49,11 @@ const FFMPEG_CANDIDATES = [
     "/usr/local/bin/ffmpeg",
     "/usr/bin/ffmpeg",
 ].filter(Boolean);
+const WHISPER_DOWNLOAD_CANDIDATES = [
+    process.env.WHISPER_DOWNLOAD_BIN,
+    "/opt/homebrew/bin/whisper-cpp-download-ggml-model",
+    "/usr/local/bin/whisper-cpp-download-ggml-model",
+].filter(Boolean);
 function findBin(candidates) {
     for (const p of candidates) {
         if (existsSync(p))
@@ -44,11 +63,39 @@ function findBin(candidates) {
 }
 function findModel() {
     for (const p of WHISPER_MODELS) {
-        if (existsSync(p))
+        if (!existsSync(p))
+            continue;
+        try {
+            const entries = readdirSync(p, { withFileTypes: true });
+            const model = WHISPER_MODEL_NAMES.find((name) => entries.some((entry) => entry.isFile() && entry.name === name));
+            if (model)
+                return join(p, model);
+            const anyModel = entries.find((entry) => entry.isFile() && /^ggml.*\.bin$/i.test(entry.name));
+            if (anyModel)
+                return join(p, anyModel.name);
+        }
+        catch {
             return p;
+        }
     }
     return null;
 }
+async function ensureModel() {
+    const existing = findModel();
+    if (existing)
+        return existing;
+    const downloader = findBin(WHISPER_DOWNLOAD_CANDIDATES);
+    if (!downloader)
+        return null;
+    const modelDir = process.env.WHISPER_MODEL_DIR || `${process.env.HOME}/.local/share/whisper-cpp`;
+    await mkdir(modelDir, { recursive: true });
+    await execFileAsync(downloader, ["small.en"], {
+        cwd: modelDir,
+        timeout: 10 * 60_000,
+        maxBuffer: 1024 * 1024,
+    });
+    return findModel();
+}
 /**
  * Download a file from a URL to dest.
  * Supports file:// (copies local file), and https/http with redirect following.
@@ -95,7 +142,7 @@ export async function transcribeVoice(fileUrl) {
     const ffmpegBin = findBin(FFMPEG_CANDIDATES);
     if (!ffmpegBin)
         throw new Error("ffmpeg not found — install with: brew install ffmpeg");
-    const model = findModel();
+    const model = await ensureModel();
     if (!model)
         throw new Error("No whisper model found — run: whisper-cpp-download-ggml-model small.en");
     const tmp = join(tmpdir(), `cc-discord-voice-${Date.now()}`);

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@gonzih/cc-discord",
-  "version": "0.2.48",
-  "description": "Claude Code Discord bot — chat with Claude Code via Discord",
+  "version": "0.2.50",
+  "description": "Discord bot for routed Claude Code or Codex agents with ATC dispatch",
   "type": "module",
   "bin": {
-    "cc-discord": "./dist/index.js"
+    "cc-discord": "dist/index.js"
   },
   "scripts": {
     "build": "tsc && chmod +x dist/index.js",
@@ -13,7 +13,8 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
-    "test:integration": "CLAUDE_BIN=./test/fixtures/mock-claude.js vitest run test/integration/"
+    "test:integration": "CLAUDE_BIN=./test/fixtures/mock-claude.js vitest run test/integration/",
+    "test:integration:codex": "CC_DISCORD_AGENT_DRIVER=codex CODEX_BIN=./test/fixtures/mock-codex.js vitest run test/integration/meta-agent.test.ts"
   },
   "files": [
     "dist/"
@@ -33,7 +34,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/Gonzih/cc-discord.git"
+    "url": "git+https://github.com/Gonzih/cc-discord.git"
   },
   "homepage": "https://github.com/Gonzih/cc-discord",
   "bugs": {
@@ -42,6 +43,8 @@
   "keywords": [
     "claude",
     "claude-code",
+    "codex",
+    "atc",
     "discord",
     "bot",
     "ai"