@gonzih/cc-tg 0.1.0

package/README.md

@@ -0,0 +1,66 @@
+# cc-tg
+
+Claude Code Telegram bot. Chat with Claude Code from Telegram.
+
+## Quickstart
+
+**Step 1** — create a Telegram bot via [@BotFather](https://t.me/BotFather), get your token.
+
+**Step 2** — run:
+
+```bash
+TELEGRAM_BOT_TOKEN=your_bot_token CLAUDE_CODE_TOKEN=your_claude_token npx @gonzih/cc-tg
+```
+
+That's it. Open your bot in Telegram and start chatting.
+
+## Environment variables
+
+| Variable | Required | Description |
+|---|---|---|
+| `TELEGRAM_BOT_TOKEN` | yes | From @BotFather |
+| `CLAUDE_CODE_TOKEN` | yes* | Claude Code OAuth token |
+| `ANTHROPIC_API_KEY` | yes* | Alternative to CLAUDE_CODE_TOKEN |
+| `ALLOWED_USER_IDS` | no | Comma-separated Telegram user IDs. Leave empty to allow anyone |
+| `CWD` | no | Working directory for Claude Code. Defaults to current directory |
+
+*One of CLAUDE_CODE_TOKEN or ANTHROPIC_API_KEY is required.
+
+## How to get your Telegram user ID
+
+Message [@userinfobot](https://t.me/userinfobot) on Telegram — it replies with your ID.
+
+## Bot commands
+
+| Command | Action |
+|---|---|
+| `/start` | Reset session |
+| `/reset` | Reset session |
+| `/status` | Check if session is active |
+| Any text | Sent directly to Claude Code |
+
+## How it works
+
+Spawns a `claude` CLI subprocess per chat session using the same stream-JSON protocol as the [ce_ce](https://github.com/ityonemo/ce_ce) Elixir library. Each Telegram chat gets its own isolated Claude Code session. Messages stream back in real time, debounced into Telegram messages.
+
+## Run persistently (systemd)
+
+```ini
+[Unit]
+Description=cc-tg Claude Code Telegram bot
+
+[Service]
+Environment=TELEGRAM_BOT_TOKEN=xxx
+Environment=CLAUDE_CODE_TOKEN=yyy
+Environment=ALLOWED_USER_IDS=123456789
+ExecStart=npx @gonzih/cc-tg
+Restart=always
+
+[Install]
+WantedBy=multi-user.target
+```
+
+## Requirements
+
+- Node.js 18+
+- `claude` CLI installed and in PATH (`npm install -g @anthropic-ai/claude-code`)

package/dist/bot.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Telegram bot that routes messages to/from a Claude Code subprocess.
+ * One ClaudeProcess per chat_id — sessions are isolated per user.
+ */
+export interface BotOptions {
+    telegramToken: string;
+    claudeToken?: string;
+    cwd?: string;
+    allowedUserIds?: number[];
+}
+export declare class CcTgBot {
+    private bot;
+    private sessions;
+    private opts;
+    constructor(opts: BotOptions);
+    private isAllowed;
+    private handleTelegram;
+    private getOrCreateSession;
+    private handleClaudeMessage;
+    private flushPending;
+    private killSession;
+    stop(): void;
+}

package/dist/bot.js

@@ -0,0 +1,138 @@
+/**
+ * Telegram bot that routes messages to/from a Claude Code subprocess.
+ * One ClaudeProcess per chat_id — sessions are isolated per user.
+ */
+import TelegramBot from "node-telegram-bot-api";
+import { ClaudeProcess, extractText } from "./claude.js";
+const FLUSH_DELAY_MS = 800; // debounce streaming chunks into one Telegram message
+export class CcTgBot {
+    bot;
+    sessions = new Map();
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+        this.bot = new TelegramBot(opts.telegramToken, { polling: true });
+        this.bot.on("message", (msg) => this.handleTelegram(msg));
+        this.bot.on("polling_error", (err) => console.error("[tg]", err.message));
+        console.log("cc-tg bot started");
+    }
+    isAllowed(userId) {
+        if (!this.opts.allowedUserIds?.length)
+            return true;
+        return this.opts.allowedUserIds.includes(userId);
+    }
+    async handleTelegram(msg) {
+        const chatId = msg.chat.id;
+        const userId = msg.from?.id ?? chatId;
+        const text = msg.text?.trim();
+        if (!text)
+            return;
+        if (!this.isAllowed(userId)) {
+            await this.bot.sendMessage(chatId, "Not authorized.");
+            return;
+        }
+        // /start or /reset — kill existing session and ack
+        if (text === "/start" || text === "/reset") {
+            this.killSession(chatId);
+            await this.bot.sendMessage(chatId, "Session reset. Send a message to start.");
+            return;
+        }
+        // /status
+        if (text === "/status") {
+            const has = this.sessions.has(chatId);
+            await this.bot.sendMessage(chatId, has ? "Session active." : "No active session.");
+            return;
+        }
+        const session = this.getOrCreateSession(chatId);
+        try {
+            session.claude.sendPrompt(text);
+        }
+        catch (err) {
+            await this.bot.sendMessage(chatId, `Error sending to Claude: ${err.message}`);
+            this.killSession(chatId);
+        }
+    }
+    getOrCreateSession(chatId) {
+        const existing = this.sessions.get(chatId);
+        if (existing && !existing.claude.exited)
+            return existing;
+        const claude = new ClaudeProcess({
+            cwd: this.opts.cwd,
+            token: this.opts.claudeToken,
+        });
+        const session = {
+            claude,
+            pendingText: "",
+            flushTimer: null,
+        };
+        claude.on("message", (msg) => this.handleClaudeMessage(chatId, session, msg));
+        claude.on("stderr", (data) => {
+            // Only surface non-noise stderr
+            if (data.includes("Error") || data.includes("error")) {
+                console.error(`[claude:${chatId}]`, data.trim());
+            }
+        });
+        claude.on("exit", (code) => {
+            console.log(`[claude:${chatId}] exited with code ${code}`);
+            this.sessions.delete(chatId);
+        });
+        claude.on("error", (err) => {
+            console.error(`[claude:${chatId}] process error:`, err.message);
+            this.bot.sendMessage(chatId, `Claude process error: ${err.message}`).catch(() => { });
+            this.sessions.delete(chatId);
+        });
+        this.sessions.set(chatId, session);
+        return session;
+    }
+    handleClaudeMessage(chatId, session, msg) {
+        if (msg.type !== "assistant" && msg.type !== "result")
+            return;
+        const text = extractText(msg);
+        if (!text)
+            return;
+        // Accumulate text and debounce — Claude streams chunks rapidly
+        session.pendingText += text;
+        if (session.flushTimer)
+            clearTimeout(session.flushTimer);
+        session.flushTimer = setTimeout(() => this.flushPending(chatId, session), FLUSH_DELAY_MS);
+    }
+    flushPending(chatId, session) {
+        const text = session.pendingText.trim();
+        session.pendingText = "";
+        session.flushTimer = null;
+        if (!text)
+            return;
+        // Telegram max message length is 4096 chars — split if needed
+        const chunks = splitMessage(text);
+        for (const chunk of chunks) {
+            this.bot.sendMessage(chatId, chunk, { parse_mode: "Markdown" }).catch(() => {
+                // Markdown parse failed — retry as plain text
+                this.bot.sendMessage(chatId, chunk).catch((err) => console.error(`[tg:${chatId}] send failed:`, err.message));
+            });
+        }
+    }
+    killSession(chatId) {
+        const session = this.sessions.get(chatId);
+        if (session) {
+            session.claude.kill();
+            this.sessions.delete(chatId);
+        }
+    }
+    stop() {
+        this.bot.stopPolling();
+        for (const [chatId] of this.sessions) {
+            this.killSession(chatId);
+        }
+    }
+}
+function splitMessage(text, maxLen = 4096) {
+    if (text.length <= maxLen)
+        return [text];
+    const chunks = [];
+    let i = 0;
+    while (i < text.length) {
+        chunks.push(text.slice(i, i + maxLen));
+        i += maxLen;
+    }
+    return chunks;
+}

package/dist/claude.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 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;
+    /** CLAUDE_CODE_OAUTH_TOKEN or ANTHROPIC_API_KEY value */
+    token?: string;
+}
+export declare interface ClaudeProcess {
+    on(event: "message", listener: (msg: ClaudeMessage) => 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;
+    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

@@ -0,0 +1,118 @@
+/**
+ * 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";
+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",
+        ];
+        if (opts.systemPrompt) {
+            args.push("--system-prompt", opts.systemPrompt);
+        }
+        const env = { ...process.env };
+        if (opts.token) {
+            // Try as OAuth token first; Claude Code accepts both env vars
+            env.CLAUDE_CODE_OAUTH_TOKEN = opts.token;
+        }
+        this.proc = spawn("claude", 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");
+    }
+    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;
+            try {
+                const raw = JSON.parse(line);
+                const msg = this.parseMessage(raw);
+                if (msg)
+                    this.emit("message", msg);
+            }
+            catch {
+                // Non-JSON line (startup noise etc.) — ignore
+            }
+        }
+    }
+    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 "";
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+#!/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)
+ *   CWD                  — working directory for Claude Code (default: process.cwd())
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,67 @@
+#!/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)
+ *   CWD                  — working directory for Claude Code (default: process.cwd())
+ */
+import { CcTgBot } from "./bot.js";
+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 either CLAUDE_CODE_TOKEN or ANTHROPIC_API_KEY
+const claudeToken = process.env.CLAUDE_CODE_TOKEN ??
+    process.env.ANTHROPIC_API_KEY;
+if (!claudeToken) {
+    console.error(`
+ERROR: Neither CLAUDE_CODE_TOKEN nor ANTHROPIC_API_KEY is set.
+
+Set one and run again:
+  TELEGRAM_BOT_TOKEN=xxx CLAUDE_CODE_TOKEN=yyy npx @gonzih/cc-tg
+`);
+    process.exit(1);
+}
+const allowedUserIds = process.env.ALLOWED_USER_IDS
+    ? process.env.ALLOWED_USER_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,
+});
+process.on("SIGINT", () => {
+    console.log("\nShutting down...");
+    bot.stop();
+    process.exit(0);
+});
+process.on("SIGTERM", () => {
+    bot.stop();
+    process.exit(0);
+});

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@gonzih/cc-tg",
+  "version": "0.1.0",
+  "description": "Claude Code Telegram bot — chat with Claude Code via Telegram",
+  "type": "module",
+  "bin": {
+    "cc-tg": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "node --loader ts-node/esm src/index.ts"
+  },
+  "files": [
+    "dist/"
+  ],
+  "dependencies": {
+    "node-telegram-bot-api": "^0.66.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/node-telegram-bot-api": "^0.64.0",
+    "typescript": "^5.5.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Gonzih/cc-tg.git"
+  },
+  "homepage": "https://github.com/Gonzih/cc-tg",
+  "bugs": {
+    "url": "https://github.com/Gonzih/cc-tg/issues"
+  },
+  "keywords": ["claude", "claude-code", "telegram", "bot", "ai"],
+  "license": "MIT"
+}