@inetafrica/open-claudia 2.6.43 → 2.6.45

package/bot-agent.js

@@ -767,25 +767,9 @@ function transcribeAudio(oggPath) {
 }
 
 // ── Text-to-Speech ────────────────────────────────────────────────
+// Shared with direct mode: ElevenLabs natural voice, falling back to `say`.
 
-const TTS_CMD = process.platform === "darwin" ? "say" : null;
-
-function textToVoice(text) {
-  if (!TTS_CMD || !FFMPEG) return null;
-  try {
-    const clean = text.replace(/[*_`#>\[\]()]/g, "").replace(/\n{2,}/g, ". ").replace(/\n/g, " ").trim();
-    if (!clean) return null;
-    const aiffPath = path.join(TEMP_DIR, `tts-${Date.now()}.aiff`);
-    const oggPath = aiffPath.replace(".aiff", ".ogg");
-    execSync(`${TTS_CMD} ${JSON.stringify(clean)} -o "${aiffPath}"`, { timeout: 30000 });
-    execSync(`"${FFMPEG}" -i "${aiffPath}" -c:a libopus -y "${oggPath}" 2>/dev/null`, { timeout: 30000 });
-    try { fs.unlinkSync(aiffPath); } catch (e) {}
-    return oggPath;
-  } catch (e) {
-    console.error("TTS error:", e.message);
-    return null;
-  }
-}
+const { textToVoice } = require("./core/media");
 
 async function sendVoice(oggPath) {
   try {
@@ -1421,9 +1405,9 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
       if (code !== 0 && code !== null) await send(`Exit code: ${code}`);
 
       // Send voice reply if input was a voice note
-      if (lastInputWasVoice && TTS_CMD) {
+      if (lastInputWasVoice) {
         lastInputWasVoice = false;
-        const voicePath = textToVoice(finalText);
+        const voicePath = await textToVoice(finalText);
         if (voicePath) await sendVoice(voicePath);
       }
     } catch (e) {

package/channels/telegram/adapter.js

@@ -19,11 +19,16 @@ class TelegramAdapter {
     this.token = token;
     this.ownerChatId = ownerChatId;
     this.chatIds = chatIds || [];
+    // Own the HTTP(S) agent so we can drop dead keep-alive sockets on reconnect.
+    this._agent = new https.Agent({ keepAlive: true });
     this.bot = new TelegramBot(token, {
       polling: { autoStart: false, params: { timeout: 30 } },
+      request: { agent: this._agent },
     });
     this._listeners = { message: new Set(), action: new Set() };
     this._reconnectTimer = null;
+    this._recoveryTimer = null;
+    this._reconnectAttempts = 0;
     this._wireInbound();
   }
 
@@ -45,9 +50,49 @@ class TelegramAdapter {
   }
 
   async stop() {
+    if (this._reconnectTimer) { clearTimeout(this._reconnectTimer); this._reconnectTimer = null; }
+    if (this._recoveryTimer) { clearTimeout(this._recoveryTimer); this._recoveryTimer = null; }
     try { await this.bot.stopPolling(); } catch (e) {}
   }
 
+  // Recover from a wedged poll loop. The library reuses one keep-alive socket;
+  // after a sleep/wake or network blip that socket dies and every poll then
+  // ETIMEDOUTs forever — restarting polling alone reuses the same dead socket.
+  // So we destroy the agent (forcing a fresh connection), back off, and if we
+  // still can't recover after several tries we exit so launchd (KeepAlive)
+  // relaunches a fully clean process.
+  _scheduleReconnect() {
+    if (this._reconnectTimer) return; // one cycle in flight; swallow the flood
+    if (this._recoveryTimer) { clearTimeout(this._recoveryTimer); this._recoveryTimer = null; }
+    this._reconnectAttempts += 1;
+    const MAX = 6;
+    if (this._reconnectAttempts > MAX) {
+      console.error(`Polling unrecoverable after ${MAX} attempts — exiting for supervisor restart.`);
+      process.exit(1);
+    }
+    const delay = Math.min(30000, 1000 * 2 ** this._reconnectAttempts); // 2s,4s,8s,16s,30s,30s
+    console.log(`Network lost. Reconnecting in ${Math.round(delay / 1000)}s (attempt ${this._reconnectAttempts}/${MAX})...`);
+    this._reconnectTimer = setTimeout(async () => {
+      this._reconnectTimer = null;
+      try {
+        try { await this.bot.stopPolling(); } catch (e) {}
+        try { this._agent.destroy(); } catch (e) {} // drop the dead pooled socket
+        await new Promise((r) => setTimeout(r, 1000));
+        await this.bot.startPolling();
+        console.log("Polling restarted.");
+        // No fresh error within 30s ⇒ genuinely recovered; reset the counter.
+        this._recoveryTimer = setTimeout(() => {
+          this._recoveryTimer = null;
+          if (this._reconnectAttempts) console.log("Connection healthy again.");
+          this._reconnectAttempts = 0;
+        }, 30000);
+      } catch (e) {
+        console.error("Reconnect attempt failed:", e.message);
+        this._scheduleReconnect(); // back off and retry; don't die on first miss
+      }
+    }, delay);
+  }
+
   _wireInbound() {
     this.bot.on("polling_error", (err) => {
       const msg = err.message || "";
@@ -56,21 +101,8 @@ class TelegramAdapter {
         console.error("Another instance is polling. Exiting.");
         process.exit(1);
       }
-      if (msg.includes("ETIMEDOUT") || msg.includes("ECONNRESET") || msg.includes("ENOTFOUND") || msg.includes("EFATAL")) {
-        if (this._reconnectTimer) return;
-        console.log("Network lost. Reconnecting in 10s...");
-        this._reconnectTimer = setTimeout(async () => {
-          this._reconnectTimer = null;
-          try {
-            await this.bot.stopPolling();
-            await new Promise((r) => setTimeout(r, 2000));
-            await this.bot.startPolling();
-            console.log("Reconnected.");
-          } catch (e) {
-            console.error("Reconnect failed:", e.message);
-            process.exit(1);
-          }
-        }, 10000);
+      if (/ETIMEDOUT|ECONNRESET|ENOTFOUND|ENETUNREACH|EAI_AGAIN|EFATAL|socket hang up/i.test(msg)) {
+        this._scheduleReconnect();
       }
     });
 

package/core/config.js

@@ -99,6 +99,9 @@ const TRANSCRIPTS_DIR = config.TRANSCRIPTS_DIR || process.env.TRANSCRIPTS_DIR ||
 const WHISPER_CLI = config.WHISPER_CLI || "";
 const WHISPER_MODEL = config.WHISPER_MODEL || "";
 const FFMPEG = config.FFMPEG || "";
+const ELEVENLABS_API_KEY = config.ELEVENLABS_API_KEY || process.env.ELEVENLABS_API_KEY || "";
+const ELEVENLABS_VOICE_ID = config.ELEVENLABS_VOICE_ID || process.env.ELEVENLABS_VOICE_ID || "EXAVITQu4vr4xnSDxMaL";
+const ELEVENLABS_MODEL = config.ELEVENLABS_MODEL || process.env.ELEVENLABS_MODEL || "eleven_v3";
 const SOUL_FILE = config.SOUL_FILE || path.join(CONFIG_DIR, "soul.md");
 const CRONS_FILE = config.CRONS_FILE || path.join(CONFIG_DIR, "crons.json");
 const JOBS_FILE = config.JOBS_FILE || path.join(CONFIG_DIR, "jobs.json");
@@ -233,6 +236,7 @@ module.exports = {
   TRANSCRIPT_MAX_ENTRY_CHARS,
   TRANSCRIPTS_DIR,
   WHISPER_CLI, WHISPER_MODEL, FFMPEG,
+  ELEVENLABS_API_KEY, ELEVENLABS_VOICE_ID, ELEVENLABS_MODEL,
   SOUL_FILE, CRONS_FILE, JOBS_FILE, TASKS_DIR, VAULT_FILE, AUTH_FILE, IDENTITIES_FILE,
   PEOPLE_FILE, INTROS_FILE, AUDIT_FILE,
   STATE_FILE, SESSIONS_FILE,

package/core/media.js

@@ -4,7 +4,7 @@
 const fs = require("fs");
 const path = require("path");
 const { execSync } = require("child_process");
-const { WHISPER_CLI, WHISPER_MODEL, FFMPEG, TEMP_DIR } = require("./config");
+const { WHISPER_CLI, WHISPER_MODEL, FFMPEG, TEMP_DIR, ELEVENLABS_API_KEY, ELEVENLABS_VOICE_ID, ELEVENLABS_MODEL } = require("./config");
 
 const TTS_CMD = process.platform === "darwin" ? "say" : null;
 
@@ -19,11 +19,14 @@ function transcribeAudio(oggPath) {
     .join(" ").trim();
 }
 
-function textToVoice(text) {
+function cleanForTTS(text) {
+  return text.replace(/[*_`#>\[\]()]/g, "").replace(/\n{2,}/g, ". ").replace(/\n/g, " ").trim();
+}
+
+// macOS `say` fallback. Synchronous. Returns ogg path or null.
+function sayToVoice(clean) {
   if (!TTS_CMD || !FFMPEG) return null;
   try {
-    const clean = text.replace(/[*_`#>\[\]()]/g, "").replace(/\n{2,}/g, ". ").replace(/\n/g, " ").trim();
-    if (!clean) return null;
     const aiffPath = path.join(TEMP_DIR, `tts-${Date.now()}.aiff`);
     const oggPath = aiffPath.replace(".aiff", ".ogg");
     execSync(`${TTS_CMD} ${JSON.stringify(clean)} -o "${aiffPath}"`, { timeout: 30000 });
@@ -31,9 +34,49 @@ function textToVoice(text) {
     try { fs.unlinkSync(aiffPath); } catch (e) {}
     return oggPath;
   } catch (e) {
-    console.error("TTS error:", e.message);
+    console.error("say TTS error:", e.message);
     return null;
   }
 }
 
+// Natural TTS via ElevenLabs. Returns ogg path or null on any failure.
+async function elevenLabsToVoice(clean) {
+  if (!ELEVENLABS_API_KEY || !FFMPEG) return null;
+  try {
+    const res = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${ELEVENLABS_VOICE_ID}`, {
+      method: "POST",
+      headers: { "xi-api-key": ELEVENLABS_API_KEY, "Content-Type": "application/json" },
+      body: JSON.stringify({
+        text: clean,
+        model_id: ELEVENLABS_MODEL,
+        voice_settings: { stability: 0.5, similarity_boost: 0.85, style: 0.5, use_speaker_boost: true },
+      }),
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      console.error(`ElevenLabs TTS failed: ${res.status} ${body}`.slice(0, 300));
+      return null;
+    }
+    const buf = Buffer.from(await res.arrayBuffer());
+    const mp3Path = path.join(TEMP_DIR, `tts-${Date.now()}.mp3`);
+    const oggPath = mp3Path.replace(".mp3", ".ogg");
+    fs.writeFileSync(mp3Path, buf);
+    execSync(`"${FFMPEG}" -i "${mp3Path}" -c:a libopus -y "${oggPath}" 2>/dev/null`, { timeout: 30000 });
+    try { fs.unlinkSync(mp3Path); } catch (e) {}
+    return oggPath;
+  } catch (e) {
+    console.error("ElevenLabs TTS error:", e.message);
+    return null;
+  }
+}
+
+// Natural voice via ElevenLabs, falling back to macOS `say` only on no-key/error.
+async function textToVoice(text) {
+  const clean = cleanForTTS(text);
+  if (!clean) return null;
+  const eleven = await elevenLabsToVoice(clean);
+  if (eleven) return eleven;
+  return sayToVoice(clean);
+}
+
 module.exports = { transcribeAudio, textToVoice, TTS_CMD };

package/core/runner.js

@@ -16,7 +16,7 @@ const { chatContext, currentChannelId, currentAdapter } = require("./context");
 const { buildSystemPrompt, promptWithDynamicContext } = require("./system-prompt");
 const { redactSensitive } = require("./redact");
 const { send, editMessage, sendVoice, splitMessage } = require("./io");
-const { textToVoice, TTS_CMD } = require("./media");
+const { textToVoice } = require("./media");
 const { killProcessTree } = require("./process-tree");
 const {
   appendProjectTranscript, transcriptProjectInfo,
@@ -1193,9 +1193,9 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
       }
       if (code !== 0 && code !== null) await send(`Exit code: ${code}`);
 
-      if (state.lastInputWasVoice && TTS_CMD) {
+      if (state.lastInputWasVoice) {
         state.lastInputWasVoice = false;
-        const voicePath = textToVoice(finalText);
+        const voicePath = await textToVoice(finalText);
         if (voicePath) await sendVoice(voicePath);
       }
     } catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.6.43",
+  "version": "2.6.45",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {