shadok-ai 0.16.29 → 0.16.30

package/README.md

@@ -191,6 +191,13 @@ Enter to skip; you can add it later from the web UI).
   `SHADOK_WHISPER_MODEL` picks a bigger one if your recordings need it.
   Set `SHADOK_WHISPER_DIR` to a directory shared between containers and one copy
   serves them all.
+- **Dictate a prompt on the web** — a 🎙 button beside *Send* records your
+  microphone and transcribes it with the **same local whisper.cpp** the voice
+  notes use (nothing leaves the machine). The text drops into the composer
+  **editable**, never auto-sent, so a misheard word is fixed before it goes —
+  click to start, click to stop, a red timer runs while recording. Needs a
+  secure context (localhost or HTTPS) for the browser to grant the mic; the
+  first use pays the same one-time whisper install as the voice notes above.
 - **Videos on Telegram** — share a video (or a GIF, or a round video note) and
   the agent actually sees it: shadok pulls a handful of stills out of the clip
   for it to look at, and transcribes the sound when there is speech. Both run

package/dist/server.js

@@ -39,6 +39,7 @@ import { getUsage } from "./usage.js";
 import { loadChannels, loadGroups, saveGroups, upsertChannel, removeChannel, mergeClientChannels, channelWriteAllowed, profilePatch, loadTgGroup, saveTgGroup, isHomeChannel, homeAdoptionTarget, resolveSessionTarget, resolveResumeId, resumeTarget, } from "./channels.js";
 import { deliverWithRetry } from "./reload.js";
 import { startTelegram, renameTelegramTopic, closeTelegramTopic, probeToken, isStalePreface, announceLoggedOut, resetLoggedOutNotice, attachmentPrompt, pasteFileName, MEDIA_DIR, } from "./telegram.js";
+import { transcribe, audioClipExtension } from "./whisper.js";
 import { cancelPairingCode, issuePairingCode, pairingStatus } from "./tg-pairing.js";
 import { migrateTgBindings } from "./channels.js";
 import { instanceKey } from "./paths.js";
@@ -1267,6 +1268,50 @@ app.post("/paste", express.raw({ type: () => true, limit: PASTE_LIMIT }), (req,
         res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
     }
 });
+/**
+ * Speech-to-text for the composer's microphone button. The browser records a
+ * short clip (MediaRecorder → webm/opus) and POSTs the raw bytes here; we run
+ * the SAME local whisper.cpp pipeline the Telegram voice path uses
+ * (`transcribe`) and return the text for the client to drop into the composer.
+ *
+ * The text is NEVER auto-sent — it lands in the editable composer so the user
+ * reads it before acting, because a misheard instruction acted on in silence is
+ * worse than a voice note that was ignored (the reason `heardNotice` exists).
+ *
+ * `requestFromBrowser` like `/paste`: this writes a file and records the mic, a
+ * browser-only capability with no business being reachable by a script on
+ * loopback. The clip is TRANSIENT — written to the OS temp dir and removed in
+ * `finally`, never kept in `MEDIA_DIR`: it is spoken input, not a file to hand
+ * the agent.
+ *
+ * The first call on a fresh instance provisions whisper (ffmpeg / model / build
+ * via `ensureWhisper` inside `transcribe`), which can take minutes; the client
+ * shows a working state and we simply wait. The French whisper notices are kept
+ * server-side — the client maps `kind` to its own English UI copy, so the web
+ * stays English while Telegram keeps its spoken-language notices.
+ */
+app.post("/transcribe", express.raw({ type: () => true, limit: PASTE_LIMIT }), async (req, res) => {
+    if (!requestFromBrowser(req))
+        return res.status(403).json({ error: "same-origin browser only" });
+    const body = req.body;
+    if (!Buffer.isBuffer(body) || !body.length)
+        return res.status(400).json({ error: "empty body" });
+    const ext = audioClipExtension(String(req.headers["content-type"] ?? ""));
+    const tmp = path.join(os.tmpdir(), `shadok-stt-${randomUUID()}.${ext}`);
+    try {
+        await fs.promises.writeFile(tmp, body);
+        const out = await transcribe(tmp);
+        if (out.ok)
+            return res.json({ ok: true, text: out.text });
+        return res.json({ ok: false, kind: out.kind });
+    }
+    catch (e) {
+        return res.status(500).json({ ok: false, error: e instanceof Error ? e.message : String(e) });
+    }
+    finally {
+        await fs.promises.rm(tmp, { force: true }).catch(() => { });
+    }
+});
 app.use(express.static(path.join(__dirname, "..", "public")));
 // Markdown parser served locally (history rendering on the client).
 // Resolved through require.resolve, not a hardcoded path: in the npm install