@gonzih/cc-tg 0.9.28 → 0.9.29

package/dist/index.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+/**
+ * cc-tg — Claude Code Telegram bot
+ *
+ * Usage:
+ *   npx @gonzih/cc-tg
+ *
+ * Required env:
+ *   TELEGRAM_BOT_TOKEN   — from @BotFather
+ *   CLAUDE_CODE_TOKEN    — your Claude Code OAuth token (or ANTHROPIC_API_KEY)
+ *
+ * Optional env:
+ *   ALLOWED_USER_IDS     — comma-separated Telegram user IDs (leave empty to allow all)
+ *   GROUP_CHAT_IDS       — comma-separated Telegram group/supergroup chat IDs (leave empty to allow all groups)
+ *   CWD                  — working directory for Claude Code (default: process.cwd())
+ */
+import { createServer, createConnection } from "net";
+import { unlinkSync, readFileSync } from "fs";
+import { tmpdir } from "os";
+import os from "os";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import TelegramBot from "node-telegram-bot-api";
+import { CcTgBot } from "./bot.js";
+import { loadTokens } from "./tokens.js";
+import { Registry, startControlServer } from "@gonzih/agent-ops";
+import { Redis } from "ioredis";
+import { startNotifier } from "./notifier.js";
+import { seedClaudeMd } from "./seed.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
+// Make lock socket unique per bot token so multiple users on the same machine don't collide
+const _tokenHash = Buffer.from(process.env.TELEGRAM_BOT_TOKEN ?? "default").toString("base64").replace(/[^a-z0-9]/gi, "").slice(0, 16);
+const LOCK_SOCKET = join(tmpdir(), `cc-tg-${_tokenHash}.sock`);
+function acquireLock() {
+    return new Promise((resolve) => {
+        const server = createServer();
+        server.listen(LOCK_SOCKET, () => {
+            // Bound successfully — we own the lock. Socket auto-released on any exit incl. SIGKILL.
+            resolve(true);
+        });
+        server.on("error", (err) => {
+            if (err.code !== "EADDRINUSE") {
+                resolve(true); // unrelated error, proceed
+                return;
+            }
+            // Socket path exists — probe if anything is actually listening
+            const probe = createConnection(LOCK_SOCKET);
+            probe.on("connect", () => {
+                probe.destroy();
+                console.error("[cc-tg] Another instance is already running. Exiting.");
+                resolve(false);
+            });
+            probe.on("error", () => {
+                // Nothing listening — stale socket, remove and retry
+                try {
+                    unlinkSync(LOCK_SOCKET);
+                }
+                catch { }
+                const retry = createServer();
+                retry.listen(LOCK_SOCKET, () => resolve(true));
+                retry.on("error", () => resolve(true)); // give up on lock, just start
+            });
+        });
+    });
+}
+const lockAcquired = await acquireLock();
+if (!lockAcquired) {
+    process.exit(1);
+}
+function required(name) {
+    const val = process.env[name];
+    if (!val) {
+        console.error(`
+ERROR: ${name} is not set.
+
+cc-tg requires:
+  TELEGRAM_BOT_TOKEN   — get one from @BotFather on Telegram
+  CLAUDE_CODE_TOKEN    — your Claude Code OAuth token
+
+Set them and run again:
+  TELEGRAM_BOT_TOKEN=xxx CLAUDE_CODE_TOKEN=yyy npx @gonzih/cc-tg
+
+Or add to your shell profile / .env file.
+`);
+        process.exit(1);
+    }
+    return val;
+}
+const telegramToken = required("TELEGRAM_BOT_TOKEN");
+// Accept CLAUDE_CODE_TOKEN, CLAUDE_CODE_OAUTH_TOKEN, or ANTHROPIC_API_KEY
+const claudeToken = process.env.CLAUDE_CODE_TOKEN ??
+    process.env.CLAUDE_CODE_OAUTH_TOKEN ??
+    process.env.ANTHROPIC_API_KEY;
+if (!claudeToken) {
+    console.error(`
+ERROR: No Claude token set. Set one of: CLAUDE_CODE_TOKEN, CLAUDE_CODE_OAUTH_TOKEN, or ANTHROPIC_API_KEY.
+
+Set one and run again:
+  TELEGRAM_BOT_TOKEN=xxx CLAUDE_CODE_TOKEN=yyy npx @gonzih/cc-tg
+`);
+    process.exit(1);
+}
+// Load OAuth token pool (supports CLAUDE_CODE_OAUTH_TOKENS for multi-account rotation)
+const tokenPool = loadTokens();
+if (tokenPool.length > 1) {
+    console.log(`[cc-tg] Token pool loaded: ${tokenPool.length} tokens — will rotate on usage limit`);
+}
+const allowedUserIds = process.env.ALLOWED_USER_IDS
+    ? process.env.ALLOWED_USER_IDS.split(",").map((s) => parseInt(s.trim(), 10)).filter(Boolean)
+    : [];
+const groupChatIds = process.env.GROUP_CHAT_IDS
+    ? process.env.GROUP_CHAT_IDS.split(",").map((s) => parseInt(s.trim(), 10)).filter(Boolean)
+    : [];
+const cwd = process.env.CWD ?? process.cwd();
+seedClaudeMd(cwd);
+// agent-ops / chat bridge — Redis is always initialized so the chat bridge works
+// regardless of whether CC_AGENT_OPS_PORT or CC_AGENT_NOTIFY_CHAT_ID are set.
+const redisUrl = process.env.REDIS_URL || "redis://localhost:6379";
+const namespace = process.env.CC_AGENT_NAMESPACE || "default";
+const sharedRedis = new Redis(redisUrl);
+sharedRedis.on("error", (err) => {
+    // Non-fatal — Redis features (chat bridge, ops) degrade gracefully
+    console.warn("[redis] connection error:", err.message);
+});
+sharedRedis.once("ready", () => {
+    sharedRedis.set("cca:meta:cc-tg:version", pkg.version).catch((err) => {
+        console.warn("[redis] failed to write version:", err.message);
+    });
+    console.log(`[cc-tg] version:reported ${pkg.version}`);
+});
+const bot = new CcTgBot({
+    telegramToken,
+    claudeToken,
+    cwd,
+    allowedUserIds,
+    groupChatIds,
+    redis: sharedRedis,
+    namespace,
+});
+if (process.env.CC_AGENT_OPS_PORT) {
+    const botInfo = await bot.getMe();
+    const registry = new Registry(sharedRedis);
+    await registry.register({
+        namespace,
+        hostname: os.hostname(),
+        user: os.userInfo().username,
+        pid: String(process.pid),
+        version: pkg.version,
+        cwd: process.env.CWD || process.cwd(),
+        control_port: process.env.CC_AGENT_OPS_PORT,
+        bot_username: botInfo.username ?? "",
+        started_at: new Date().toISOString(),
+    });
+    setInterval(() => registry.heartbeat(namespace), 60_000);
+    startControlServer(Number(process.env.CC_AGENT_OPS_PORT), {
+        namespace,
+        version: pkg.version,
+        logFile: process.env.CC_AGENT_LOG_FILE || process.env.LOG_FILE,
+    });
+    console.log(`[ops] control server on port ${process.env.CC_AGENT_OPS_PORT}`);
+}
+// Notifier — always subscribe to cca:notify and cca:chat:incoming channels.
+// CC_AGENT_NOTIFY_CHAT_ID pins a fixed Telegram chatId; without it the last
+// active chatId is used dynamically for the chat bridge.
+const notifyChatId = process.env.CC_AGENT_NOTIFY_CHAT_ID
+    ? Number(process.env.CC_AGENT_NOTIFY_CHAT_ID)
+    : null;
+const notifierBot = new TelegramBot(telegramToken, { polling: false });
+startNotifier(notifierBot, notifyChatId, namespace, sharedRedis, (cid, text) => bot.handleUserMessage(cid, text), () => bot.getLastActiveChatId());
+console.log(`[notifier] started for namespace=${namespace} chatId=${notifyChatId ?? "dynamic"}`);
+process.on("SIGINT", () => {
+    console.log("\nShutting down...");
+    bot.stop();
+    process.exit(0);
+});
+process.on("SIGTERM", () => {
+    bot.stop();
+    process.exit(0);
+});

package/dist/notifier.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 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
+ *   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 { Redis } from "ioredis";
+import TelegramBot from "node-telegram-bot-api";
+export interface ChatMessage {
+    id: string;
+    source: "telegram" | "ui" | "claude" | "cc-tg";
+    role: "user" | "assistant" | "tool";
+    content: string;
+    timestamp: string;
+    chatId: number;
+}
+/**
+ * Parse a notification payload and return the display text.
+ * 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, cost?: number }
+ * Falls back to raw string if not valid JSON.
+ */
+export declare function parseNotification(raw: string): string;
+/**
+ * Write a message to the chat log in Redis.
+ * Fire-and-forget — errors are logged but not thrown.
+ */
+export declare function writeChatLog(redis: Redis, namespace: string, msg: ChatMessage): void;
+/**
+ * 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 declare function startNotifier(bot: TelegramBot, chatId: number | null, namespace: string, redis: Redis, handleUserMessage?: (chatId: number, text: string) => void, getActiveChatId?: () => number | undefined): void;

package/dist/notifier.js

@@ -0,0 +1,319 @@
+/**
+ * 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
+ *   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 [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, 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;
+    }
+    // Show badge whenever driver field is present
+    if (!driver)
+        return text;
+    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.
+ * 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}`);
+        }
+    });
+    // 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}`;
+    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) {
+            const text = parseNotification(raw);
+            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) {
+                const text = parseNotification(message);
+                bot.sendMessage(targetId, text).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/seed.d.ts

@@ -0,0 +1 @@
+export declare function seedClaudeMd(cwd: string): void;