@gonzih/cc-tg 0.9.18 → 0.9.19

package/dist/notifier.js

@@ -0,0 +1,209 @@
+/**
+ * Notifier — subscribes to Redis pub/sub channels and bridges messages to Telegram.
+ *
+ * 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
+ *
+ * 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
+ */
+function log(level, ...args) {
+    const fn = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
+    fn("[notifier]", ...args);
+}
+/**
+ * Write a message to the chat log in Redis.
+ * Fire-and-forget — errors are logged but not thrown.
+ */
+export function writeChatLog(redis, namespace, msg) {
+    const logKey = `cca:chat:log:${namespace}`;
+    const outKey = `cca:chat:outgoing:${namespace}`;
+    const payload = JSON.stringify(msg);
+    redis.lpush(logKey, payload).catch((err) => {
+        log("warn", "writeChatLog lpush failed:", err.message);
+    });
+    redis.ltrim(logKey, 0, 499).catch((err) => {
+        log("warn", "writeChatLog ltrim failed:", err.message);
+    });
+    redis.publish(outKey, payload).catch((err) => {
+        log("warn", "writeChatLog publish failed:", err.message);
+    });
+}
+/**
+ * Start the notifier.
+ *
+ * @param bot       - Telegram bot instance (for sending messages)
+ * @param chatId    - Telegram chat ID to forward notifications to. Pass null to use getActiveChatId.
+ * @param namespace - cc-agent namespace (used to build Redis channel names)
+ * @param redis     - ioredis client in normal mode (will be duplicated for pub/sub)
+ * @param handleUserMessage - Optional callback to feed UI messages into the active Claude session
+ * @param getActiveChatId   - Optional callback to resolve chatId dynamically (used when chatId is null)
+ */
+export function startNotifier(bot, chatId, namespace, redis, handleUserMessage, getActiveChatId) {
+    const sub = redis.duplicate({
+        retryStrategy: (times) => {
+            const delay = Math.min(1000 * Math.pow(2, times - 1), 30_000);
+            log("info", `subscriber reconnecting in ${delay}ms (attempt ${times})`);
+            return delay;
+        },
+    });
+    sub.on("error", (err) => {
+        log("warn", "subscriber error:", err.message);
+    });
+    sub.on("close", () => {
+        log("info", "subscriber disconnected, will reconnect with backoff");
+    });
+    // cca:notify:{namespace} — forward job completion notifications to Telegram
+    sub.subscribe(`cca:notify:${namespace}`, (err) => {
+        if (err) {
+            log("error", `subscribe cca:notify:${namespace} failed:`, err.message);
+        }
+        else {
+            log("info", `subscribed to cca:notify:${namespace}`);
+        }
+    });
+    // cca:chat:incoming:{namespace} — messages from UI
+    sub.subscribe(`cca:chat:incoming:${namespace}`, (err) => {
+        if (err) {
+            log("error", `subscribe cca:chat:incoming:${namespace} failed:`, err.message);
+        }
+        else {
+            log("info", `subscribed to cca:chat:incoming:${namespace}`);
+        }
+    });
+    // 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}`;
+    const MAX_PER_CYCLE = 20;
+    const pollNotifyList = async () => {
+        const targetId = chatId ?? getActiveChatId?.();
+        if (targetId == null)
+            return;
+        const items = [];
+        try {
+            for (let i = 0; i < MAX_PER_CYCLE; i++) {
+                const item = await redis.rpop(notifyListKey);
+                if (item === null)
+                    break;
+                items.push(item);
+            }
+        }
+        catch (err) {
+            log("warn", "notify list rpop failed:", err.message);
+            return;
+        }
+        if (items.length === 0)
+            return;
+        let remaining = 0;
+        if (items.length === MAX_PER_CYCLE) {
+            try {
+                remaining = await redis.llen(notifyListKey);
+            }
+            catch (err) {
+                log("warn", "notify list llen failed:", err.message);
+            }
+        }
+        for (const raw of items) {
+            let text = raw;
+            try {
+                const parsed = JSON.parse(raw);
+                if (parsed.text)
+                    text = parsed.text;
+            }
+            catch {
+                // not JSON — use raw string as-is
+            }
+            bot.sendMessage(targetId, text).catch((err) => {
+                log("warn", "notify list sendMessage failed:", err.message);
+            });
+        }
+        if (remaining > 0) {
+            bot.sendMessage(targetId, `...and ${remaining} more notifications`).catch((err) => {
+                log("warn", "notify list summary sendMessage failed:", err.message);
+            });
+        }
+    };
+    setInterval(() => {
+        void pollNotifyList();
+    }, 5_000);
+    sub.on("message", (channel, message) => {
+        const notifyChannel = `cca:notify:${namespace}`;
+        const incomingChannel = `cca:chat:incoming:${namespace}`;
+        if (channel === notifyChannel) {
+            const targetId = chatId ?? getActiveChatId?.();
+            if (targetId != null) {
+                bot.sendMessage(targetId, message).catch((err) => {
+                    log("warn", "sendMessage failed:", err.message);
+                });
+            }
+            else {
+                log("warn", "notify: no chatId available, dropping notification");
+            }
+            return;
+        }
+        if (channel === incomingChannel) {
+            let content = message;
+            let originalTimestamp;
+            try {
+                const parsed = JSON.parse(message);
+                if (parsed.content)
+                    content = parsed.content;
+                if (parsed.timestamp)
+                    originalTimestamp = parsed.timestamp;
+            }
+            catch {
+                // raw string message — use as-is
+            }
+            // Resolve the target chatId: prefer the fixed chatId, fall back to last active
+            const targetChatId = chatId ?? getActiveChatId?.();
+            if (targetChatId !== undefined) {
+                // Echo to Telegram so the user sees UI messages in the chat
+                bot.sendMessage(targetChatId, `📱 [from UI]: ${content}`).catch((err) => {
+                    log("warn", "sendMessage (UI echo) failed:", err.message);
+                });
+                // Log the incoming message — preserve original timestamp from UI if present
+                const inMsg = {
+                    id: `ui-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+                    source: "ui", // 'ui' distinguishes this from telegram/claude messages
+                    role: "user",
+                    content,
+                    // ISO 8601 — matches cc-agent-ui /chat/send format; preserve original if present
+                    timestamp: originalTimestamp ?? new Date().toISOString(),
+                    chatId: targetChatId,
+                };
+                writeChatLog(redis, namespace, inMsg);
+                // Check if a meta-agent is running for this namespace; if so, route there instead
+                void (async () => {
+                    let routedToMetaAgent = false;
+                    try {
+                        const statusRaw = await redis.get(`cca:meta-agent:status:${namespace}`);
+                        if (statusRaw) {
+                            const status = JSON.parse(statusRaw);
+                            if (status.status === "running") {
+                                const entry = JSON.stringify({
+                                    id: crypto.randomUUID(),
+                                    content,
+                                    timestamp: new Date().toISOString(),
+                                });
+                                await redis.lpush(`cca:meta:${namespace}:input`, entry);
+                                log("info", `cca:chat:incoming: routed to meta-agent for namespace ${namespace}`);
+                                routedToMetaAgent = true;
+                            }
+                        }
+                    }
+                    catch (err) {
+                        log("warn", "meta-agent status check failed, falling back to coordinator:", err.message);
+                    }
+                    if (!routedToMetaAgent && handleUserMessage) {
+                        handleUserMessage(targetChatId, content);
+                    }
+                })();
+            }
+            else {
+                log("warn", "cca:chat:incoming: no active chatId to route message to");
+            }
+        }
+    });
+}

package/dist/tokens.d.ts

@@ -0,0 +1,22 @@
+/**
+ * OAuth token pool management.
+ *
+ * Supports CLAUDE_CODE_OAUTH_TOKENS (comma-separated list of tokens).
+ * Falls back to CLAUDE_CODE_OAUTH_TOKEN for single-token / backwards compat.
+ */
+/**
+ * Load tokens from env vars. Called on startup; also re-callable in tests.
+ * Priority: CLAUDE_CODE_OAUTH_TOKENS > CLAUDE_CODE_OAUTH_TOKEN > (empty)
+ */
+export declare function loadTokens(): string[];
+/** Returns the current active token, or empty string if none configured. */
+export declare function getCurrentToken(): string;
+/**
+ * Advance to the next token (wraps around).
+ * Returns the new current token.
+ */
+export declare function rotateToken(): string;
+/** Zero-based index of the current token. */
+export declare function getTokenIndex(): number;
+/** Total number of tokens in the pool. */
+export declare function getTokenCount(): number;

package/dist/tokens.js

@@ -0,0 +1,56 @@
+/**
+ * OAuth token pool management.
+ *
+ * Supports CLAUDE_CODE_OAUTH_TOKENS (comma-separated list of tokens).
+ * Falls back to CLAUDE_CODE_OAUTH_TOKEN for single-token / backwards compat.
+ */
+let tokens = [];
+let currentIndex = 0;
+let initialized = false;
+/**
+ * Load tokens from env vars. Called on startup; also re-callable in tests.
+ * Priority: CLAUDE_CODE_OAUTH_TOKENS > CLAUDE_CODE_OAUTH_TOKEN > (empty)
+ */
+export function loadTokens() {
+    const multi = process.env.CLAUDE_CODE_OAUTH_TOKENS;
+    if (multi) {
+        tokens = multi.split(",").map((t) => t.trim()).filter(Boolean);
+    }
+    else {
+        const single = process.env.CLAUDE_CODE_OAUTH_TOKEN;
+        tokens = single ? [single] : [];
+    }
+    currentIndex = 0;
+    initialized = true;
+    return tokens;
+}
+function ensureInitialized() {
+    if (!initialized)
+        loadTokens();
+}
+/** Returns the current active token, or empty string if none configured. */
+export function getCurrentToken() {
+    ensureInitialized();
+    return tokens[currentIndex] ?? "";
+}
+/**
+ * Advance to the next token (wraps around).
+ * Returns the new current token.
+ */
+export function rotateToken() {
+    ensureInitialized();
+    if (tokens.length === 0)
+        return "";
+    currentIndex = (currentIndex + 1) % tokens.length;
+    return tokens[currentIndex];
+}
+/** Zero-based index of the current token. */
+export function getTokenIndex() {
+    ensureInitialized();
+    return currentIndex;
+}
+/** Total number of tokens in the pool. */
+export function getTokenCount() {
+    ensureInitialized();
+    return tokens.length;
+}

package/dist/usage-limit.js

@@ -3,8 +3,7 @@ export function detectUsageLimit(text) {
     if (lower.includes('extra usage') ||
         lower.includes('usage has been disabled') ||
         lower.includes('billing_error') ||
-        lower.includes('usage limit reached') ||
-        lower.includes('your usage limit')) {
+        lower.includes('usage limit')) {
         const wake = nextHourBoundary() + 5 * 60 * 1000;
         return {
             detected: true,
@@ -13,7 +12,7 @@ export function detectUsageLimit(text) {
             humanMessage: `⏸ Claude usage limit reached. Will auto-resume at ${new Date(wake).toUTCString()}. I'll message you when it's back.`,
         };
     }
-    if (lower.includes('currently overloaded') || lower.includes('overloaded with requests')) {
+    if (lower.includes('rate limit') || lower.includes('overloaded')) {
         return {
             detected: true,
             reason: 'rate_limit',

package/dist/voice.js

@@ -5,7 +5,7 @@
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { existsSync } from "fs";
-import { unlink } from "fs/promises";
+import { unlink, readFile } from "fs/promises";
 import { tmpdir } from "os";
 import { join } from "path";
 import https from "https";
@@ -92,40 +92,34 @@ export async function transcribeVoice(fileUrl) {
             "-c:a", "pcm_s16le",
             wavPath,
         ]);
-        // 3. Run whisper-cpp (with one retry on signal-kill)
-        // Note: omit --output-txt — we read from stdout directly, no file write needed
-        const whisperArgs = [
-            "-m", model,
-            "-f", wavPath,
-            "--no-timestamps",
-            "-l", "auto",
-            "--no-prints", // suppress progress/timing logs from stdout so we get clean text
-        ];
-        let stdout = "";
-        for (let attempt = 1; attempt <= 2; attempt++) {
-            try {
-                const result = await execFileAsync(whisperBin, whisperArgs, {
-                    timeout: 120000, // 2 min — large audio files can take a while
-                    maxBuffer: 10 * 1024 * 1024, // 10 MB — generous for long transcriptions
-                });
-                stdout = result.stdout;
-                break;
-            }
-            catch (e) {
-                // On attempt 1: retry if killed by signal or empty message (OOM/SIGKILL)
-                if (attempt < 2 && (e.signal || !e.message)) {
-                    console.warn(`[voice] whisper attempt ${attempt} killed (${e.signal || 'no message'}), retrying...`);
-                    continue;
-                }
-                // Re-throw with stderr attached so caller can show useful diagnostics
-                const detail = (e.stderr || "").toString().trim().split("\n").slice(-5).join(" | ");
-                if (detail)
-                    e.message = `${e.message || "whisper failed"} — ${detail}`;
-                throw e;
-            }
+        // 3. Run whisper-cpp
+        // --output-txt writes to ${wavPath}.txt (NOT stdout)
+        // -l auto fails with .en models — detect and use -l en instead
+        const isEnModel = model.includes(".en.");
+        const langArgs = isEnModel ? ["-l", "en"] : ["-l", "auto"];
+        try {
+            await execFileAsync(whisperBin, [
+                "-m", model,
+                "-f", wavPath,
+                "--no-timestamps",
+                ...langArgs,
+                "--output-txt", // writes to wavPath + ".txt"
+            ]);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`whisper-cpp failed: ${msg}`);
+        }
+        // Read the output file whisper-cpp wrote
+        const txtPath = `${wavPath}.txt`;
+        let raw = "";
+        try {
+            raw = await readFile(txtPath, "utf-8");
+        }
+        catch {
+            throw new Error("whisper-cpp ran but produced no output file");
         }
-        // whisper outputs to stdout — strip leading/trailing whitespace and [BLANK_AUDIO] artifacts
-        const text = stdout
+        const text = raw
             .replace(/\[BLANK_AUDIO\]/gi, "")
             .replace(/\[.*?\]/g, "") // remove timestamp artifacts
             .trim();
@@ -135,6 +129,7 @@ export async function transcribeVoice(fileUrl) {
         // Cleanup temp files
         await unlink(oggPath).catch(() => { });
         await unlink(wavPath).catch(() => { });
+        await unlink(`${wavPath}.txt`).catch(() => { });
     }
 }
 /**

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@gonzih/cc-tg",
-  "version": "0.9.18",
+  "version": "0.9.19",
   "description": "Claude Code Telegram bot — chat with Claude Code via Telegram",
   "type": "module",
   "bin": {
     "cc-tg": "./dist/index.js"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && chmod +x dist/index.js",
     "start": "node dist/index.js",
     "dev": "node --loader ts-node/esm src/index.ts",
     "test": "vitest run",
@@ -18,10 +18,11 @@
     "dist/"
   ],
   "dependencies": {
+    "@gonzih/agent-ops": "^0.1.0",
     "node-telegram-bot-api": "^0.66.0"
   },
   "devDependencies": {
-    "@types/node": "^22.19.15",
+    "@types/node": "^22.0.0",
     "@types/node-telegram-bot-api": "^0.64.0",
     "@vitest/coverage-v8": "^4.1.0",
     "typescript": "^5.5.0",