@gonzih/cc-tg 0.9.24 → 0.9.26

package/dist/index.js

@@ -1,179 +0,0 @@
-#!/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";
-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();
-// 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

@@ -1,47 +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
- *   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

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

package/dist/usage-limit.d.ts

@@ -1,7 +0,0 @@
-export interface UsageLimitSignal {
-    detected: boolean;
-    reason: 'usage_exhausted' | 'rate_limit';
-    retryAfterMs: number;
-    humanMessage: string;
-}
-export declare function detectUsageLimit(text: string): UsageLimitSignal;

package/dist/usage-limit.js

@@ -1,29 +0,0 @@
-export function detectUsageLimit(text) {
-    const lower = text.toLowerCase();
-    if (lower.includes('extra usage') ||
-        lower.includes('usage has been disabled') ||
-        lower.includes('billing_error') ||
-        lower.includes('usage limit')) {
-        const wake = nextHourBoundary() + 5 * 60 * 1000;
-        return {
-            detected: true,
-            reason: 'usage_exhausted',
-            retryAfterMs: wake - Date.now(),
-            humanMessage: `⏸ Claude usage limit reached. Will auto-resume at ${new Date(wake).toUTCString()}. I'll message you when it's back.`,
-        };
-    }
-    if (lower.includes('rate limit') || lower.includes('overloaded')) {
-        return {
-            detected: true,
-            reason: 'rate_limit',
-            retryAfterMs: 2 * 60 * 1000,
-            humanMessage: `⏸ Rate limited. Retrying in 2 minutes...`,
-        };
-    }
-    return { detected: false, reason: 'rate_limit', retryAfterMs: 0, humanMessage: '' };
-}
-function nextHourBoundary() {
-    const d = new Date();
-    d.setHours(d.getHours() + 1, 0, 0, 0);
-    return d.getTime();
-}

package/dist/voice.d.ts

@@ -1,13 +0,0 @@
-/**
- * Voice message transcription via whisper.cpp.
- * Flow: Telegram OGG → ffmpeg convert to 16kHz WAV → whisper-cpp → text
- */
-/**
- * Transcribe a voice message from a Telegram file URL.
- * Returns the transcribed text, or throws if whisper/ffmpeg not available.
- */
-export declare function transcribeVoice(fileUrl: string): Promise<string>;
-/**
- * Check if voice transcription is available on this system.
- */
-export declare function isVoiceAvailable(): boolean;