@gonzih/cc-tg 0.1.8 → 0.2.1

package/dist/bot.d.ts

@@ -15,11 +15,14 @@ export declare class CcTgBot {
     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 killSession;
     stop(): void;

package/dist/bot.js

@@ -3,7 +3,10 @@
  * 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";
 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 {
@@ -16,6 +19,7 @@ export class CcTgBot {
         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");
+        console.log(`[voice] whisper available: ${isVoiceAvailable()}`);
     }
     isAllowed(userId) {
         if (!this.opts.allowedUserIds?.length)
@@ -25,13 +29,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);
@@ -61,6 +70,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)
@@ -74,6 +113,7 @@ export class CcTgBot {
             pendingText: "",
             flushTimer: null,
             typingTimer: null,
+            writtenFiles: new Set(),
         };
         claude.on("message", (msg) => {
             // Verbose logging — log every message type and subtype
@@ -85,6 +125,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) => {
@@ -149,6 +191,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;

package/dist/claude.js

@@ -5,6 +5,7 @@
  */
 import { spawn } from "child_process";
 import { EventEmitter } from "events";
+import { existsSync } from "fs";
 export class ClaudeProcess extends EventEmitter {
     proc;
     buffer = "";
@@ -37,7 +38,9 @@ export class ClaudeProcess extends EventEmitter {
                 delete env.ANTHROPIC_API_KEY;
             }
         }
-        this.proc = spawn("claude", args, {
+        // 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"],
@@ -127,3 +130,29 @@ export function extractText(msg) {
     }
     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/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.8",
+  "version": "0.2.1",
   "description": "Claude Code Telegram bot — chat with Claude Code via Telegram",
   "type": "module",
   "bin": {