friend-assistant 0.1.41 → 0.1.43

package/dist/friend.mjs

@@ -159,6 +159,14 @@ function resolveVoice(input) {
   if (PLAIN.test(t) && PIPER_NAME.test(t)) return { id: t, label: t, listed: false };
   return null;
 }
+var LISTENING_MODELS = [
+  { id: "tiny", name: "Tiny", mb: 75, note: "fastest, mishears a lot" },
+  { id: "base", name: "Base", mb: 145, note: "fast, struggles with Hindi, Marathi and distance" },
+  { id: "small", name: "Small", mb: 480, note: "recommended: much better, still quick" },
+  { id: "medium", name: "Medium", mb: 1500, note: "better again, slow on a PC without a graphics card" },
+  { id: "large-v3-turbo", name: "Large (turbo)", mb: 1600, note: "most accurate for Marathi; needs a fast PC" }
+];
+var downloadSize = (mb) => `about ${mb >= 1e3 ? `${(mb / 1e3).toFixed(1)} GB` : `${mb} MB`}`;
 
 // ../protocol/src/themes.ts
 var THEMES = [
@@ -4792,6 +4800,53 @@ var ChromePlugin = class {
     });
     return this.serving;
   }
+  /** Runs one of Chrome control's own commands that answer with a line of JSON. */
+  async ask(command) {
+    const entry = this.deps.bundled;
+    if (!entry) return null;
+    const r = await this.deps.run(process.execPath, [entry, command]);
+    const line = r.stdout.split(/\r?\n/).reverse().find((l) => l.trim().startsWith("{"));
+    if (!line) return null;
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
+    }
+  }
+  /** Whether the open Chrome has the flag that hides the banner, and how many shortcuts do. Changes nothing. */
+  async bannerStatus() {
+    if (!this.deps.bundled) return { supported: false };
+    const s = await this.ask("flag-status").catch(() => null);
+    if (!s || typeof s.running !== "boolean") return { supported: true, error: "Could not read Chrome's state." };
+    const sc = s.shortcuts;
+    return {
+      supported: true,
+      platform: String(s.platform ?? ""),
+      running: s.running,
+      hidden: typeof s.hidden === "boolean" ? s.hidden : null,
+      shortcuts: sc && typeof sc.total === "number" ? { withFlag: sc.withFlag ?? 0, total: sc.total } : null
+    };
+  }
+  /** Adds the flag to the Chrome shortcuts. It takes effect the next time Chrome starts. */
+  async hideBanner() {
+    if (!this.deps.bundled) return { ok: false, message: "This Friend has no copy of Chrome control to do that." };
+    const r = await this.ask("flag").catch(() => null);
+    const c = r?.counts;
+    if (!r || !c) return { ok: false, message: "Could not change the shortcuts." };
+    const patched = c.patched ?? 0;
+    const failed = c.failed ?? 0;
+    const already = c.already ?? 0;
+    if (r.ok !== true) return { ok: false, patched, failed, message: failed ? "Windows would not let Friend change those shortcuts (shared ones may need an administrator)." : "No Chrome shortcut was found to change." };
+    const bits = [patched ? `Added the flag to ${patched} shortcut${patched === 1 ? "" : "s"}.` : "", already ? `${already} already had it.` : "", failed ? `${failed} could not be changed (shared ones may need an administrator).` : ""].filter(Boolean);
+    return { ok: true, patched, failed, message: `${bits.join(" ")} It counts when Chrome starts: if Chrome is open now, restart it.` };
+  }
+  /** Closes Chrome politely and starts it again with the flag and the tabs back. */
+  async restartChrome() {
+    if (!this.deps.bundled) return { ok: false, message: "This Friend has no copy of Chrome control to do that." };
+    const r = await this.ask("chrome-restart").catch(() => null);
+    if (!r || typeof r.ok !== "boolean") return { ok: false, message: "Could not restart Chrome." };
+    return { ok: r.ok, message: String(r.message ?? (r.ok ? "Chrome was restarted." : "Chrome was not restarted.")) };
+  }
   /** Switches the connector off but keeps it listed. */
   async disconnect() {
     if (!this.deps.hub.list().some((c) => c.id === ID)) return;
@@ -11537,6 +11592,18 @@ function createGateway(deps) {
         return pluginError(reply, e, "chrome.remote");
       }
     });
+    app.get("/api/plugins/chrome/banner", { onRequest: pluginGuard }, async () => chrome.banner());
+    app.post("/api/plugins/chrome/banner/:what", { onRequest: pluginGuard }, async (req, reply) => {
+      const what = z10.enum(["hide", "restart"]).safeParse(req.params.what);
+      const body = z10.object({ pin: z10.string().min(1).max(32) }).safeParse(req.body);
+      if (!what.success) return reply.code(404).send({ error: "Not found" });
+      if (!body.success) return reply.code(400).send({ error: "Enter your PIN" });
+      try {
+        return await chrome.bannerAct(what.data, body.data.pin, req.ip);
+      } catch (e) {
+        return pluginError(reply, e, `chrome.banner_${what.data}`);
+      }
+    });
     app.post("/api/plugins/chrome/token", { onRequest: pluginGuard }, async (req, reply) => {
       const body = z10.object({ pin: z10.string().min(1).max(32) }).safeParse(req.body);
       if (!body.success) return reply.code(400).send({ error: "Enter your PIN" });
@@ -12970,7 +13037,7 @@ function refuseForAgent(raw) {
   if ("command" in cc) throw new SettingsError("The Claude Code command can only be changed by the owner on the settings screen.");
 }
 var PROVIDER_KEYS = /* @__PURE__ */ new Set(["provider", "model", "apiKey", "ollama", "openai", "claudeCode"]);
-var RESTART_VOICE = ["enabled", "sttModel"];
+var RESTART_VOICE = ["enabled"];
 function applySettings(config, raw) {
   const parsed = SettingsPatch.safeParse(raw);
   if (!parsed.success) {
@@ -13852,7 +13919,11 @@ var HttpVoiceService = class {
     });
     return Buffer.from(await res.arrayBuffer());
   }
-  async request(path3, init) {
+  /** Loading a model the first time downloads it (up to about 1.6 GB), so this waits far longer than a normal request. */
+  async useListeningModel(name) {
+    await this.request("/stt-model", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ model: name }) }, 30 * 6e4);
+  }
+  async request(path3, init, timeoutMs) {
     const base = this.opts.baseUrl();
     if (!base) throw new VoiceError("the voice sidecar is not running");
     let res;
@@ -13860,7 +13931,7 @@ var HttpVoiceService = class {
       res = await fetch(base + path3, {
         ...init,
         headers: { ...init.headers, authorization: `Bearer ${this.opts.token}` },
-        signal: AbortSignal.timeout(this.opts.timeoutMs ?? 6e4)
+        signal: AbortSignal.timeout(timeoutMs ?? this.opts.timeoutMs ?? 6e4)
       });
     } catch (e) {
       if (e.name === "TimeoutError") throw new VoiceError("the voice sidecar timed out");
@@ -14379,6 +14450,7 @@ async function createApp(opts) {
   function commitSettings(patch, how) {
     let applied;
     let voiceBefore = config.voice.ttsVoice;
+    let sttBefore = config.voice.sttModel;
     try {
       const saved = loadConfig(opts.dataDir);
       const check3 = applySettings(saved, patch);
@@ -14386,6 +14458,7 @@ async function createApp(opts) {
         throw new HttpError(409, "Friend is busy with a request. Change the model when it is done.");
       }
       voiceBefore = config.voice.ttsVoice;
+      sttBefore = config.voice.sttModel;
       applied = applySettings(config, patch);
       saveConfig(saved);
     } catch (e) {
@@ -14411,6 +14484,7 @@ async function createApp(opts) {
       else swap();
     }
     if (applied.changed.includes("voice.ttsVoice")) void warmVoice(config.voice.ttsVoice, voiceBefore);
+    if (applied.changed.includes("voice.sttModel")) void warmListening(config.voice.sttModel, sttBefore);
     if (applied.changed.includes("voice.hindiVoice")) void warmLanguageVoice(config.voice.hindiVoice);
     if (applied.changed.includes("voice.marathiVoice")) void warmLanguageVoice(config.voice.marathiVoice);
     if (applied.changed.some((k) => k === "view" || k === "ownerName" || k.startsWith("look.") || k.startsWith("hud") || k.startsWith("music"))) {
@@ -14437,6 +14511,25 @@ async function createApp(opts) {
       broadcast({ type: "alert", level: "warn", text: `Could not load the voice ${wanted} (it needs internet the first time). Using ${voiceLabel(previous)} again.` });
     }
   }
+  async function warmListening(wanted, previous) {
+    if (!voice2?.useListeningModel || !voiceAvailable()) return;
+    const known = LISTENING_MODELS.find((m) => m.id === wanted);
+    const download = known ? ` (${downloadSize(known.mb)} the first time it is downloaded)` : ". The first time it downloads";
+    broadcast({ type: "alert", level: "info", text: `Getting the listening model ${wanted}${download}. Friend keeps listening with the old one meanwhile.` });
+    try {
+      await voice2.useListeningModel(wanted);
+      broadcast({ type: "alert", level: "info", text: `The listening model ${wanted} is ready.` });
+    } catch (e) {
+      audit.log("system", "voice.model_failed", { model: wanted, message: e.message });
+      if (config.voice.sttModel === wanted) {
+        config.voice.sttModel = previous;
+        const saved = loadConfig(opts.dataDir);
+        saved.voice.sttModel = previous;
+        saveConfig(saved);
+      }
+      broadcast({ type: "alert", level: "warn", text: `Could not load the listening model ${wanted} (it needs internet the first time). Using ${previous} again.` });
+    }
+  }
   async function warmLanguageVoice(wanted) {
     if (!wanted || !voice2 || !voiceAvailable()) return;
     broadcast({ type: "alert", level: "info", text: `Loading the voice ${voiceLabel(wanted)}. The first time it downloads about 64 MB.` });
@@ -14818,6 +14911,12 @@ async function createApp(opts) {
       if (enabled) void chromeRemoteApi.ensureServer().catch(() => {
       });
     },
+    banner: () => chromePlugin.bannerStatus(),
+    bannerAct: async (what, pin, ip) => {
+      await requirePin(pin, ip);
+      audit.log("owner", what === "hide" ? "chrome.banner_hide" : "chrome.banner_restart", { ip });
+      return what === "hide" ? chromePlugin.hideBanner() : chromePlugin.restartChrome();
+    },
     revealToken: async (pin, ip) => {
       await requirePin(pin, ip);
       const key = chromeToken(opts.quick?.home);
@@ -17844,7 +17943,7 @@ async function daemonCommand(args, io2, deps = realDeps) {
 import crossSpawn5 from "cross-spawn";
 var PACKAGE = "friend-assistant";
 var real = {
-  current: () => true ? "0.1.41" : "development",
+  current: () => true ? "0.1.43" : "development",
   latest: () => new Promise((resolve13) => {
     const child = crossSpawn5("npm", ["view", PACKAGE, "version", "--prefer-online"], { stdio: ["ignore", "pipe", "ignore"] });
     let out = "";
@@ -18132,7 +18231,7 @@ async function run(argv, io2) {
       case "version":
       case "--version":
       case "-v":
-        io2.out(true ? "0.1.41" : "development");
+        io2.out(true ? "0.1.43" : "development");
         return 0;
       case "lan":
         return await lanCommand(rest, io2);

package/dist/voice/friend_voice/__main__.py

@@ -32,7 +32,13 @@ def main() -> int:
 
         engines = load_engines(args.data_dir, args.stt_model, args.tts_voice)
 
-    server, port = make_server(engines, token, port=args.port)
+    if args.fake:
+        loader = lambda name: FakeEngines().stt  # noqa: E731
+    else:
+        from .models import load_stt
+
+        loader = lambda name: load_stt(args.data_dir, name)  # noqa: E731
+    server, port = make_server(engines, token, port=args.port, load_stt=loader)
     print(json.dumps({"ready": True, "port": port}), flush=True)
 
     # When the parent process goes away its end of our stdin closes: shut down instead of lingering.

package/dist/voice/friend_voice/models.py

@@ -46,6 +46,12 @@ def ensure_speaker_model(directory: Path, url: str = SPEAKER_URL, sha256: str =
     return target
 
 
+def load_stt(data_dir: Optional[str], name: str) -> WhisperSTT:
+    """One listening model, downloaded into the models folder when it is not there yet."""
+    root = Path(data_dir) if data_dir else Path.home() / ".friend" / "voice" / "models"
+    return WhisperSTT(name, str(root / "whisper"))
+
+
 def load_engines(data_dir: Optional[str], stt_model: str = "small", tts_voice: str = "en_US-lessac-medium") -> Engines:
     root = Path(data_dir) if data_dir else Path.home() / ".friend" / "voice" / "models"
     root.mkdir(parents=True, exist_ok=True)

package/dist/voice/friend_voice/server.py

@@ -4,20 +4,33 @@ from __future__ import annotations
 
 import hmac
 import json
+import re
+import threading
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-from typing import Tuple
+from typing import Callable, Optional, Tuple
 from urllib.parse import parse_qs, urlparse
 
 from .engines import Engines
 from .tts import check_voice_name
 
 MAX_TTS_CHARS = 2000
+#: What a listening model is called: tiny, base, small, large-v3-turbo, or a Hugging Face folder such as Systran/faster-whisper-small.
+MODEL_NAME = re.compile(r"^[A-Za-z0-9_./-]{1,80}$")
 
 
 def make_server(
-    engines: Engines, token: str, port: int = 0, max_body: int = 4_000_000, io_timeout: float = 30
+    engines: Engines,
+    token: str,
+    port: int = 0,
+    max_body: int = 4_000_000,
+    io_timeout: float = 30,
+    load_stt: Optional[Callable[[str], object]] = None,
 ) -> Tuple[ThreadingHTTPServer, int]:
-    """Create (but do not start) a server bound to 127.0.0.1. Returns (server, actual_port)."""
+    """Create (but do not start) a server bound to 127.0.0.1. Returns (server, actual_port).
+
+    `load_stt(name)` builds (and, the first time, downloads) a listening model; POST /stt-model swaps it in while running.
+    """
+    swapping = threading.Lock()  # one model change at a time
 
     class Handler(BaseHTTPRequestHandler):
         protocol_version = "HTTP/1.1"
@@ -85,6 +98,8 @@ def make_server(
                 return self._tts()
             if url.path == "/embed":
                 return self._embed()
+            if url.path == "/stt-model":
+                return self._stt_model()
             self._drain(64 * 1024)
             self._json(404, {"error": "not found"}, close=True)
 
@@ -118,6 +133,26 @@ def make_server(
             except Exception as e:  # engine failures are reported, never crash the server
                 self._json(500, {"error": str(e)})
 
+        def _stt_model(self) -> None:
+            raw = self._read_body()
+            if raw is None:
+                return
+            if load_stt is None:
+                return self._json(501, {"error": "this speech engine cannot change its listening model"})
+            try:
+                name = json.loads(raw)["model"]
+            except (ValueError, KeyError, TypeError):
+                return self._json(400, {"error": "expected JSON with a model field"})
+            if not isinstance(name, str) or not MODEL_NAME.match(name) or ".." in name:
+                return self._json(400, {"error": "that is not a listening model name"})
+            with swapping:
+                try:
+                    fresh = load_stt(name)  # may take minutes the first time (download); the old model keeps listening meanwhile
+                except Exception as e:
+                    return self._json(500, {"error": str(e) or "the listening model could not be loaded"})
+                engines.stt = fresh
+            self._json(200, {"ok": True, "model": name})
+
         def _embed(self) -> None:
             audio = self._read_body()
             if audio is None: