@gonzih/cc-tg 0.1.9 → 0.2.2

package/README.md

@@ -1,6 +1,6 @@
 # cc-tg
 
-Claude Code Telegram bot. Chat with Claude Code from Telegram.
+Claude Code Telegram bot. Chat with Claude Code from Telegram — voice messages, scheduled prompts, and automatic file delivery.
 
 ## Quickstart
 
@@ -19,12 +19,12 @@ That's it. Open your bot in Telegram and start chatting.
 | 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 |
+| `CLAUDE_CODE_TOKEN` | yes* | Claude Code OAuth token (starts with `sk-ant-oat`) |
+| `ANTHROPIC_API_KEY` | yes* | Alternative — API key from console.anthropic.com |
 | `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.
+*One of `CLAUDE_CODE_TOKEN` or `ANTHROPIC_API_KEY` is required.
 
 ## How to get your Claude Code token
 
@@ -36,27 +36,107 @@ npx @anthropic-ai/claude-code setup-token
 
 It opens a browser, logs you in with your Anthropic account, and prints a token starting with `sk-ant-oat`. Paste that as `CLAUDE_CODE_TOKEN`.
 
-Alternatively, use an `ANTHROPIC_API_KEY` from [console.anthropic.com](https://console.anthropic.com) (API key starts with `sk-ant-api`).
-
 ## How to get your Telegram user ID
 
-Message [@userinfobot](https://t.me/userinfobot) on Telegram — it replies with your ID.
+Message [@userinfobot](https://t.me/userinfobot) on Telegram — it replies with your numeric ID.
 
 ## Bot commands
 
 | Command | Action |
 |---|---|
-| `/start` | Reset session |
-| `/reset` | Reset session |
-| `/stop` | Interrupt current Claude task |
-| `/status` | Check if session is active |
+| `/start` or `/reset` | Kill current Claude session and start fresh |
+| `/stop` | Interrupt the running Claude task |
+| `/status` | Check if a session is active |
+| `/cron every 1h <prompt>` | Schedule a recurring prompt |
+| `/cron list` | Show active cron jobs |
+| `/cron remove <id>` | Remove a specific cron job |
+| `/cron clear` | Remove all cron jobs |
 | Any text | Sent directly to Claude Code |
+| Voice message | Transcribed via whisper.cpp and sent to Claude |
+
+## Features
+
+### Persistent sessions
+Each Telegram chat ID gets its own isolated Claude Code subprocess. Sessions survive between messages — Claude remembers context within a conversation. `/reset` starts a fresh session.
+
+### Voice messages
+Send a voice message → automatically transcribed via whisper.cpp → fed into Claude as text. Requires `whisper-cpp` and `ffmpeg` installed on the host.
+
+### File delivery
+When Claude writes a file and mentions it in the response, the bot automatically uploads it to Telegram. Hybrid detection: tracks `Write`/`Edit` tool calls during the session, cross-references with filenames mentioned in the final response.
+
+### Cron jobs
+Schedule recurring prompts that fire into your Claude session on a timer:
+
+```
+/cron every 1h check whale-watcher logs and summarize any new large trades
+/cron every 6h run the market scan and save results to daily-report.md
+/cron every 30m ping the API and alert me if anything looks off
+```
+
+Cron jobs persist to `<CWD>/.cc-tg/crons.json` and are restored on bot restart. Output is prefixed with `CRON: <prompt>` so you know what triggered it. Files written by cron jobs are uploaded the same way as regular responses.
+
+### Typing indicator
+While Claude is working, the bot sends a continuous typing indicator so you know it's active.
+
+### Permissions
+Runs Claude Code with `--dangerously-skip-permissions` — no confirmation prompts blocking headless execution.
 
 ## 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.
+Spawns a `claude` CLI subprocess per chat session using the stream-JSON protocol (same mechanism as the [ce_ce](https://github.com/ityonemo/ce_ce) Elixir library). Prompts pipe in via stdin, streaming JSON responses parse out. Only the final `result` message is forwarded to Telegram — no duplicate streaming chunks.
+
+## Run persistently
+
+### macOS launchd
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.yourname.cc-tg</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>/opt/homebrew/bin/npx</string>
+        <string>-y</string>
+        <string>@gonzih/cc-tg</string>
+    </array>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>TELEGRAM_BOT_TOKEN</key>
+        <string>your_token</string>
+        <key>CLAUDE_CODE_TOKEN</key>
+        <string>your_claude_token</string>
+        <key>ALLOWED_USER_IDS</key>
+        <string>your_telegram_id</string>
+        <key>CWD</key>
+        <string>/Users/you/your-project</string>
+        <key>PATH</key>
+        <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+    </dict>
+    <key>WorkingDirectory</key>
+    <string>/Users/you/your-project</string>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>/tmp/cc-tg.log</string>
+    <key>StandardErrorPath</key>
+    <string>/tmp/cc-tg.log</string>
+</dict>
+</plist>
+```
+
+Save to `~/Library/LaunchAgents/com.yourname.cc-tg.plist`, then:
+
+```bash
+launchctl load ~/Library/LaunchAgents/com.yourname.cc-tg.plist
+```
 
-## Run persistently (systemd)
+### Linux systemd
 
 ```ini
 [Unit]
@@ -66,7 +146,9 @@ Description=cc-tg Claude Code Telegram bot
 Environment=TELEGRAM_BOT_TOKEN=xxx
 Environment=CLAUDE_CODE_TOKEN=yyy
 Environment=ALLOWED_USER_IDS=123456789
-ExecStart=npx @gonzih/cc-tg
+Environment=CWD=/home/you/your-project
+WorkingDirectory=/home/you/your-project
+ExecStart=npx -y @gonzih/cc-tg
 Restart=always
 
 [Install]
@@ -76,4 +158,5 @@ WantedBy=multi-user.target
 ## Requirements
 
 - Node.js 18+
-- `claude` CLI installed and in PATH (`npm install -g @anthropic-ai/claude-code`)
+- `claude` CLI: `npm install -g @anthropic-ai/claude-code`
+- Voice transcription (optional): `whisper-cpp` + `ffmpeg`

package/dist/bot.d.ts

@@ -12,15 +12,20 @@ export declare class CcTgBot {
     private bot;
     private sessions;
     private opts;
+    private cron;
     constructor(opts: BotOptions);
     private isAllowed;
     private handleTelegram;
+    private handleVoice;
     private getOrCreateSession;
     private handleClaudeMessage;
     private startTyping;
     private stopTyping;
     private flushPending;
+    private trackWrittenFiles;
+    private uploadMentionedFiles;
     private extractToolName;
+    private handleCron;
     private killSession;
     stop(): void;
 }

package/dist/bot.js

@@ -3,19 +3,38 @@
  * One ClaudeProcess per chat_id — sessions are isolated per user.
  */
 import TelegramBot from "node-telegram-bot-api";
+import { existsSync } from "fs";
+import { resolve, basename } from "path";
 import { ClaudeProcess, extractText } from "./claude.js";
+import { transcribeVoice, isVoiceAvailable } from "./voice.js";
+import { CronManager } from "./cron.js";
 const FLUSH_DELAY_MS = 800; // debounce streaming chunks into one Telegram message
 const TYPING_INTERVAL_MS = 4000; // re-send typing action before Telegram's 5s expiry
 export class CcTgBot {
     bot;
     sessions = new Map();
     opts;
+    cron;
     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));
+        // Cron manager — fires prompts into user sessions on schedule
+        this.cron = new CronManager(opts.cwd ?? process.cwd(), (chatId, prompt) => {
+            const session = this.getOrCreateSession(chatId);
+            try {
+                session.claude.sendPrompt(`[CRON: ${prompt}]\n\n${prompt}`);
+                this.startTyping(chatId, session);
+                // Tag result with cron prefix
+                session.pendingPrefix = `CRON: ${prompt}\n\n`;
+            }
+            catch (err) {
+                console.error(`[cron] failed to fire for chat=${chatId}:`, err.message);
+            }
+        });
         console.log("cc-tg bot started");
+        console.log(`[voice] whisper available: ${isVoiceAvailable()}`);
     }
     isAllowed(userId) {
         if (!this.opts.allowedUserIds?.length)
@@ -25,13 +44,18 @@ export class CcTgBot {
     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;
         }
+        // Voice message — transcribe then feed as text
+        if (msg.voice || msg.audio) {
+            await this.handleVoice(chatId, msg);
+            return;
+        }
+        const text = msg.text?.trim();
+        if (!text)
+            return;
         // /start or /reset — kill existing session and ack
         if (text === "/start" || text === "/reset") {
             this.killSession(chatId);
@@ -51,6 +75,11 @@ export class CcTgBot {
             await this.bot.sendMessage(chatId, has ? "Session active." : "No active session.");
             return;
         }
+        // /cron <schedule> <prompt> | /cron list | /cron clear | /cron remove <id>
+        if (text.startsWith("/cron")) {
+            await this.handleCron(chatId, text);
+            return;
+        }
         const session = this.getOrCreateSession(chatId);
         try {
             session.claude.sendPrompt(text);
@@ -61,6 +90,36 @@ export class CcTgBot {
             this.killSession(chatId);
         }
     }
+    async handleVoice(chatId, msg) {
+        const fileId = msg.voice?.file_id ?? msg.audio?.file_id;
+        if (!fileId)
+            return;
+        console.log(`[voice:${chatId}] received voice message, transcribing...`);
+        this.bot.sendChatAction(chatId, "typing").catch(() => { });
+        try {
+            const fileLink = await this.bot.getFileLink(fileId);
+            const transcript = await transcribeVoice(fileLink);
+            console.log(`[voice:${chatId}] transcribed: ${transcript}`);
+            if (!transcript || transcript === "[empty transcription]") {
+                await this.bot.sendMessage(chatId, "Could not transcribe voice message.");
+                return;
+            }
+            // Feed transcript into Claude as if user typed it
+            const session = this.getOrCreateSession(chatId);
+            try {
+                session.claude.sendPrompt(transcript);
+                this.startTyping(chatId, session);
+            }
+            catch (err) {
+                await this.bot.sendMessage(chatId, `Error sending to Claude: ${err.message}`);
+                this.killSession(chatId);
+            }
+        }
+        catch (err) {
+            console.error(`[voice:${chatId}] error:`, err.message);
+            await this.bot.sendMessage(chatId, `Voice transcription failed: ${err.message}`);
+        }
+    }
     getOrCreateSession(chatId) {
         const existing = this.sessions.get(chatId);
         if (existing && !existing.claude.exited)
@@ -72,8 +131,10 @@ export class CcTgBot {
         const session = {
             claude,
             pendingText: "",
+            pendingPrefix: "",
             flushTimer: null,
             typingTimer: null,
+            writtenFiles: new Set(),
         };
         claude.on("message", (msg) => {
             // Verbose logging — log every message type and subtype
@@ -85,6 +146,8 @@ export class CcTgBot {
             if (toolName)
                 logParts.push(`tool=${toolName}`);
             console.log(logParts.join(" "));
+            // Track files written by Write/Edit tool calls
+            this.trackWrittenFiles(msg, session, this.opts.cwd);
             this.handleClaudeMessage(chatId, session, msg);
         });
         claude.on("stderr", (data) => {
@@ -136,11 +199,14 @@ export class CcTgBot {
         }
     }
     flushPending(chatId, session) {
-        const text = session.pendingText.trim();
+        const raw = session.pendingText.trim();
+        const prefix = session.pendingPrefix;
         session.pendingText = "";
+        session.pendingPrefix = "";
         session.flushTimer = null;
-        if (!text)
+        if (!raw)
             return;
+        const text = prefix ? `${prefix}${raw}` : raw;
         // Telegram max message length is 4096 chars — split if needed
         const chunks = splitMessage(text);
         for (const chunk of chunks) {
@@ -149,6 +215,78 @@ export class CcTgBot {
                 this.bot.sendMessage(chatId, chunk).catch((err) => console.error(`[tg:${chatId}] send failed:`, err.message));
             });
         }
+        // Hybrid file upload: find files mentioned in result text that Claude actually wrote
+        this.uploadMentionedFiles(chatId, text, session);
+    }
+    trackWrittenFiles(msg, session, cwd) {
+        // Only look at assistant messages with tool_use blocks
+        if (msg.type !== "assistant")
+            return;
+        const message = msg.payload.message;
+        if (!message)
+            return;
+        const content = message.content;
+        if (!Array.isArray(content))
+            return;
+        for (const block of content) {
+            if (block.type !== "tool_use")
+                continue;
+            const name = block.name;
+            if (!["Write", "Edit", "NotebookEdit"].includes(name))
+                continue;
+            const input = block.input;
+            if (!input)
+                continue;
+            // Write tool uses file_path, Edit uses file_path
+            const filePath = input.file_path ?? input.path;
+            if (!filePath)
+                continue;
+            // Resolve relative paths against cwd
+            const resolved = filePath.startsWith("/")
+                ? filePath
+                : resolve(cwd ?? process.cwd(), filePath);
+            console.log(`[claude:files] tracked written file: ${resolved}`);
+            session.writtenFiles.add(resolved);
+        }
+    }
+    uploadMentionedFiles(chatId, resultText, session) {
+        if (session.writtenFiles.size === 0)
+            return;
+        // Extract file path candidates from result text
+        // Match: /absolute/path/file.ext or relative like ./foo/bar.csv or just foo.pdf
+        const pathPattern = /(?:^|[\s`'"(])(\/?[\w.\-/]+\.[\w]{1,10})(?:[\s`'")\n]|$)/gm;
+        const candidates = new Set();
+        let match;
+        while ((match = pathPattern.exec(resultText)) !== null) {
+            candidates.add(match[1]);
+        }
+        const toUpload = [];
+        for (const candidate of candidates) {
+            // Try as-is (absolute), or resolve against cwd
+            const resolved = candidate.startsWith("/")
+                ? candidate
+                : resolve(this.opts.cwd ?? process.cwd(), candidate);
+            if (session.writtenFiles.has(resolved) && existsSync(resolved)) {
+                toUpload.push(resolved);
+            }
+            else {
+                // Also check by basename — result might mention just the filename
+                for (const written of session.writtenFiles) {
+                    if (basename(written) === basename(candidate) && existsSync(written)) {
+                        toUpload.push(written);
+                        break;
+                    }
+                }
+            }
+        }
+        // Deduplicate
+        const unique = [...new Set(toUpload)];
+        for (const filePath of unique) {
+            console.log(`[claude:files] uploading to telegram: ${filePath}`);
+            this.bot.sendDocument(chatId, filePath).catch((err) => console.error(`[tg:${chatId}] sendDocument failed for ${filePath}:`, err.message));
+        }
+        // Clear written files for next turn
+        session.writtenFiles.clear();
     }
     extractToolName(msg) {
         const message = msg.payload.message;
@@ -160,13 +298,56 @@ export class CcTgBot {
         const toolUse = content.find((b) => b.type === "tool_use");
         return toolUse?.name ?? "";
     }
-    killSession(chatId) {
+    async handleCron(chatId, text) {
+        const args = text.slice("/cron".length).trim();
+        // /cron list
+        if (args === "list" || args === "") {
+            const jobs = this.cron.list(chatId);
+            if (!jobs.length) {
+                await this.bot.sendMessage(chatId, "No cron jobs.");
+                return;
+            }
+            const lines = jobs.map((j) => `[${j.id}] ${j.schedule}: ${j.prompt}`);
+            await this.bot.sendMessage(chatId, lines.join("\n"));
+            return;
+        }
+        // /cron clear
+        if (args === "clear") {
+            const n = this.cron.clearAll(chatId);
+            await this.bot.sendMessage(chatId, `Cleared ${n} cron job(s).`);
+            return;
+        }
+        // /cron remove <id>
+        if (args.startsWith("remove ")) {
+            const id = args.slice("remove ".length).trim();
+            const ok = this.cron.remove(chatId, id);
+            await this.bot.sendMessage(chatId, ok ? `Removed ${id}.` : `Not found: ${id}`);
+            return;
+        }
+        // /cron every 1h <prompt>
+        const scheduleMatch = args.match(/^(every\s+\d+[mhd])\s+(.+)$/i);
+        if (!scheduleMatch) {
+            await this.bot.sendMessage(chatId, "Usage:\n/cron every 1h <prompt>\n/cron list\n/cron remove <id>\n/cron clear");
+            return;
+        }
+        const schedule = scheduleMatch[1];
+        const prompt = scheduleMatch[2];
+        const job = this.cron.add(chatId, schedule, prompt);
+        if (!job) {
+            await this.bot.sendMessage(chatId, "Invalid schedule. Use: every 30m / every 2h / every 1d");
+            return;
+        }
+        await this.bot.sendMessage(chatId, `Cron set [${job.id}]: ${schedule} — "${prompt}"`);
+    }
+    killSession(chatId, keepCrons = true) {
         const session = this.sessions.get(chatId);
         if (session) {
             this.stopTyping(session);
             session.claude.kill();
             this.sessions.delete(chatId);
         }
+        if (!keepCrons)
+            this.cron.clearAll(chatId);
     }
     stop() {
         this.bot.stopPolling();

package/dist/cron.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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[];
+    private persist;
+    private load;
+}
+export {};

package/dist/cron.js

@@ -0,0 +1,103 @@
+/**
+ * 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);
+    }
+    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/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.1.9",
+  "version": "0.2.2",
   "description": "Claude Code Telegram bot — chat with Claude Code via Telegram",
   "type": "module",
   "bin": {