@gonzih/cc-tg 0.9.19 → 0.9.21

package/dist/notifier.js

@@ -1,209 +0,0 @@
-/**
- * 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

@@ -1,22 +0,0 @@
-/**
- * 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

@@ -1,56 +0,0 @@
-/**
- * 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;
-}