@inetafrica/open-claudia 3.1.10 → 3.1.12

package/core/actions.js

@@ -416,6 +416,27 @@ async function handleAction(envelope) {
     await send(`Tooling mode: ${m}${m === "relaxed" ? " ⚠️ deny-gate is log-only; ad-hoc scripting allowed" : " — tool-first enforced"}`);
     return;
   }
+  if (d.startsWith("vc:")) {
+    if (!isChatOwner(envelope.channelId)) return send("Owner only — the voice is shared across this bot.");
+    const ttsVoice = require("./tts-voice");
+    const rest = d.slice(3);
+    if (rest === "clone") {
+      state.pendingVoiceClone = { at: Date.now() };
+      return send("🎙️ Send me a voice note now — 5–15s of clear speech and I'll clone it as your voice. Send /voice to cancel.");
+    }
+    state.pendingVoiceClone = null;
+    if (rest === "default") {
+      ttsVoice.clearVoice();
+      return send(`🎙️ Voice reset to default (${ttsVoice.getVoiceLabel()}).`);
+    }
+    if (rest.startsWith("p:")) {
+      const preset = ttsVoice.presetByKey(rest.slice(2));
+      if (!preset) return send("That voice button is stale. Open /voice again.");
+      ttsVoice.setVoice(preset.id, preset.label);
+      return send(`🎙️ Voice set: ${preset.label}`);
+    }
+    return;
+  }
   if (d.startsWith("apr:")) {
     // Approval buttons. Owner-only: the exact payload was shown in the prompt;
     // decide() is idempotent so double-taps can't flip it. Two shapes share

package/core/handlers.js

@@ -1322,6 +1322,49 @@ register({
   },
 });
 
+register({
+  name: "voice", description: "Pick the Pocket TTS voice, or clone your own", args: "[<preset>|<hf://…>|clone|default]", ownerOnly: true,
+  handler: async (env, { tail }) => {
+    if (!authorized(env)) return;
+    const ttsVoice = require("./tts-voice");
+    const state = currentState();
+    const arg = (tail || "").trim();
+    if (arg) {
+      const low = arg.toLowerCase();
+      if (low === "clone") {
+        state.pendingVoiceClone = { at: Date.now() };
+        return send("🎙️ Send me a voice note now — 5–15s of clear speech and I'll clone it as your voice. Send /voice to cancel.");
+      }
+      state.pendingVoiceClone = null;
+      if (low === "default" || low === "reset") {
+        ttsVoice.clearVoice();
+        return send(`🎙️ Voice reset to default (${ttsVoice.getVoiceLabel()}).`);
+      }
+      const preset = ttsVoice.presetByKey(low);
+      if (preset) {
+        ttsVoice.setVoice(preset.id, preset.label);
+        return send(`🎙️ Voice set: ${preset.label}`);
+      }
+      // Anything else is treated as a raw voice reference pocket-tts understands:
+      // a built-in shorthand, an hf:// path, an http(s) URL, or a stored id.
+      ttsVoice.setVoice(arg, null);
+      return send(`🎙️ Voice set: ${arg}`);
+    }
+    state.pendingVoiceClone = null;
+    const rows = ttsVoice.presets().map((p) => [{ text: p.label, callback_data: `vc:p:${p.key}` }]);
+    rows.push([
+      { text: "🎙️ Clone from a clip", callback_data: "vc:clone" },
+      { text: "↩︎ Default", callback_data: "vc:default" },
+    ]);
+    send(
+      `🎙️ Voice: ${ttsVoice.getVoiceLabel()}\n\n` +
+      "Pick a voice — it takes effect immediately, no restart. Or tap Clone from a clip (or send /voice clone) to use your own recorded voice.\n\n" +
+      "For any other voice: /voice hf://kyutai/tts-voices/<folder>/<clip>.wav",
+      { keyboard: { inline_keyboard: rows } },
+    );
+  },
+});
+
 register({
   name: "budget", description: "Set max spend for next task", args: "[$N]",
   handler: async (env, { tail }) => {

package/core/media.js

@@ -4,7 +4,8 @@
 const fs = require("fs");
 const path = require("path");
 const { execSync } = require("child_process");
-const { WHISPER_CLI, WHISPER_MODEL, FFMPEG, TEMP_DIR, ELEVENLABS_API_KEY, ELEVENLABS_VOICE_ID, ELEVENLABS_MODEL, SPEECH_SERVICE_URL, SPEECH_API_KEY, AGENTSPACE_POD_TOKEN, POCKET_TTS_VOICE, TTS_PROVIDER } = require("./config");
+const { WHISPER_CLI, WHISPER_MODEL, FFMPEG, TEMP_DIR, ELEVENLABS_API_KEY, ELEVENLABS_VOICE_ID, ELEVENLABS_MODEL, SPEECH_SERVICE_URL, SPEECH_API_KEY, AGENTSPACE_POD_TOKEN, TTS_PROVIDER } = require("./config");
+const ttsVoice = require("./tts-voice");
 
 const TTS_CMD = process.platform === "darwin" ? "say" : null;
 
@@ -108,7 +109,7 @@ async function pocketToVoice(clean) {
     const res = await fetch(`${SPEECH_SERVICE_URL.replace(/\/$/, "")}/v1/audio/speech`, {
       method: "POST",
       headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
-      body: JSON.stringify({ input: clean, voice: POCKET_TTS_VOICE, response_format: "wav" }),
+      body: JSON.stringify({ input: clean, voice: ttsVoice.getVoice(), response_format: "wav" }),
       signal: AbortSignal.timeout(60000),
     });
     if (!res.ok) {
@@ -129,6 +130,52 @@ async function pocketToVoice(clean) {
   }
 }
 
+// Upload a reference clip to the speech gateway for voice cloning. The gateway
+// stores the clip on the TTS pod's model-cache volume and returns a voice id
+// usable as the `voice` field on later /v1/audio/speech calls; pocket-tts clones
+// from it. Returns the id string, or null on any failure.
+async function cloneVoiceFromClip(clipPath) {
+  const token = speechBearerToken();
+  if (!SPEECH_SERVICE_URL || !token || !clipPath) return null;
+  // Telegram voice notes arrive as ogg/opus, which pocket-tts can't decode as a
+  // reference prompt — transcode to 24kHz mono wav (the model's native rate)
+  // first. Fall back to the raw clip only if ffmpeg is unavailable.
+  let wavPath = null;
+  let uploadPath = clipPath;
+  if (FFMPEG) {
+    try {
+      wavPath = path.join(TEMP_DIR, `voice-clone-${Date.now()}-${Math.random().toString(36).slice(2, 6)}.wav`);
+      execSync(`"${FFMPEG}" -i "${clipPath}" -ar 24000 -ac 1 -y "${wavPath}" 2>/dev/null`, { timeout: 30000 });
+      uploadPath = wavPath;
+    } catch (e) {
+      console.error("Voice clone transcode error:", e.message);
+      wavPath = null;
+      uploadPath = clipPath;
+    }
+  }
+  try {
+    const body = new FormData();
+    body.append("file", new Blob([fs.readFileSync(uploadPath)]), path.basename(uploadPath));
+    const res = await fetch(`${SPEECH_SERVICE_URL.replace(/\/$/, "")}/v1/voices`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${token}` },
+      body,
+      signal: AbortSignal.timeout(120000),
+    });
+    if (!res.ok) {
+      console.error(`Voice clone upload failed: HTTP ${res.status}`);
+      return null;
+    }
+    const payload = await res.json().catch(() => ({}));
+    return String(payload.voice_id || payload.id || "").trim() || null;
+  } catch (e) {
+    console.error("Voice clone error:", e.message);
+    return null;
+  } finally {
+    if (wavPath) { try { fs.unlinkSync(wavPath); } catch (e) {} }
+  }
+}
+
 // True when at least one textToVoice route can produce audio. Mirrors the
 // pocket -> ElevenLabs -> say fallback chain; local Whisper is deliberately
 // irrelevant here (hosted pods speak via the gateway without it).
@@ -203,4 +250,4 @@ async function synthSentenceMp3(text) {
   }
 }
 
-module.exports = { transcribeAudio, transcribeAudioLocal, textToVoice, splitSentences, synthSentenceMp3, pocketToVoice, speechBearerToken, canSpeak, TTS_CMD };
+module.exports = { transcribeAudio, transcribeAudioLocal, textToVoice, splitSentences, synthSentenceMp3, pocketToVoice, cloneVoiceFromClip, speechBearerToken, canSpeak, TTS_CMD };

package/core/router.js

@@ -13,7 +13,7 @@ const introFlow = require("./intro-flow");
 const { send, deleteMessage } = require("./io");
 const { currentState, saveState, autoLinkOwnerChannel } = require("./state");
 const { admitRunContext, runAgent } = require("./runner");
-const { transcribeAudio } = require("./media");
+const { transcribeAudio, cloneVoiceFromClip } = require("./media");
 const { vault } = require("./vault-store");
 const { isOnboarded, handleOnboarding } = require("./onboarding");
 const {
@@ -185,6 +185,13 @@ async function handleVoice(envelope) {
     if (media.size && media.size > MAX_VOICE_SIZE) {
       return send(`Voice note too large (${Math.round(media.size / 1024 / 1024)}MB). Max: ${MAX_VOICE_SIZE / 1024 / 1024}MB`);
     }
+    // /voice clone armed this channel: the next clip is a cloning sample, not a
+    // prompt. Consume the flag (fresh only) before the normal transcribe path.
+    if (state.pendingVoiceClone) {
+      const fresh = Date.now() - state.pendingVoiceClone.at < 5 * 60 * 1000;
+      state.pendingVoiceClone = null;
+      if (fresh) return captureVoiceClone(envelope, media);
+    }
     const runContext = admitRunContext("", state.currentSession.dir, envelope.messageId, {
       purpose: "foreground",
       attachments: [{ type: "voice", mimeType: media.mimeType || "audio/ogg", fileName: media.fileName || null }],
@@ -216,6 +223,11 @@ async function handleAudio(envelope) {
   try {
     const media = envelope.media?.[0];
     if (!media) return;
+    if (state.pendingVoiceClone) {
+      const fresh = Date.now() - state.pendingVoiceClone.at < 5 * 60 * 1000;
+      state.pendingVoiceClone = null;
+      if (fresh) return captureVoiceClone(envelope, media);
+    }
     const runContext = admitRunContext("", state.currentSession.dir, envelope.messageId, {
       purpose: "foreground",
       attachments: [{ type: "audio", mimeType: media.mimeType || null, fileName: media.fileName || null }],
@@ -233,6 +245,26 @@ async function handleAudio(envelope) {
   } catch (err) { await send(`Audio failed: ${err.message}`); }
 }
 
+// A clip the owner sent right after /voice clone. Upload it to the speech
+// gateway (which stores it on the TTS pod and returns a voice id), then set that
+// id as the active voice. Never transcribed or sent to the agent.
+async function captureVoiceClone(envelope, media) {
+  try {
+    envelope.adapter.typing(envelope.channelId).catch(() => {});
+    await send("🎙️ Got it — cloning your voice…");
+    const clipPath = await envelope.adapter.downloadMedia(media);
+    const voiceId = await cloneVoiceFromClip(clipPath);
+    try { fs.unlinkSync(clipPath); } catch (e) {}
+    if (!voiceId) {
+      return send("Couldn't process that clip for cloning. Send a clear 5–15s recording and try /voice clone again.");
+    }
+    require("./tts-voice").setVoice(voiceId, "your cloned voice");
+    return send("✅ Cloned. I'll speak in that voice from now on — change it anytime with /voice.");
+  } catch (err) {
+    await send(`Voice clone failed: ${err.message}`);
+  }
+}
+
 async function handlePhoto(envelope) {
   if (isDuplicate(envelope)) return;
   const state = currentState();

package/core/tts-voice.js

@@ -0,0 +1,98 @@
+"use strict";
+
+// Live-read, persisted Pocket TTS voice selection.
+//
+// The active voice overrides the POCKET_TTS_VOICE env default and is read at
+// synth time (media.js), so /voice takes effect immediately with no restart.
+// The choice survives restarts via a small JSON file in the bot config dir;
+// env stays the deploy-time default/floor and is used only when no override is
+// set. A cloned-clip voice is just another voice string (a server-issued id).
+
+const fs = require("fs");
+const path = require("path");
+const { CONFIG_DIR, POCKET_TTS_VOICE } = require("./config");
+const { atomicWriteFileSync } = require("./fsutil");
+
+const STORE = path.join(CONFIG_DIR, "tts-voice.json");
+
+// Curated shortlist for the /voice picker. `id` is exactly what pocket-tts's
+// get_state_for_audio_prompt resolves: the built-in "alba" shorthand or an
+// hf:// reference into the kyutai/tts-voices repo. Every path here was verified
+// against that repo's file tree, so the buttons always resolve.
+const PRESETS = [
+  { key: "alba", label: "Alba (default)", id: "alba" },
+  { key: "announcer", label: "Alba · announcer", id: "hf://kyutai/tts-voices/alba-mackenna/announcer.wav" },
+  { key: "merchant", label: "Alba · merchant", id: "hf://kyutai/tts-voices/alba-mackenna/merchant.wav" },
+  { key: "expresso", label: "Expresso", id: "hf://kyutai/tts-voices/expresso/ex01-ex02_default_001_channel1_168s.wav" },
+  { key: "enunciated", label: "Expresso · clear", id: "hf://kyutai/tts-voices/expresso/ex01-ex02_enunciated_001_channel1_432s.wav" },
+  { key: "vctk-p225", label: "VCTK p225", id: "hf://kyutai/tts-voices/vctk/p225_023.wav" },
+  { key: "vctk-p226", label: "VCTK p226", id: "hf://kyutai/tts-voices/vctk/p226_023.wav" },
+];
+
+// undefined = not loaded yet; null = loaded, no override (use env default);
+// { voice, label } = an active override.
+let cache;
+
+function defaultVoice() {
+  return (POCKET_TTS_VOICE && String(POCKET_TTS_VOICE).trim()) || "alba";
+}
+
+function load() {
+  if (cache !== undefined) return cache;
+  try {
+    const raw = JSON.parse(fs.readFileSync(STORE, "utf-8"));
+    if (raw && typeof raw.voice === "string" && raw.voice.trim()) {
+      cache = { voice: raw.voice.trim(), label: typeof raw.label === "string" && raw.label ? raw.label : null };
+      return cache;
+    }
+  } catch (e) { /* no store yet, or malformed — fall back to default */ }
+  cache = null;
+  return cache;
+}
+
+// The active voice string handed to the speech gateway.
+function getVoice() {
+  const s = load();
+  return (s && s.voice) || defaultVoice();
+}
+
+// Human-friendly label for the active voice (preset label, custom note, or id).
+function getVoiceLabel() {
+  const s = load();
+  if (s) return s.label || s.voice;
+  const dv = defaultVoice();
+  const p = PRESETS.find((x) => x.id === dv || x.key === dv);
+  return p ? p.label : dv;
+}
+
+// True when the active voice is an explicit override (not the env default).
+function isOverridden() {
+  return !!load();
+}
+
+function setVoice(voice, label = null) {
+  const v = String(voice || "").trim();
+  if (!v) throw new Error("voice is required");
+  cache = { voice: v, label: label ? String(label).trim() : null };
+  atomicWriteFileSync(STORE, JSON.stringify(cache, null, 2), { backup: false, mode: 0o600 });
+  return cache;
+}
+
+// Drop the override and fall back to the env/config default.
+function clearVoice() {
+  cache = null;
+  try { fs.unlinkSync(STORE); } catch (e) { /* already absent */ }
+}
+
+function presets() { return PRESETS.slice(); }
+function presetByKey(key) { return PRESETS.find((p) => p.key === String(key || "").toLowerCase()) || null; }
+
+// Test seam: forget the in-memory cache so the next read re-consults disk.
+function _resetCache() { cache = undefined; }
+
+module.exports = {
+  getVoice, getVoiceLabel, isOverridden,
+  setVoice, clearVoice,
+  presets, presetByKey, defaultVoice,
+  STORE, _resetCache,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "3.1.10",
+  "version": "3.1.12",
   "description": "An always-on, provider-agnostic coding-agent harness for Claude Code and OpenAI Codex via chat",
   "main": "bot.js",
   "bin": {

package/test-provider-language.js

@@ -195,7 +195,16 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // bot process advertised voice as enabled. Synthesis moves into the credentialed
 // bot process behind a loopback "say" kind; the CLI now sends only text; the R8
 // external-contact egress guard is preserved. Plus this version-pin bump.
-assert.strictEqual(pkg.version, "3.1.10", "release version must remain unchanged without explicit approval");
+// 3.1.11 was cut for the /voice picker + voice cloning feature but its build
+// failed on this very version pin (still 3.1.10): the package.json bump landed
+// without the matching pin update, so the docker stage was skipped and no image
+// was published. Never retag a failed version — re-cut as +1.
+// 3.1.12 approved by Sumeet 2026-07-21: re-cut of 3.1.11. Owner-gated /voice
+// preset picker over the Pocket TTS catalog (live-read, persists across restart,
+// Custom hf:// escape hatch) plus voice cloning — send a clip and it's transcoded
+// (ogg->24kHz mono wav) and registered via the speech gateway /v1/voices as the
+// active stored:<digest> voice. Plus this version-pin bump.
+assert.strictEqual(pkg.version, "3.1.12", "release version must remain unchanged without explicit approval");
 for (const keyword of ["claude", "codex", "coding-agent", "provider-agnostic"]) {
   assert.ok(pkg.keywords.includes(keyword), `package keyword missing: ${keyword}`);
 }