@gonzih/cc-tg 0.9.11 → 0.9.12

package/dist/bot.d.ts

@@ -49,6 +49,7 @@ export declare class CcTgBot {
      */
     handleUserMessage(chatId: number, text: string): Promise<void>;
     private handleVoice;
+    private handleVoiceRetry;
     private handlePhoto;
     private handleDocument;
     private getOrCreateSession;

package/dist/bot.js

@@ -31,6 +31,7 @@ const BOT_COMMANDS = [
     { command: "cost", description: "Show session token usage and cost" },
     { command: "skills", description: "List available Claude skills with descriptions" },
     { command: "cron", description: "Manage cron jobs — add/list/edit/remove/clear" },
+    { command: "voice_retry", description: "Retry failed voice message transcriptions" },
 ];
 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
@@ -380,6 +381,11 @@ export class CcTgBot {
             await this.replyToChat(chatId, listSkills(), threadId);
             return;
         }
+        // /voice_retry — retry failed voice message transcriptions
+        if (text === "/voice_retry") {
+            await this.handleVoiceRetry(chatId, threadId);
+            return;
+        }
         const session = this.getOrCreateSession(chatId, threadId, threadName);
         try {
             const enriched = await enrichPromptWithUrls(text);
@@ -418,10 +424,24 @@ export class CcTgBot {
             return;
         console.log(`[voice:${chatId}] received voice message, transcribing...`);
         this.bot.sendChatAction(chatId, "typing", threadId !== undefined ? { message_thread_id: threadId } : undefined).catch(() => { });
+        // Store in Redis before transcription so we can retry on failure
+        const pendingEntry = JSON.stringify({
+            file_id: fileId,
+            chat_id: chatId,
+            message_id: msg.message_id,
+            timestamp: Date.now(),
+        });
+        if (this.redis) {
+            await this.redis.rpush("voice:pending", pendingEntry).catch((err) => console.warn("[voice] redis rpush voice:pending failed:", err.message));
+        }
         try {
             const fileLink = await this.bot.getFileLink(fileId);
             const transcript = await transcribeVoice(fileLink);
             console.log(`[voice:${chatId}] transcribed: ${transcript}`);
+            // Remove from pending on success
+            if (this.redis) {
+                await this.redis.lrem("voice:pending", 0, pendingEntry).catch((err) => console.warn("[voice] redis lrem voice:pending failed:", err.message));
+            }
             if (!transcript || transcript === "[empty transcription]") {
                 await this.replyToChat(chatId, "Could not transcribe voice message.", threadId);
                 return;
@@ -441,9 +461,97 @@ export class CcTgBot {
             }
         }
         catch (err) {
-            console.error(`[voice:${chatId}] error:`, err.message);
-            await this.replyToChat(chatId, `Voice transcription failed: ${err.message}`, threadId);
+            const errMsg = err.message;
+            console.error(`[voice:${chatId}] error:`, errMsg);
+            // Push to voice:failed on failure (entry stays in voice:pending for retry)
+            if (this.redis) {
+                const failedEntry = JSON.stringify({
+                    file_id: fileId,
+                    chat_id: chatId,
+                    message_id: msg.message_id,
+                    timestamp: Date.now(),
+                    error: errMsg,
+                    failed_at: Date.now(),
+                });
+                this.redis.rpush("voice:failed", failedEntry)
+                    .then(() => this.redis.expire("voice:failed", 48 * 60 * 60))
+                    .catch((redisErr) => console.warn("[voice] redis write voice:failed failed:", redisErr.message));
+            }
+            // User-friendly error messages
+            let userMsg;
+            if (errMsg.includes("whisper-cpp not found") || errMsg.includes("whisper not found")) {
+                userMsg = "Voice transcription unavailable — whisper-cpp not installed";
+            }
+            else if (errMsg.includes("No whisper model found")) {
+                userMsg = "Voice transcription unavailable — no whisper model found";
+            }
+            else if (errMsg.includes("HTTP") && errMsg.includes("downloading")) {
+                userMsg = "Could not download voice file from Telegram";
+            }
+            else {
+                userMsg = `Voice transcription failed: ${errMsg}`;
+            }
+            await this.replyToChat(chatId, userMsg, threadId);
+        }
+    }
+    async handleVoiceRetry(chatId, threadId) {
+        if (!this.redis) {
+            await this.replyToChat(chatId, "Redis not configured — voice retry unavailable.", threadId);
+            return;
+        }
+        const [pendingRaw, failedRaw] = await Promise.all([
+            this.redis.lrange("voice:pending", 0, -1).catch(() => []),
+            this.redis.lrange("voice:failed", 0, -1).catch(() => []),
+        ]);
+        // Deduplicate by file_id across both lists
+        const allEntries = new Map();
+        for (const raw of [...pendingRaw, ...failedRaw]) {
+            try {
+                const entry = JSON.parse(raw);
+                if (entry.file_id)
+                    allEntries.set(entry.file_id, entry);
+            }
+            catch { /* skip malformed entries */ }
+        }
+        if (allEntries.size === 0) {
+            await this.replyToChat(chatId, "No pending voice messages to retry.", threadId);
+            return;
+        }
+        await this.replyToChat(chatId, `Retrying ${allEntries.size} voice message(s)...`, threadId);
+        let succeeded = 0;
+        let failed = 0;
+        const errors = [];
+        for (const [fileId, entry] of allEntries) {
+            try {
+                const fileLink = await this.bot.getFileLink(fileId);
+                const transcript = await transcribeVoice(fileLink);
+                if (transcript && transcript !== "[empty transcription]") {
+                    const session = this.getOrCreateSession(entry.chat_id, threadId, undefined);
+                    session.claude.sendPrompt(transcript);
+                    this.writeChatMessage("user", "telegram", transcript, entry.chat_id);
+                    // Remove from both lists
+                    const matchPending = pendingRaw.find((r) => r.includes(`"${fileId}"`));
+                    const matchFailed = failedRaw.find((r) => r.includes(`"${fileId}"`));
+                    if (matchPending)
+                        await this.redis.lrem("voice:pending", 0, matchPending).catch(() => { });
+                    if (matchFailed)
+                        await this.redis.lrem("voice:failed", 0, matchFailed).catch(() => { });
+                    succeeded++;
+                }
+                else {
+                    failed++;
+                    errors.push(`${fileId}: empty transcription`);
+                }
+            }
+            catch (err) {
+                failed++;
+                errors.push(`${fileId}: ${err.message}`);
+            }
         }
+        const lines = [`Voice retry complete: ${succeeded} succeeded, ${failed} failed.`];
+        if (errors.length > 0)
+            lines.push(...errors.map((e) => `• ${e}`));
+        await this.replyToChat(chatId, lines.join("\n"), threadId);
     }
     async handlePhoto(chatId, msg, threadId, threadName) {
         // Pick highest resolution photo

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonzih/cc-tg",
-  "version": "0.9.11",
+  "version": "0.9.12",
   "description": "Claude Code Telegram bot — chat with Claude Code via Telegram",
   "type": "module",
   "bin": {