@gonzih/cc-tg 0.7.0 → 0.7.1

package/dist/claude.d.ts

@@ -1,54 +0,0 @@
-/**
- * Claude Code subprocess wrapper.
- * Mirrors ce_ce's mechanism: spawn `claude` CLI with stream-json I/O,
- * pipe prompts in, parse streaming JSON messages out.
- */
-import { EventEmitter } from "events";
-export type MessageType = "system" | "assistant" | "user" | "result";
-export interface ClaudeMessage {
-    type: MessageType;
-    session_id?: string;
-    uuid?: string;
-    payload: Record<string, unknown>;
-    raw: Record<string, unknown>;
-}
-export interface ClaudeOptions {
-    cwd?: string;
-    systemPrompt?: string;
-    /** OAuth token (sk-ant-oat01-...) or API key (sk-ant-api03-...) */
-    token?: string;
-}
-export interface UsageEvent {
-    inputTokens: number;
-    outputTokens: number;
-    cacheReadTokens: number;
-    cacheWriteTokens: number;
-}
-export declare interface ClaudeProcess {
-    on(event: "message", listener: (msg: ClaudeMessage) => void): this;
-    on(event: "usage", listener: (usage: UsageEvent) => void): this;
-    on(event: "error", listener: (err: Error) => void): this;
-    on(event: "exit", listener: (code: number | null) => void): this;
-    on(event: "stderr", listener: (data: string) => void): this;
-}
-export declare class ClaudeProcess extends EventEmitter {
-    private proc;
-    private buffer;
-    private _exited;
-    constructor(opts?: ClaudeOptions);
-    sendPrompt(text: string): void;
-    /**
-     * Send an image (with optional text caption) to Claude via stream-json content blocks.
-     * mediaType: image/jpeg | image/png | image/gif | image/webp
-     */
-    sendImage(base64Data: string, mediaType: string, caption?: string): void;
-    kill(): void;
-    get exited(): boolean;
-    private drainBuffer;
-    private parseMessage;
-}
-/**
- * Extract the text content from an assistant message payload.
- * Handles both simple string content and content-block arrays.
- */
-export declare function extractText(msg: ClaudeMessage): string;

package/dist/claude.js

@@ -1,208 +0,0 @@
-/**
- * Claude Code subprocess wrapper.
- * Mirrors ce_ce's mechanism: spawn `claude` CLI with stream-json I/O,
- * pipe prompts in, parse streaming JSON messages out.
- */
-import { spawn } from "child_process";
-import { EventEmitter } from "events";
-import { existsSync } from "fs";
-export class ClaudeProcess extends EventEmitter {
-    proc;
-    buffer = "";
-    _exited = false;
-    constructor(opts = {}) {
-        super();
-        const args = [
-            "--continue",
-            "--output-format", "stream-json",
-            "--input-format", "stream-json",
-            "--print",
-            "--verbose",
-            "--dangerously-skip-permissions",
-        ];
-        if (opts.systemPrompt) {
-            args.push("--system-prompt", opts.systemPrompt);
-        }
-        const env = { ...process.env };
-        if (opts.token) {
-            // API keys start with sk-ant-api — set ANTHROPIC_API_KEY only
-            // Everything else (OAuth sk-ant-oat, setup-token format with #, etc.)
-            // goes into CLAUDE_CODE_OAUTH_TOKEN
-            // Mixing them causes "Invalid API key" errors
-            if (opts.token.startsWith("sk-ant-api")) {
-                env.ANTHROPIC_API_KEY = opts.token;
-                delete env.CLAUDE_CODE_OAUTH_TOKEN;
-            }
-            else {
-                env.CLAUDE_CODE_OAUTH_TOKEN = opts.token;
-                delete env.ANTHROPIC_API_KEY;
-            }
-        }
-        // Resolve claude binary — check common install locations if not in PATH
-        const claudeBin = resolveClaude(env.PATH);
-        this.proc = spawn(claudeBin, args, {
-            cwd: opts.cwd ?? process.cwd(),
-            env,
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        this.proc.stdout.on("data", (chunk) => {
-            this.buffer += chunk.toString();
-            this.drainBuffer();
-        });
-        this.proc.stderr.on("data", (chunk) => {
-            this.emit("stderr", chunk.toString());
-        });
-        this.proc.on("exit", (code) => {
-            this._exited = true;
-            this.emit("exit", code);
-        });
-        this.proc.on("error", (err) => {
-            this.emit("error", err);
-        });
-    }
-    sendPrompt(text) {
-        if (this._exited)
-            throw new Error("Claude process has exited");
-        const payload = JSON.stringify({
-            type: "user",
-            message: { role: "user", content: text },
-        });
-        this.proc.stdin.write(payload + "\n");
-    }
-    /**
-     * Send an image (with optional text caption) to Claude via stream-json content blocks.
-     * mediaType: image/jpeg | image/png | image/gif | image/webp
-     */
-    sendImage(base64Data, mediaType, caption) {
-        if (this._exited)
-            throw new Error("Claude process has exited");
-        const content = [];
-        if (caption) {
-            content.push({ type: "text", text: caption });
-        }
-        content.push({
-            type: "image",
-            source: {
-                type: "base64",
-                media_type: mediaType,
-                data: base64Data,
-            },
-        });
-        const payload = JSON.stringify({
-            type: "user",
-            message: { role: "user", content },
-        });
-        this.proc.stdin.write(payload + "\n");
-    }
-    kill() {
-        this.proc.kill();
-    }
-    get exited() {
-        return this._exited;
-    }
-    drainBuffer() {
-        const lines = this.buffer.split("\n");
-        // Last element may be incomplete — keep it
-        this.buffer = lines.pop() ?? "";
-        for (const line of lines) {
-            if (!line.trim())
-                continue;
-            let raw;
-            try {
-                raw = JSON.parse(line);
-            }
-            catch {
-                // Non-JSON line (startup noise etc.) — ignore
-                continue;
-            }
-            // Emit usage events from Anthropic API stream events passed through by Claude CLI
-            if (raw.type === "message_start") {
-                const usage = (raw.message?.usage);
-                if (usage) {
-                    this.emit("usage", {
-                        inputTokens: usage.input_tokens ?? 0,
-                        outputTokens: 0, // output_tokens at message_start is always 0
-                        cacheReadTokens: usage.cache_read_input_tokens ?? 0,
-                        cacheWriteTokens: usage.cache_creation_input_tokens ?? 0,
-                    });
-                }
-            }
-            else if (raw.type === "message_delta") {
-                const usage = raw.usage;
-                if (usage?.output_tokens) {
-                    this.emit("usage", {
-                        inputTokens: 0,
-                        outputTokens: usage.output_tokens,
-                        cacheReadTokens: 0,
-                        cacheWriteTokens: 0,
-                    });
-                }
-            }
-            const msg = this.parseMessage(raw);
-            if (msg)
-                this.emit("message", msg);
-        }
-    }
-    parseMessage(raw) {
-        const type = raw.type;
-        if (!type)
-            return null;
-        return {
-            type,
-            session_id: raw.session_id,
-            uuid: raw.uuid,
-            payload: raw,
-            raw,
-        };
-    }
-}
-/**
- * Extract the text content from an assistant message payload.
- * Handles both simple string content and content-block arrays.
- */
-export function extractText(msg) {
-    const message = msg.payload.message;
-    if (!message) {
-        // result message type
-        if (msg.type === "result") {
-            return msg.payload.result ?? "";
-        }
-        return "";
-    }
-    const content = message.content;
-    if (typeof content === "string")
-        return content;
-    if (Array.isArray(content)) {
-        return content
-            .filter((b) => b.type === "text")
-            .map((b) => b.text)
-            .join("");
-    }
-    return "";
-}
-/**
- * Resolve the claude CLI binary path.
- * Checks PATH entries + common npm global install locations.
- */
-function resolveClaude(pathEnv) {
-    // Try PATH entries first
-    const dirs = (pathEnv ?? process.env.PATH ?? "").split(":");
-    for (const dir of dirs) {
-        const candidate = `${dir}/claude`;
-        if (existsSync(candidate))
-            return candidate;
-    }
-    // Common fallback locations
-    const fallbacks = [
-        `${process.env.HOME}/.npm-global/bin/claude`,
-        "/opt/homebrew/bin/claude",
-        "/usr/local/bin/claude",
-        "/usr/bin/claude",
-    ];
-    for (const p of fallbacks) {
-        if (existsSync(p))
-            return p;
-    }
-    // Last resort — let the OS resolve it (will throw ENOENT if missing)
-    return "claude";
-}

package/dist/formatter.d.ts

@@ -1,25 +0,0 @@
-/**
- * Telegram HTML post-processor.
- * Converts standard markdown to Telegram's HTML parse mode format.
- */
-/**
- * Convert standard markdown text to Telegram HTML format.
- *
- * Processing order:
- * 1. Extract fenced code blocks (``` ... ```) → <pre>, protect from further processing
- * 2. Extract inline code (`...`) → <code>, protect from further processing
- * 3. HTML-escape remaining text: & → &amp;  < → &lt;  > → &gt;
- * 4. Convert --- → blank line
- * 5. Convert ## headings → <b>Heading</b>
- * 6. Convert **bold** → <b>bold</b>
- * 7. Convert - item / * item → • item
- * 8. Convert *bold* → <b>bold</b>
- * 9. Convert _italic_ → <i>italic</i>
- * 10. Reinsert code blocks
- */
-export declare function formatForTelegram(text: string): string;
-/**
- * Split a long message at natural boundaries (paragraph > line > word).
- * Never splits mid-word or inside <pre> blocks. Chunks are at most maxLen characters.
- */
-export declare function splitLongMessage(text: string, maxLen?: number): string[];

package/dist/formatter.js

@@ -1,122 +0,0 @@
-/**
- * Telegram HTML post-processor.
- * Converts standard markdown to Telegram's HTML parse mode format.
- */
-function htmlEscape(text) {
-    return text
-        .replace(/&/g, "&")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;");
-}
-/**
- * Convert standard markdown text to Telegram HTML format.
- *
- * Processing order:
- * 1. Extract fenced code blocks (``` ... ```) → <pre>, protect from further processing
- * 2. Extract inline code (`...`) → <code>, protect from further processing
- * 3. HTML-escape remaining text: & → &amp;  < → &lt;  > → &gt;
- * 4. Convert --- → blank line
- * 5. Convert ## headings → <b>Heading</b>
- * 6. Convert **bold** → <b>bold</b>
- * 7. Convert - item / * item → • item
- * 8. Convert *bold* → <b>bold</b>
- * 9. Convert _italic_ → <i>italic</i>
- * 10. Reinsert code blocks
- */
-export function formatForTelegram(text) {
-    const placeholders = [];
-    // Step 1: Extract fenced code blocks (``` ... ```) → <pre>
-    let out = text.replace(/```(?:\w*)\n?([\s\S]*?)```/g, (_, content) => {
-        placeholders.push(`<pre>${htmlEscape(content)}</pre>`);
-        return `\x00P${placeholders.length - 1}\x00`;
-    });
-    // Step 2: Extract inline code (`...`) → <code>
-    out = out.replace(/`([^`\n]+)`/g, (_, content) => {
-        placeholders.push(`<code>${htmlEscape(content)}</code>`);
-        return `\x00P${placeholders.length - 1}\x00`;
-    });
-    // Step 3: HTML-escape remaining text
-    out = htmlEscape(out);
-    // Step 4: Convert --- → blank line
-    out = out.replace(/^-{3,}$/gm, "");
-    // Step 5: Convert ## headings → <b>Heading</b>
-    out = out.replace(/^#{1,6}\s+(.+)$/gm, "<b>$1</b>");
-    // Step 6: Convert **bold** → <b>bold</b>
-    out = out.replace(/\*\*(.+?)\*\*/gs, "<b>$1</b>");
-    // Step 7: Convert - item / * item → • item
-    out = out.replace(/^[ \t]*[-*]\s+(.+)$/gm, "• $1");
-    // Step 8: Convert *bold* → <b>bold</b> (single asterisk, after bullets handled)
-    out = out.replace(/\*([^*\n]+)\*/g, "<b>$1</b>");
-    // Step 9: Convert _italic_ → <i>italic</i>
-    // Use word-boundary guards to avoid mangling snake_case identifiers
-    out = out.replace(/(?<![a-zA-Z0-9])_([^_\n]+?)_(?![a-zA-Z0-9])/g, "<i>$1</i>");
-    // Step 10: Reinsert code blocks
-    out = out.replace(/\x00P(\d+)\x00/g, (_, i) => placeholders[parseInt(i, 10)]);
-    return out;
-}
-function findPreRanges(text) {
-    const ranges = [];
-    const open = "<pre>";
-    const close = "</pre>";
-    let i = 0;
-    while (i < text.length) {
-        const start = text.indexOf(open, i);
-        if (start === -1)
-            break;
-        const end = text.indexOf(close, start);
-        if (end === -1)
-            break;
-        ranges.push([start, end + close.length]);
-        i = end + close.length;
-    }
-    return ranges;
-}
-function isInsidePre(pos, ranges) {
-    return ranges.some(([start, end]) => pos > start && pos < end);
-}
-/**
- * Split a long message at natural boundaries (paragraph > line > word).
- * Never splits mid-word or inside <pre> blocks. Chunks are at most maxLen characters.
- */
-export function splitLongMessage(text, maxLen = 4096) {
-    if (text.length <= maxLen)
-        return [text];
-    const chunks = [];
-    let remaining = text;
-    while (remaining.length > maxLen) {
-        const slice = remaining.slice(0, maxLen);
-        const preRanges = findPreRanges(remaining);
-        // Prefer paragraph boundary (\n\n)
-        const lastPara = slice.lastIndexOf("\n\n");
-        // Then line boundary (\n)
-        const lastLine = slice.lastIndexOf("\n");
-        // Then word boundary (space)
-        const lastSpace = slice.lastIndexOf(" ");
-        let splitAt;
-        if (lastPara > 0 && !isInsidePre(lastPara, preRanges)) {
-            splitAt = lastPara + 2;
-        }
-        else if (lastLine > 0 && !isInsidePre(lastLine, preRanges)) {
-            splitAt = lastLine + 1;
-        }
-        else if (lastSpace > 0 && !isInsidePre(lastSpace, preRanges)) {
-            splitAt = lastSpace + 1;
-        }
-        else {
-            // If all candidate split points are inside a <pre> block, split after it
-            const coveringPre = preRanges.find(([start, end]) => start < maxLen && end > maxLen);
-            if (coveringPre) {
-                splitAt = coveringPre[1];
-            }
-            else {
-                splitAt = maxLen;
-            }
-        }
-        chunks.push(remaining.slice(0, splitAt).trimEnd());
-        remaining = remaining.slice(splitAt).trimStart();
-    }
-    if (remaining.length > 0) {
-        chunks.push(remaining);
-    }
-    return chunks;
-}

package/dist/index.d.ts

@@ -1,17 +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())
- */
-export {};

package/dist/index.js

@@ -1,169 +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();
-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);
-    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

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