@inetafrica/open-claudia 2.6.47 → 2.6.48

package/channels/voice/adapter.js

@@ -127,6 +127,16 @@ class VoiceAdapter {
       });
     }
 
+    // Management API — REST surface over the core stores (tasks, jobs, packs,
+    // entities, people, lessons, ideas) so the app is a full Open Claudia
+    // frontend, not just a voice channel.
+    if (pathname.startsWith("/v1/manage/")) {
+      return require("./manage").handle(req, res, url, {
+        json: (code, payload) => this._json(res, code, payload),
+        readBody: (cb) => this._readBody(req, res, cb),
+      });
+    }
+
     if (req.method === "POST" && pathname === "/v1/messages/text") {
       return this._readBody(req, res, (buf) => this._onText(buf, res));
     }
@@ -330,10 +340,11 @@ class VoiceAdapter {
     this._broadcast({ kind: "delete", messageId, ts: Date.now() });
   }
 
-  async sendVoice(channelId, oggPath) {
+  async sendVoice(channelId, audioPath) {
     try {
-      const id = this._registerMedia(oggPath, "audio/ogg", path.basename(oggPath));
-      this._broadcast({ kind: "voice", messageId: this._mkId("v"), url: `/v1/media/${id}`, mime: "audio/ogg", ts: Date.now() });
+      const mime = this._guessMime(audioPath);
+      const id = this._registerMedia(audioPath, mime, path.basename(audioPath));
+      this._broadcast({ kind: "voice", messageId: this._mkId("v"), url: `/v1/media/${id}`, mime, ts: Date.now() });
       return true;
     } catch (e) {
       console.error("voice sendVoice error:", e.message);
@@ -341,6 +352,12 @@ class VoiceAdapter {
     }
   }
 
+  // Marks the end of a streamed multi-clip spoken reply so the client can stop
+  // queueing and re-arm the mic for the next hands-free turn.
+  async sendVoiceEnd() {
+    this._broadcast({ kind: "voice-end", ts: Date.now() });
+  }
+
   async sendPhoto(channelId, filePath, caption) { return this.sendFile(channelId, filePath, caption); }
 
   async sendFile(channelId, filePath, caption) {
@@ -442,7 +459,7 @@ class VoiceAdapter {
   _cors(res, code) {
     res.writeHead(code, {
       "Access-Control-Allow-Origin": "*",
-      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+      "Access-Control-Allow-Methods": "GET, POST, PATCH, DELETE, OPTIONS",
       "Access-Control-Allow-Headers": "Authorization, Content-Type",
     });
     res.end();

package/channels/voice/manage.js

@@ -0,0 +1,285 @@
+// Management API for the voice/companion app — a thin REST surface over the
+// same core stores the CLI uses (tasks, jobs, packs, entities, people,
+// lessons, ideas). Lets the Expo client act as a full Open Claudia frontend:
+// browse and manage work across every channel, not just the voice one.
+//
+// Mounted by the voice adapter under /v1/manage/*. Auth is already enforced
+// by the adapter before we get here (same bearer token as the rest of the
+// bridge). All routes return JSON.
+//
+// Scope note: tasks are stored per channel (tasks/<adapter>-<channelId>.json),
+// so the owner's real backlog lives on the Telegram channel, not voice. We
+// aggregate across every task file so the app shows the whole picture. The
+// file stem is an opaque "key"; since tasks.filePathFor re-applies the same
+// safe() (idempotent on already-safe strings) and just concatenates with a
+// single "-", splitting the key at the first "-" round-trips to the same file
+// regardless of where the boundary truly was.
+
+const fs = require("fs");
+const path = require("path");
+const tasks = require("../../core/tasks");
+const jobs = require("../../core/jobs");
+const packs = require("../../core/packs");
+const entities = require("../../core/entities");
+const people = require("../../core/people");
+const lessons = require("../../core/lessons");
+const ideas = require("../../core/ideas");
+const { TASKS_DIR, DEFAULT_CLAUDE_MODEL } = require("../../core/config");
+
+let PKG_VERSION = "unknown";
+try { PKG_VERSION = require("../../package.json").version || "unknown"; } catch (e) {}
+
+// ── task channel keys ──────────────────────────────────────────────
+
+function taskFileKeys() {
+  let entries = [];
+  try { entries = fs.readdirSync(TASKS_DIR); } catch (e) { return []; }
+  return entries
+    .filter((f) => f.endsWith(".json") && !f.endsWith(".tmp") && !f.startsWith("."))
+    .map((f) => f.slice(0, -5));
+}
+
+function keyToAC(key) {
+  const i = String(key).indexOf("-");
+  if (i < 0) return { adapter: key, channelId: "" };
+  return { adapter: key.slice(0, i), channelId: key.slice(i + 1) };
+}
+
+// Friendlier channel label for the UI than the raw file stem.
+function channelLabel(key) {
+  const { adapter } = keyToAC(key);
+  const map = { telegram: "Telegram", kazee: "Kazee", voice: "Voice" };
+  return map[adapter] || adapter || key;
+}
+
+function isOpen(t) { return t.status === "pending" || t.status === "in_progress"; }
+
+// ── responses ──────────────────────────────────────────────────────
+
+function overview() {
+  const keys = taskFileKeys();
+  let openTasks = 0, inProgress = 0;
+  for (const key of keys) {
+    const { adapter, channelId } = keyToAC(key);
+    for (const t of tasks.load(adapter, channelId)) {
+      if (isOpen(t)) openTasks++;
+      if (t.status === "in_progress") inProgress++;
+    }
+  }
+  const allJobs = jobs.listAll();
+  return {
+    version: PKG_VERSION,
+    model: DEFAULT_CLAUDE_MODEL,
+    counts: {
+      tasksOpen: openTasks,
+      tasksInProgress: inProgress,
+      taskChannels: keys.length,
+      crons: allJobs.filter((j) => j.kind === "cron").length,
+      wakeups: allJobs.filter((j) => j.kind === "wakeup").length,
+      packs: safeLen(() => packs.listPacks()),
+      entities: safeLen(() => entities.listEntities()),
+      people: safeLen(() => people.list()),
+      lessons: safeLen(() => lessons.listLessons()),
+      ideas: safeLen(() => ideas.listIdeas()),
+    },
+  };
+}
+
+function safeLen(fn) { try { return (fn() || []).length; } catch (e) { return 0; } }
+
+// Aggregated task tree across every channel, grouped per channel and sorted
+// so the busiest channel (most open tasks) comes first.
+function allTasks() {
+  const groups = [];
+  for (const key of taskFileKeys()) {
+    const { adapter, channelId } = keyToAC(key);
+    const tree = tasks.tree(adapter, channelId);
+    const open = tree.filter((r) => isOpen(r) || (r.children || []).some(isOpen)).length;
+    if (tree.length === 0) continue;
+    groups.push({ key, label: channelLabel(key), adapter, channelId, open, total: tree.length, tasks: tree });
+  }
+  groups.sort((a, b) => b.open - a.open || b.total - a.total);
+  return { groups };
+}
+
+function allJobsView() {
+  const list = jobs.listAll().map((j) => ({
+    id: j.id,
+    kind: j.kind,
+    label: j.label || "",
+    prompt: j.prompt || "",
+    adapterType: j.adapterType || j.adapter || "",
+    channelId: j.channelId || "",
+    project: j.project || null,
+    source: j.source || "agent",
+    schedule: j.schedule || null,
+    fireAt: j.fireAt || null,
+    lastFireAt: j.lastFireAt || null,
+    lastFireOk: j.lastFireOk === undefined ? null : j.lastFireOk,
+    createdAt: j.createdAt || null,
+  }));
+  // Wakeups by soonest fire, then crons.
+  list.sort((a, b) => {
+    if (a.kind !== b.kind) return a.kind === "wakeup" ? -1 : 1;
+    if (a.kind === "wakeup") return (a.fireAt || 0) - (b.fireAt || 0);
+    return String(a.label).localeCompare(String(b.label));
+  });
+  return { jobs: list };
+}
+
+function packSummaries() {
+  return {
+    packs: (packs.listPacks() || []).map((p) => ({
+      dir: p.dir, name: p.name, description: p.description, tags: p.tags,
+      parent: p.parent, skill: p.skill, kind: p.kind, updated: p.updated,
+      usage_count: p.usage_count, archived: !!p.archived,
+    })),
+  };
+}
+
+function packDetail(dir) {
+  const p = packs.readPack(dir);
+  if (!p) return null;
+  return p; // includes sections {Stance, Procedure, State, Journal}
+}
+
+function entitySummaries() {
+  return {
+    entities: (entities.listEntities() || []).map((e) => ({
+      slug: e.slug, name: e.name, type: e.type, description: e.description,
+      aliases: e.aliases, updated: e.updated, last_seen: e.last_seen,
+    })),
+  };
+}
+
+function entityDetail(slug) {
+  const e = entities.readEntity(slug);
+  if (!e) return null;
+  // readEntity stores sections as parseSections(body) → { sections: {...} }.
+  const sections = e.sections && e.sections.sections ? e.sections.sections : e.sections;
+  return { ...e, sections };
+}
+
+function peopleView() {
+  return {
+    people: (people.list() || []).map((p) => ({
+      id: p.id, name: p.name, isOwner: !!p.isOwner, bio: p.bio || null,
+      handles: (p.handles || []).map((h) => ({ adapter: h.adapter, channelId: h.channelId })),
+      primaryChannel: p.primaryChannel || null,
+      notes: (p.notes || []).map((n) => (typeof n === "string" ? { text: n } : { text: n.text || "", at: n.at || n.createdAt || null })),
+    })),
+  };
+}
+
+function lessonsView() {
+  return { lessons: (lessons.listLessons() || []).map((l) => ({ id: l.id, text: l.text, src: l.src || "", origin: l.origin || "", created: l.created || "", reinforced: l.reinforced || 0 })) };
+}
+
+function ideasView() {
+  return { ideas: (ideas.listIdeas() || []).map((i) => ({ id: i.id, text: i.text, created: i.created || "" })) };
+}
+
+// ── router ─────────────────────────────────────────────────────────
+// helpers: { json(code, payload), readBody(cb) } supplied by the adapter so
+// we don't reach into its privates.
+
+function handle(req, res, url, helpers) {
+  const { json, readBody } = helpers;
+  const method = req.method;
+  const sub = url.pathname.slice("/v1/manage/".length).replace(/\/+$/, "");
+  const parts = sub.split("/").filter(Boolean);
+
+  try {
+    // GET reads
+    if (method === "GET") {
+      if (sub === "overview") return json(200, { ok: true, ...overview() });
+      if (sub === "tasks") return json(200, { ok: true, ...allTasks() });
+      if (sub === "jobs") return json(200, { ok: true, ...allJobsView() });
+      if (sub === "packs") return json(200, { ok: true, ...packSummaries() });
+      if (parts[0] === "packs" && parts[1]) {
+        const d = packDetail(decodeURIComponent(parts.slice(1).join("/")));
+        return d ? json(200, { ok: true, pack: d }) : json(404, { ok: false, error: "pack not found" });
+      }
+      if (sub === "entities") return json(200, { ok: true, ...entitySummaries() });
+      if (parts[0] === "entities" && parts[1]) {
+        const e = entityDetail(decodeURIComponent(parts.slice(1).join("/")));
+        return e ? json(200, { ok: true, entity: e }) : json(404, { ok: false, error: "entity not found" });
+      }
+      if (sub === "people") return json(200, { ok: true, ...peopleView() });
+      if (sub === "lessons") return json(200, { ok: true, ...lessonsView() });
+      if (sub === "ideas") return json(200, { ok: true, ...ideasView() });
+      return json(404, { ok: false, error: "unknown manage route" });
+    }
+
+    // POST /tasks — add a task (or subtask)
+    if (method === "POST" && sub === "tasks") {
+      return readBody((buf) => {
+        let body = {};
+        try { body = JSON.parse(buf.toString("utf-8") || "{}"); } catch (e) {}
+        const { adapter, channelId } = resolveTaskTarget(body);
+        const content = String(body.content || "").trim();
+        if (!content) return json(400, { ok: false, error: "content required" });
+        try {
+          const t = tasks.add(adapter, channelId, content, {
+            parentId: body.parentId || null,
+            description: body.description || null,
+          });
+          return json(201, { ok: true, task: t });
+        } catch (e) { return json(400, { ok: false, error: e.message }); }
+      });
+    }
+
+    // PATCH /tasks/:id — { key|adapter+channelId, action: start|done|remove|pending }
+    if (method === "PATCH" && parts[0] === "tasks" && parts[1]) {
+      const id = parts[1];
+      return readBody((buf) => {
+        let body = {};
+        try { body = JSON.parse(buf.toString("utf-8") || "{}"); } catch (e) {}
+        const { adapter, channelId } = resolveTaskTarget(body);
+        const action = String(body.action || "").toLowerCase();
+        try {
+          if (action === "start") {
+            const t = tasks.update(adapter, channelId, id, { status: "in_progress" });
+            return t ? json(200, { ok: true, task: t }) : json(404, { ok: false, error: "task not found" });
+          }
+          if (action === "pending") {
+            const t = tasks.update(adapter, channelId, id, { status: "pending" });
+            return t ? json(200, { ok: true, task: t }) : json(404, { ok: false, error: "task not found" });
+          }
+          if (action === "done") {
+            const r = tasks.complete(adapter, channelId, id);
+            if (!r) return json(404, { ok: false, error: "task not found" });
+            if (r.blocked) return json(409, { ok: false, error: "plan has open subtasks", openChildren: r.openChildren.map((c) => c.content) });
+            return json(200, { ok: true, removedCount: r.removedCount });
+          }
+          if (action === "remove") {
+            const r = tasks.remove(adapter, channelId, id);
+            return r ? json(200, { ok: true, alsoRemoved: r.alsoRemoved }) : json(404, { ok: false, error: "task not found" });
+          }
+          return json(400, { ok: false, error: "unknown action" });
+        } catch (e) { return json(400, { ok: false, error: e.message }); }
+      });
+    }
+
+    // DELETE /jobs/:id — cancel a wakeup or cron
+    if (method === "DELETE" && parts[0] === "jobs" && parts[1]) {
+      const removed = jobs.remove(parts[1]);
+      return removed ? json(200, { ok: true, removed: { id: removed.id, kind: removed.kind, label: removed.label } }) : json(404, { ok: false, error: "job not found" });
+    }
+
+    return json(404, { ok: false, error: "unknown manage route" });
+  } catch (e) {
+    return json(500, { ok: false, error: e.message });
+  }
+}
+
+// A task mutation needs the exact (adapter, channelId). The client passes the
+// channel "key" (file stem) it got from GET /tasks; fall back to explicit
+// adapter+channelId, then to the voice channel as a last resort.
+function resolveTaskTarget(body) {
+  if (body && body.key) return keyToAC(body.key);
+  if (body && body.adapter) return { adapter: body.adapter, channelId: body.channelId || "" };
+  return { adapter: "voice", channelId: "voice-owner" };
+}
+
+module.exports = { handle };

package/core/io.js

@@ -35,6 +35,16 @@ async function sendVoice(oggPath) {
   return adapter.sendVoice(channelId, oggPath);
 }
 
+// Signal the end of a streamed multi-clip spoken reply. Only the voice channel
+// implements it (so the client knows the reply is complete and can re-arm the
+// mic); other adapters simply have no such method and this is a no-op.
+async function sendVoiceEnd() {
+  const adapter = currentAdapter();
+  const channelId = currentChannelId();
+  if (!adapter || !channelId || typeof adapter.sendVoiceEnd !== "function") return;
+  return adapter.sendVoiceEnd(channelId);
+}
+
 async function sendFile(filePath, caption) {
   const adapter = currentAdapter();
   const channelId = currentChannelId();
@@ -56,4 +66,4 @@ function splitMessage(text, maxLen = 4000) {
   return chunks;
 }
 
-module.exports = { send, editMessage, deleteMessage, sendVoice, sendFile, typing, splitMessage };
+module.exports = { send, editMessage, deleteMessage, sendVoice, sendVoiceEnd, sendFile, typing, splitMessage };

package/core/media.js

@@ -79,4 +79,56 @@ async function textToVoice(text) {
   return sayToVoice(clean);
 }
 
-module.exports = { transcribeAudio, textToVoice, TTS_CMD };
+// Split a reply into sentence-sized chunks for streamed TTS. Tiny fragments are
+// merged into the next chunk so we don't fire a TTS call per "Hi." and end up
+// with choppy playback. Returns cleaned, non-empty chunks.
+function splitSentences(text, minLen = 30) {
+  const clean = cleanForTTS(text);
+  if (!clean) return [];
+  const raw = clean.match(/[^.!?]+[.!?]+|\S[^.!?]*$/g) || [clean];
+  const out = [];
+  let buf = "";
+  for (const piece of raw) {
+    buf = (buf ? `${buf} ${piece.trim()}` : piece.trim()).trim();
+    if (buf.length >= minLen) { out.push(buf); buf = ""; }
+  }
+  if (buf) {
+    if (out.length) out[out.length - 1] = `${out[out.length - 1]} ${buf}`.trim();
+    else out.push(buf);
+  }
+  return out.filter(Boolean);
+}
+
+// Synthesize one already-short chunk to a directly-playable mp3 (no transcode).
+// Used by the voice channel's streamed replies. Falls back to the ogg path
+// (textToVoice) on no-key/error so callers always get a playable file or null.
+async function synthSentenceMp3(text) {
+  const clean = cleanForTTS(text);
+  if (!clean) return null;
+  if (!ELEVENLABS_API_KEY) return sayToVoice(clean); // ogg fallback
+  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 sayToVoice(clean);
+    }
+    const buf = Buffer.from(await res.arrayBuffer());
+    const mp3Path = path.join(TEMP_DIR, `tts-${Date.now()}-${Math.random().toString(36).slice(2, 6)}.mp3`);
+    fs.writeFileSync(mp3Path, buf);
+    return mp3Path;
+  } catch (e) {
+    console.error("ElevenLabs TTS error:", e.message);
+    return sayToVoice(clean);
+  }
+}
+
+module.exports = { transcribeAudio, textToVoice, splitSentences, synthSentenceMp3, TTS_CMD };

package/core/runner.js

@@ -15,8 +15,8 @@ const { currentState, saveState, recordSession, userOwnsClaudeSession, resetSess
 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 } = require("./media");
+const { send, editMessage, sendVoice, sendVoiceEnd, splitMessage } = require("./io");
+const { textToVoice, splitSentences, synthSentenceMp3 } = require("./media");
 const { killProcessTree } = require("./process-tree");
 const {
   appendProjectTranscript, transcriptProjectInfo,
@@ -1200,8 +1200,20 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
         // input is unwanted noise, so gate it to the voice channel.
         const { currentTransport } = require("./context");
         if (currentTransport() === "voice") {
-          const voicePath = await textToVoice(finalText);
-          if (voicePath) await sendVoice(voicePath);
+          // Stream the spoken reply sentence-by-sentence so the first audio
+          // plays while the rest still synthesizes — far lower time-to-first-
+          // sound than waiting for one TTS pass over the whole reply.
+          const sentences = splitSentences(finalText);
+          let spokeAny = false;
+          for (const sentence of sentences) {
+            const clip = await synthSentenceMp3(sentence);
+            if (clip) { spokeAny = true; await sendVoice(clip); }
+          }
+          if (!spokeAny) {
+            const voicePath = await textToVoice(finalText);
+            if (voicePath) await sendVoice(voicePath);
+          }
+          await sendVoiceEnd();
         }
       }
     } catch (e) {

package/package.json

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