@gonzih/cc-tg 0.7.1 → 0.7.2

package/dist/index.js

@@ -0,0 +1,169 @@
+#!/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();
+const bot = new CcTgBot({
+    telegramToken,
+    claudeToken,
+    cwd,
+    allowedUserIds,
+    groupChatIds,
+});
+// agent-ops: optional self-registration + HTTP control endpoint
+const redisUrl = process.env.REDIS_URL || "redis://localhost:6379";
+const namespace = process.env.CC_AGENT_NAMESPACE || "default";
+let sharedRedis = null;
+if (process.env.CC_AGENT_OPS_PORT) {
+    const botInfo = await bot.getMe();
+    sharedRedis = new Redis(redisUrl);
+    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 — subscribe to cca:notify:{namespace} and cca:chat:incoming:{namespace}
+const notifyChatId = process.env.CC_AGENT_NOTIFY_CHAT_ID
+    ? Number(process.env.CC_AGENT_NOTIFY_CHAT_ID)
+    : null;
+if (notifyChatId) {
+    if (!sharedRedis)
+        sharedRedis = new Redis(redisUrl);
+    const notifierBot = new TelegramBot(telegramToken, { polling: false });
+    startNotifier(notifierBot, notifyChatId, namespace, sharedRedis, (cid, text) => bot.handleUserMessage(cid, text));
+    console.log(`[notifier] started for namespace=${namespace} chatId=${notifyChatId}`);
+}
+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,36 @@
+/**
+ * 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
+ */
+import { Redis } from "ioredis";
+import TelegramBot from "node-telegram-bot-api";
+export interface ChatMessage {
+    id: string;
+    source: "telegram" | "ui" | "claude";
+    role: "user" | "assistant";
+    content: string;
+    timestamp: string;
+    chatId: number;
+}
+/**
+ * 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
+ * @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
+ */
+export declare function startNotifier(bot: TelegramBot, chatId: number, namespace: string, redis: Redis, handleUserMessage?: (chatId: number, text: string) => void): void;

package/dist/notifier.js

@@ -0,0 +1,105 @@
+/**
+ * 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
+ * @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
+ */
+export function startNotifier(bot, chatId, namespace, redis, handleUserMessage) {
+    const sub = redis.duplicate();
+    sub.on("error", (err) => {
+        log("warn", "subscriber error:", err.message);
+    });
+    // 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}`);
+        }
+    });
+    sub.on("message", (channel, message) => {
+        const notifyChannel = `cca:notify:${namespace}`;
+        const incomingChannel = `cca:chat:incoming:${namespace}`;
+        if (channel === notifyChannel) {
+            bot.sendMessage(chatId, message).catch((err) => {
+                log("warn", "sendMessage failed:", err.message);
+            });
+            return;
+        }
+        if (channel === incomingChannel) {
+            let content = message;
+            try {
+                const parsed = JSON.parse(message);
+                if (parsed.content)
+                    content = parsed.content;
+            }
+            catch {
+                // raw string message — use as-is
+            }
+            // Echo to Telegram so the user sees UI messages in the chat
+            bot.sendMessage(chatId, `📱 [from UI]: ${content}`).catch((err) => {
+                log("warn", "sendMessage (UI echo) failed:", err.message);
+            });
+            // Log the incoming message
+            const inMsg = {
+                id: `ui-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+                source: "ui",
+                role: "user",
+                content,
+                timestamp: new Date().toISOString(),
+                chatId,
+            };
+            writeChatLog(redis, namespace, inMsg);
+            // Feed into active Claude session as if user typed it
+            if (handleUserMessage) {
+                handleUserMessage(chatId, content);
+            }
+        }
+    });
+}

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.d.ts

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

@@ -0,0 +1,29 @@
+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

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

package/dist/voice.js

@@ -0,0 +1,124 @@
+/**
+ * Voice message transcription via whisper.cpp.
+ * Flow: Telegram OGG → ffmpeg convert to 16kHz WAV → whisper-cpp → text
+ */
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { existsSync } from "fs";
+import { unlink } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import https from "https";
+import http from "http";
+import { createWriteStream } from "fs";
+const execFileAsync = promisify(execFile);
+// Whisper model — small.en is fast and accurate enough for commands
+// Falls back to base.en if small not found
+const WHISPER_MODELS = [
+    "/opt/homebrew/share/whisper-cpp/ggml-small.en.bin",
+    "/opt/homebrew/share/whisper-cpp/ggml-small.bin",
+    "/opt/homebrew/share/whisper-cpp/ggml-base.en.bin",
+    "/opt/homebrew/share/whisper-cpp/ggml-base.bin",
+    // user-local
+    `${process.env.HOME}/.local/share/whisper-cpp/ggml-small.en.bin`,
+    `${process.env.HOME}/.local/share/whisper-cpp/ggml-base.en.bin`,
+];
+const WHISPER_BIN_CANDIDATES = [
+    "/opt/homebrew/bin/whisper-cli", // whisper-cpp brew formula installs as whisper-cli
+    "/opt/homebrew/bin/whisper-cpp",
+    "/usr/local/bin/whisper-cli",
+    "/usr/local/bin/whisper-cpp",
+    "/opt/homebrew/bin/whisper",
+];
+const FFMPEG_CANDIDATES = [
+    "/opt/homebrew/bin/ffmpeg",
+    "/usr/local/bin/ffmpeg",
+    "/usr/bin/ffmpeg",
+];
+function findBin(candidates) {
+    for (const p of candidates) {
+        if (existsSync(p))
+            return p;
+    }
+    return null;
+}
+function findModel() {
+    for (const p of WHISPER_MODELS) {
+        if (existsSync(p))
+            return p;
+    }
+    return null;
+}
+function downloadFile(url, dest) {
+    return new Promise((resolve, reject) => {
+        const file = createWriteStream(dest);
+        const getter = url.startsWith("https") ? https : http;
+        getter.get(url, (res) => {
+            if (res.statusCode !== 200) {
+                reject(new Error(`HTTP ${res.statusCode} downloading ${url}`));
+                return;
+            }
+            res.pipe(file);
+            file.on("finish", () => file.close(() => resolve()));
+            file.on("error", reject);
+        }).on("error", reject);
+    });
+}
+/**
+ * Transcribe a voice message from a Telegram file URL.
+ * Returns the transcribed text, or throws if whisper/ffmpeg not available.
+ */
+export async function transcribeVoice(fileUrl) {
+    const whisperBin = findBin(WHISPER_BIN_CANDIDATES);
+    if (!whisperBin)
+        throw new Error("whisper-cpp not found — install with: brew install whisper-cpp");
+    const ffmpegBin = findBin(FFMPEG_CANDIDATES);
+    if (!ffmpegBin)
+        throw new Error("ffmpeg not found — install with: brew install ffmpeg");
+    const model = findModel();
+    if (!model)
+        throw new Error("No whisper model found — run: whisper-cpp-download-ggml-model small.en");
+    const tmp = join(tmpdir(), `cc-tg-voice-${Date.now()}`);
+    const oggPath = `${tmp}.ogg`;
+    const wavPath = `${tmp}.wav`;
+    try {
+        // 1. Download OGG from Telegram
+        await downloadFile(fileUrl, oggPath);
+        // 2. Convert OGG → 16kHz mono WAV (whisper requirement)
+        await execFileAsync(ffmpegBin, [
+            "-y", "-i", oggPath,
+            "-ar", "16000",
+            "-ac", "1",
+            "-c:a", "pcm_s16le",
+            wavPath,
+        ]);
+        // 3. Run whisper-cpp
+        const { stdout } = await execFileAsync(whisperBin, [
+            "-m", model,
+            "-f", wavPath,
+            "--no-timestamps",
+            "-l", "auto",
+            "--output-txt",
+        ]);
+        // whisper outputs to stdout — strip leading/trailing whitespace and [BLANK_AUDIO] artifacts
+        const text = stdout
+            .replace(/\[BLANK_AUDIO\]/gi, "")
+            .replace(/\[.*?\]/g, "") // remove timestamp artifacts
+            .trim();
+        return text || "[empty transcription]";
+    }
+    finally {
+        // Cleanup temp files
+        await unlink(oggPath).catch(() => { });
+        await unlink(wavPath).catch(() => { });
+        await unlink(`${wavPath}.txt`).catch(() => { });
+    }
+}
+/**
+ * Check if voice transcription is available on this system.
+ */
+export function isVoiceAvailable() {
+    return (findBin(WHISPER_BIN_CANDIDATES) !== null &&
+        findBin(FFMPEG_CANDIDATES) !== null &&
+        findModel() !== null);
+}

package/package.json

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