@gonzih/cc-tg 0.9.22 → 0.9.24

package/dist/bot.d.ts

@@ -74,6 +74,7 @@ export declare class CcTgBot {
     private runCronTask;
     private handleGetFile;
     private handleDrivers;
+    private handleAgents;
     private callCcAgentTool;
     private killSession;
     getMe(): Promise<TelegramBot.User>;

package/dist/bot.js

@@ -33,6 +33,7 @@ const BOT_COMMANDS = [
     { command: "cron", description: "Manage cron jobs — add/list/edit/remove/clear" },
     { command: "voice_retry", description: "Retry failed voice message transcriptions" },
     { command: "drivers", description: "List available agent drivers" },
+    { command: "agents", description: "Show running meta-agents and their live status" },
 ];
 const FLUSH_DELAY_MS = 800; // debounce streaming chunks into one Telegram message
 const TYPING_INTERVAL_MS = 4000; // re-send typing action before Telegram's 5s expiry
@@ -73,22 +74,25 @@ function formatAgentCostSummary(text) {
     try {
         const data = JSON.parse(text);
         const totalCost = (data.total_cost_usd ?? data.total_cost ?? 0);
-        const totalJobs = (data.total_jobs ?? data.job_count ?? 0);
         const byRepo = (data.by_repo ?? []);
-        const lines = [
-            "🤖 Agent jobs (all time)",
-            `Total: $${totalCost.toFixed(2)} across ${totalJobs} jobs`,
-        ];
+        if (byRepo.length === 0) {
+            return "No cost data available yet.";
+        }
+        const lines = ["💰 Cost Summary", ""];
+        // Align repo names with right-padded costs
+        const maxLen = Math.max(...byRepo.map((e) => (e.repo ?? e.repository ?? "unknown").length));
         for (const entry of byRepo) {
             const repo = (entry.repo ?? entry.repository ?? "unknown");
             const cost = (entry.cost_usd ?? entry.cost ?? 0);
-            const jobs = (entry.job_count ?? entry.jobs ?? 0);
-            lines.push(`  ${repo}: $${cost.toFixed(2)} (${jobs} jobs)`);
+            const pad = " ".repeat(maxLen - repo.length + 3);
+            lines.push(`${repo}${pad}$${cost.toFixed(2)}`);
         }
+        lines.push("");
+        lines.push(`Total: $${totalCost.toFixed(2)}`);
         return lines.join("\n");
     }
     catch {
-        return `🤖 Agent jobs (all time)\n${text}`;
+        return `💰 Cost Summary\n${text}`;
     }
 }
 class CostStore {
@@ -392,6 +396,11 @@ export class CcTgBot {
             await this.handleDrivers(chatId, threadId);
             return;
         }
+        // /agents — show running meta-agents and their live status
+        if (text === "/agents") {
+            await this.handleAgents(chatId, threadId);
+            return;
+        }
         const session = this.getOrCreateSession(chatId, threadId, threadName);
         try {
             const enriched = await enrichPromptWithUrls(text);
@@ -1236,6 +1245,70 @@ export class CcTgBot {
             await this.replyToChat(chatId, `Failed to list drivers: ${err.message}`, threadId);
         }
     }
+    async handleAgents(chatId, threadId) {
+        if (!this.redis) {
+            await this.replyToChat(chatId, "Redis not configured — agents status unavailable.", threadId);
+            return;
+        }
+        try {
+            // Scan for all meta-agent status keys
+            const keys = [];
+            let cursor = "0";
+            do {
+                const [nextCursor, found] = await this.redis.scan(cursor, "MATCH", "cca:meta-agent:status:*", "COUNT", 100);
+                cursor = nextCursor;
+                keys.push(...found);
+            } while (cursor !== "0");
+            if (keys.length === 0) {
+                await this.replyToChat(chatId, "No active meta-agents.", threadId);
+                return;
+            }
+            const statuses = await Promise.all(keys.sort().map(async (key) => ({ key, raw: await this.redis.get(key) })));
+            const lines = ["🤖 Active Agents", ""];
+            for (const { key, raw } of statuses) {
+                const namespace = key.replace("cca:meta-agent:status:", "");
+                if (!raw) {
+                    lines.push(`${namespace} — status unknown`);
+                    continue;
+                }
+                try {
+                    const status = JSON.parse(raw);
+                    const state = status.status ?? "unknown";
+                    const turns = status.turn ?? status.turn_count ?? 0;
+                    const tool = status.current_tool;
+                    const lastActivity = status.last_activity ?? status.updated_at;
+                    let ageStr = "";
+                    if (lastActivity) {
+                        const ageSec = Math.floor((Date.now() - new Date(lastActivity).getTime()) / 1000);
+                        if (ageSec < 60)
+                            ageStr = `${ageSec}s ago`;
+                        else if (ageSec < 3600)
+                            ageStr = `${Math.floor(ageSec / 60)}m ago`;
+                        else
+                            ageStr = `${Math.floor(ageSec / 3600)}h ago`;
+                    }
+                    let statusDesc;
+                    if (state === "running" && tool) {
+                        statusDesc = `typing... (turn ${turns})`;
+                    }
+                    else if (state === "running") {
+                        statusDesc = `running (turn ${turns}${ageStr ? `, ${ageStr}` : ""})`;
+                    }
+                    else {
+                        statusDesc = `idle (turn ${turns}${ageStr ? `, ${ageStr}` : ""})`;
+                    }
+                    lines.push(`${namespace} — ${statusDesc}`);
+                }
+                catch {
+                    lines.push(`${namespace} — status unknown`);
+                }
+            }
+            await this.replyToChat(chatId, lines.join("\n"), threadId);
+        }
+        catch (err) {
+            await this.replyToChat(chatId, `Failed to get agents status: ${err.message}`, threadId);
+        }
+    }
     callCcAgentTool(toolName, args = {}) {
         // For spawn tools, pass through the configured driver and model
         const spawnTools = new Set(["spawn_agent", "spawn_from_profile"]);

package/dist/notifier.d.ts

@@ -4,6 +4,7 @@
  * Channels:
  *   cca:notify:{namespace}       — job completion notifications from cc-agent → forward to Telegram
  *   cca:chat:incoming:{namespace} — messages from the web UI → echo to Telegram + feed into Claude session
+ *   cca:chat:outgoing:*          — meta-agent stdout lines (source=claude) → buffer+debounce → Telegram
  *
  * All messages (Telegram incoming, Claude responses) are also written to:
  *   cca:chat:log:{namespace}     — LPUSH + LTRIM 0 499 (last 500 messages)
@@ -21,9 +22,10 @@ export interface ChatMessage {
 }
 /**
  * Parse a notification payload and return the display text.
- * Appends a [model] or [driver] badge if the driver is non-claude.
+ * Appends a [driver] or [driver:model] badge whenever the driver field is present.
+ * Appends " cost: $X.XXX" if a numeric cost field is present.
  *
- * Payload format (JSON): { text: string, driver?: string, model?: string }
+ * Payload format (JSON): { text: string, driver?: string, model?: string, cost?: number }
  * Falls back to raw string if not valid JSON.
  */
 export declare function parseNotification(raw: string): string;

package/dist/notifier.js

@@ -4,42 +4,72 @@
  * Channels:
  *   cca:notify:{namespace}       — job completion notifications from cc-agent → forward to Telegram
  *   cca:chat:incoming:{namespace} — messages from the web UI → echo to Telegram + feed into Claude session
+ *   cca:chat:outgoing:*          — meta-agent stdout lines (source=claude) → buffer+debounce → Telegram
  *
  * All messages (Telegram incoming, Claude responses) are also written to:
  *   cca:chat:log:{namespace}     — LPUSH + LTRIM 0 499 (last 500 messages)
  *   cca:chat:outgoing:{namespace} — PUBLISH for web UI to consume
  */
+import { splitLongMessage } from "./formatter.js";
 function log(level, ...args) {
     const fn = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
     fn("[notifier]", ...args);
 }
+/**
+ * Shorten a model name for display in a badge.
+ * - Strips driver prefix (e.g. "claude-sonnet-4-6" with driver "claude" → "sonnet-4-6")
+ * - Strips vendor/ prefix for openrouter-style names (e.g. "openai/gpt-4o" → "gpt-4o")
+ * - Returns empty string when model is absent.
+ */
+function shortenModelName(model, driver) {
+    if (!model.trim())
+        return "";
+    const pfx = driver.toLowerCase() + "-";
+    if (model.toLowerCase().startsWith(pfx))
+        return model.slice(pfx.length);
+    const slashIdx = model.indexOf("/");
+    if (slashIdx >= 0)
+        return model.slice(slashIdx + 1);
+    return model;
+}
+/** Strip ANSI escape sequences from a string before sending to Telegram. */
+function stripAnsi(text) {
+    // eslint-disable-next-line no-control-regex
+    return text.replace(/\x1B\[[0-9;]*[mGKHF]/g, "");
+}
 /**
  * Parse a notification payload and return the display text.
- * Appends a [model] or [driver] badge if the driver is non-claude.
+ * Appends a [driver] or [driver:model] badge whenever the driver field is present.
+ * Appends " cost: $X.XXX" if a numeric cost field is present.
  *
- * Payload format (JSON): { text: string, driver?: string, model?: string }
+ * Payload format (JSON): { text: string, driver?: string, model?: string, cost?: number }
  * Falls back to raw string if not valid JSON.
  */
 export function parseNotification(raw) {
     let text = raw;
     let driver;
     let model;
+    let cost;
     try {
         const parsed = JSON.parse(raw);
         if (parsed.text)
             text = parsed.text;
         driver = parsed.driver;
         model = parsed.model;
+        if (typeof parsed.cost === "number")
+            cost = parsed.cost;
     }
     catch {
         // not JSON — use raw string as-is, no badge
         return text;
     }
-    // Only show badge if driver is present and not 'claude'
-    if (!driver || driver === "claude")
+    // Show badge whenever driver field is present
+    if (!driver)
         return text;
-    const badge = model && model.trim() ? model.trim() : driver;
-    return `${text} [${badge}]`;
+    const shortModel = shortenModelName(model ?? "", driver);
+    const badge = shortModel ? `${driver}:${shortModel}` : driver;
+    const costStr = cost != null ? ` cost: $${cost.toFixed(3)}` : "";
+    return `${text}\n[${badge}]${costStr}`;
 }
 /**
  * Write a message to the chat log in Redis.
@@ -101,6 +131,65 @@ export function startNotifier(bot, chatId, namespace, redis, handleUserMessage,
             log("info", `subscribed to cca:chat:incoming:${namespace}`);
         }
     });
+    // cca:chat:outgoing:* — meta-agent stdout lines (source=claude) → buffer+debounce → Telegram
+    // Using psubscribe so we catch all namespaces (money-brain, isoc-nevada, etc.)
+    sub.psubscribe("cca:chat:outgoing:*", (err) => {
+        if (err) {
+            log("error", "psubscribe cca:chat:outgoing:* failed:", err.message);
+        }
+        else {
+            log("info", "psubscribed to cca:chat:outgoing:*");
+        }
+    });
+    // Per-namespace debounce buffer: accumulate streaming lines, flush after 1.5s silence
+    const metaAgentBuffers = new Map();
+    function flushMetaAgentBuffer(ns, targetChatId) {
+        const buf = metaAgentBuffers.get(ns);
+        if (!buf || !buf.text.trim())
+            return;
+        const text = stripAnsi(buf.text.trim());
+        buf.text = "";
+        buf.timer = null;
+        const chunks = splitLongMessage(text);
+        for (const chunk of chunks) {
+            bot.sendMessage(targetChatId, chunk).catch((err) => {
+                log("warn", `meta-agent flush sendMessage failed (ns=${ns}):`, err.message);
+            });
+        }
+    }
+    sub.on("pmessage", (pattern, channel, message) => {
+        void pattern; // used only as a type guard
+        const ns = channel.replace("cca:chat:outgoing:", "");
+        let parsed = null;
+        try {
+            parsed = JSON.parse(message);
+        }
+        catch {
+            return; // non-JSON line — skip
+        }
+        // Only forward messages from the meta-agent (source=claude).
+        // cc-tg itself publishes to this channel with source "cc-tg"/"telegram"/"ui" — skip those.
+        if (parsed.source !== "claude")
+            return;
+        const content = parsed.content;
+        if (!content)
+            return;
+        const targetChatId = chatId ?? getActiveChatId?.();
+        if (targetChatId == null) {
+            log("warn", `meta-agent output: no chatId for namespace=${ns}, dropping line`);
+            return;
+        }
+        // Accumulate into per-namespace buffer and (re-)arm debounce timer
+        let buf = metaAgentBuffers.get(ns);
+        if (!buf) {
+            buf = { text: "", timer: null };
+            metaAgentBuffers.set(ns, buf);
+        }
+        buf.text += (buf.text ? "\n" : "") + content;
+        if (buf.timer)
+            clearTimeout(buf.timer);
+        buf.timer = setTimeout(() => flushMetaAgentBuffer(ns, targetChatId), 1500);
+    });
     // Poll the cca:notify:{namespace} LIST every 5 seconds.
     // Jobs push to this list via RPUSH; pub/sub alone won't deliver those messages.
     const notifyListKey = `cca:notify:${namespace}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonzih/cc-tg",
-  "version": "0.9.22",
+  "version": "0.9.24",
   "description": "Claude Code Telegram bot — chat with Claude Code via Telegram",
   "type": "module",
   "bin": {