@gonzih/cc-tg 0.2.21 → 0.3.0

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

@@ -1,33 +0,0 @@
-/**
- * Cron job manager for cc-tg.
- * Persists jobs to <cwd>/.cc-tg/crons.json.
- * Fires prompts into Claude sessions on schedule.
- */
-export interface CronJob {
-    id: string;
-    chatId: number;
-    intervalMs: number;
-    prompt: string;
-    createdAt: string;
-    schedule: string;
-}
-type FireCallback = (chatId: number, prompt: string) => void;
-export declare class CronManager {
-    private jobs;
-    private storePath;
-    private fire;
-    constructor(cwd: string, fire: FireCallback);
-    /** Parse "every 30m", "every 2h", "every 1d" → ms */
-    static parseSchedule(schedule: string): number | null;
-    add(chatId: number, schedule: string, prompt: string): CronJob | null;
-    remove(chatId: number, id: string): boolean;
-    clearAll(chatId: number): number;
-    list(chatId: number): CronJob[];
-    update(chatId: number, id: string, updates: {
-        schedule?: string;
-        prompt?: string;
-    }): CronJob | null | false;
-    private persist;
-    private load;
-}
-export {};

package/dist/cron.js

@@ -1,127 +0,0 @@
-/**
- * Cron job manager for cc-tg.
- * Persists jobs to <cwd>/.cc-tg/crons.json.
- * Fires prompts into Claude sessions on schedule.
- */
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
-import { join } from "path";
-export class CronManager {
-    jobs = new Map();
-    storePath;
-    fire;
-    constructor(cwd, fire) {
-        this.storePath = join(cwd, ".cc-tg", "crons.json");
-        this.fire = fire;
-        this.load();
-    }
-    /** Parse "every 30m", "every 2h", "every 1d" → ms */
-    static parseSchedule(schedule) {
-        const m = schedule.trim().match(/^every\s+(\d+)(m|h|d)$/i);
-        if (!m)
-            return null;
-        const n = parseInt(m[1]);
-        const unit = m[2].toLowerCase();
-        if (unit === "m")
-            return n * 60_000;
-        if (unit === "h")
-            return n * 3_600_000;
-        if (unit === "d")
-            return n * 86_400_000;
-        return null;
-    }
-    add(chatId, schedule, prompt) {
-        const intervalMs = CronManager.parseSchedule(schedule);
-        if (!intervalMs)
-            return null;
-        const id = `${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
-        const job = { id, chatId, intervalMs, prompt, schedule, createdAt: new Date().toISOString() };
-        const timer = setInterval(() => {
-            console.log(`[cron:${id}] firing for chat=${chatId} prompt="${prompt}"`);
-            this.fire(chatId, prompt);
-        }, intervalMs);
-        this.jobs.set(id, { ...job, timer });
-        this.persist();
-        return job;
-    }
-    remove(chatId, id) {
-        const job = this.jobs.get(id);
-        if (!job || job.chatId !== chatId)
-            return false;
-        clearInterval(job.timer);
-        this.jobs.delete(id);
-        this.persist();
-        return true;
-    }
-    clearAll(chatId) {
-        let count = 0;
-        for (const [id, job] of this.jobs) {
-            if (job.chatId === chatId) {
-                clearInterval(job.timer);
-                this.jobs.delete(id);
-                count++;
-            }
-        }
-        if (count)
-            this.persist();
-        return count;
-    }
-    list(chatId) {
-        return [...this.jobs.values()]
-            .filter((j) => j.chatId === chatId)
-            .map(({ timer: _t, ...j }) => j);
-    }
-    update(chatId, id, updates) {
-        const job = this.jobs.get(id);
-        if (!job || job.chatId !== chatId)
-            return false;
-        if (updates.schedule !== undefined) {
-            const intervalMs = CronManager.parseSchedule(updates.schedule);
-            if (!intervalMs)
-                return null;
-            job.intervalMs = intervalMs;
-            job.schedule = updates.schedule;
-        }
-        if (updates.prompt !== undefined) {
-            job.prompt = updates.prompt;
-        }
-        // Recreate timer so it uses updated intervalMs and always reads latest job.prompt
-        clearInterval(job.timer);
-        job.timer = setInterval(() => {
-            console.log(`[cron:${job.id}] firing for chat=${job.chatId} prompt="${job.prompt}"`);
-            this.fire(job.chatId, job.prompt);
-        }, job.intervalMs);
-        this.persist();
-        const { timer: _t, ...cronJob } = job;
-        return cronJob;
-    }
-    persist() {
-        try {
-            const dir = join(this.storePath, "..");
-            if (!existsSync(dir))
-                mkdirSync(dir, { recursive: true });
-            const data = [...this.jobs.values()].map(({ timer: _t, ...j }) => j);
-            writeFileSync(this.storePath, JSON.stringify(data, null, 2));
-        }
-        catch (err) {
-            console.error("[cron] persist error:", err.message);
-        }
-    }
-    load() {
-        if (!existsSync(this.storePath))
-            return;
-        try {
-            const data = JSON.parse(readFileSync(this.storePath, "utf8"));
-            for (const job of data) {
-                const timer = setInterval(() => {
-                    console.log(`[cron:${job.id}] firing for chat=${job.chatId} prompt="${job.prompt}"`);
-                    this.fire(job.chatId, job.prompt);
-                }, job.intervalMs);
-                this.jobs.set(job.id, { ...job, timer });
-            }
-            console.log(`[cron] loaded ${data.length} jobs from disk`);
-        }
-        catch (err) {
-            console.error("[cron] load error:", err.message);
-        }
-    }
-}

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,94 +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)
- *   CWD                  — working directory for Claude Code (default: process.cwd())
- */
-import { existsSync, writeFileSync, unlinkSync, readFileSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-import { CcTgBot } from "./bot.js";
-const LOCK_FILE = join(tmpdir(), "cc-tg.lock");
-function acquireLock() {
-    if (existsSync(LOCK_FILE)) {
-        try {
-            const pid = parseInt(readFileSync(LOCK_FILE, "utf8").trim());
-            process.kill(pid, 0);
-            console.error(`[cc-tg] Another instance is already running (PID ${pid}). Exiting.`);
-            return false;
-        }
-        catch {
-            // PID is dead — stale lock, take over
-        }
-    }
-    writeFileSync(LOCK_FILE, String(process.pid));
-    process.on("exit", () => { try {
-        unlinkSync(LOCK_FILE);
-    }
-    catch { } });
-    return true;
-}
-if (!acquireLock()) {
-    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);
-}
-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/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;

package/dist/voice.js

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