@geravant/sinain 1.23.1 → 1.23.3

package/cli.js

@@ -69,6 +69,13 @@ switch (cmd) {
     break;
   }
 
+  case "setup-embedding": {
+    const { cacheEmbeddingModel } = await import("./setup-embedding.js");
+    const forceUpdate = process.argv.includes("--update");
+    await cacheEmbeddingModel({ forceUpdate });
+    break;
+  }
+
   case "install":
     // --if-openclaw: only run if OpenClaw is installed (for postinstall)
     if (process.argv.includes("--if-openclaw")) {
@@ -400,6 +407,7 @@ Usage:
   sinain setup                 (deprecated — use onboard)
   sinain setup-overlay         Download pre-built overlay app
   sinain setup-sck-capture     Download sck-capture audio binary (macOS)
+  sinain setup-embedding       Pre-cache sentence-transformer model (~90MB)
   sinain export-knowledge      Export knowledge for transfer to another machine
   sinain import-knowledge <file>  Import knowledge from export file
   sinain install               Install OpenClaw plugin (server-side)
@@ -416,6 +424,9 @@ Start options:
 Setup-overlay options:
   --from-source                Build from Flutter source instead of downloading
   --update                     Force re-download even if version matches
+
+Setup-embedding options:
+  --update                     Force re-download even if model is already cached
 `);
 
 }

package/launcher.js

@@ -139,6 +139,17 @@ async function main() {
     }
   }
 
+  // Pre-cache embedding model if not already cached (prevents 10s huggingface.co
+  // download at sinain-core first-startup; skipped silently if SINAIN_SKIP_EMBEDDING_SETUP=1)
+  if (process.env.SINAIN_SKIP_EMBEDDING_SETUP !== "1") {
+    try {
+      const { cacheEmbeddingModel } = await import("./setup-embedding.js");
+      await cacheEmbeddingModel({ silent: true });
+    } catch (e) {
+      warn(`embedding model pre-cache skipped: ${e.message}`);
+    }
+  }
+
   // Start core
   log("Starting sinain-core...");
   const coreDir = path.join(PKG_DIR, "sinain-core");

package/onboard.js

@@ -346,6 +346,27 @@ export async function runOnboard(args = {}) {
 
   await stepOverlay(base);
 
+  // ── Embedding model ───────────────────────────────────────────────────
+  // Pre-cache Xenova/all-MiniLM-L6-v2 (~90MB) so sinain-core startup is
+  // a cache-hit with no network activity. Helps all users, not just paranoid
+  // mode — runtime load goes from ~10s download to <1s cache read.
+
+  {
+    const s = p.spinner();
+    s.start("Pre-caching sentence-transformer model (~90MB)...");
+    try {
+      const { cacheEmbeddingModel } = await import("./setup-embedding.js");
+      await cacheEmbeddingModel({ silent: true });
+      s.stop(c.green("Embedding model cached."));
+    } catch (err) {
+      s.stop(c.yellow(`Embedding model pre-cache skipped: ${err.message}`));
+      p.note(
+        "Run manually: sinain setup-embedding\nOr set SINAIN_SKIP_EMBEDDING_SETUP=1 to skip.",
+        "Embedding",
+      );
+    }
+  }
+
   // ── Health check ──────────────────────────────────────────────────────
 
   await runHealthCheck();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geravant/sinain",
-  "version": "1.23.1",
+  "version": "1.23.3",
   "description": "Ambient intelligence that sees what you see, hears what you hear, and acts on your behalf",
   "type": "module",
   "bin": {
@@ -22,6 +22,7 @@
     "mcp-register.js",
     "setup-overlay.js",
     "setup-sck-capture.js",
+    "setup-embedding.js",
     "pack-prepare.js",
     "install.js",
     "index.ts",

package/setup-embedding.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+// sinain setup-embedding — pre-cache sentence-transformer model at setup time
+//
+// Moves the ~90MB Xenova/all-MiniLM-L6-v2 download from sinain-core's
+// first-startup to install time, keeping runtime fully offline in paranoid mode.
+// Mirrors the style of setup-overlay.js / setup-sck-capture.js.
+
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { createRequire } from "module";
+
+const HOME = os.homedir();
+const MODEL_ID = "Xenova/all-MiniLM-L6-v2";
+
+// sinain-core's node_modules contains @huggingface/transformers — load from there
+// so we use the SAME package instance (and thus the same cache key) as runtime.
+const PKG_DIR = path.dirname(new URL(import.meta.url).pathname);
+const CORE_DIR = path.join(PKG_DIR, "sinain-core");
+
+const BOLD   = "\x1b[1m";
+const GREEN  = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RED    = "\x1b[31m";
+const DIM    = "\x1b[2m";
+const RESET  = "\x1b[0m";
+
+function log(msg)  { console.log(`${BOLD}[setup-embedding]${RESET} ${msg}`); }
+function ok(msg)   { console.log(`${BOLD}[setup-embedding]${RESET} ${GREEN}✓${RESET} ${msg}`); }
+function warn(msg) { console.log(`${BOLD}[setup-embedding]${RESET} ${YELLOW}⚠${RESET} ${msg}`); }
+function fail(msg) { console.error(`${BOLD}[setup-embedding]${RESET} ${RED}✗${RESET} ${msg}`); process.exit(1); }
+
+// ── Entry point (only when run directly, not when imported) ──────────────────
+
+const isMain = process.argv[1] && (
+  import.meta.url === `file://${process.argv[1]}` ||
+  import.meta.url === new URL(process.argv[1], "file://").href
+);
+
+if (isMain) {
+  const args = process.argv.slice(2);
+  const forceUpdate = args.includes("--update");
+  await cacheEmbeddingModel({ forceUpdate });
+}
+
+// ── Resolve cache directory (matches @huggingface/transformers default) ──────
+//
+// @huggingface/transformers stores models under:
+//   $TRANSFORMERS_CACHE  OR
+//   $HF_HOME/hub         OR
+//   ~/.cache/huggingface/hub/
+//
+// We use the same resolution order so setup and runtime share the same cache.
+
+function resolveHfCacheDir() {
+  if (process.env.TRANSFORMERS_CACHE) return process.env.TRANSFORMERS_CACHE;
+  if (process.env.HF_HOME) return path.join(process.env.HF_HOME, "hub");
+  return path.join(HOME, ".cache", "huggingface", "hub");
+}
+
+// Model files land at: <cacheDir>/models--<org>--<name>/snapshots/**
+// A snapshot directory means the model was cached successfully.
+
+function isModelCached() {
+  const cacheDir = resolveHfCacheDir();
+  // Convert "Xenova/all-MiniLM-L6-v2" → "models--Xenova--all-MiniLM-L6-v2"
+  const modelFolder = `models--${MODEL_ID.replace("/", "--")}`;
+  const snapshotsDir = path.join(cacheDir, modelFolder, "snapshots");
+  if (!fs.existsSync(snapshotsDir)) return false;
+  // At least one snapshot sub-directory must exist and not be empty
+  try {
+    const snapshots = fs.readdirSync(snapshotsDir);
+    return snapshots.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+// ── Download / cache the model ───────────────────────────────────────────────
+
+export async function cacheEmbeddingModel({ silent = false, forceUpdate = false } = {}) {
+  const _log = silent ? () => {} : log;
+  const _ok  = silent ? () => {} : ok;
+  const _warn = silent ? () => {} : warn;
+
+  // Skip if already cached and not forcing update
+  if (!forceUpdate && isModelCached()) {
+    _ok(`Embedding model already cached (${MODEL_ID})`);
+    return true;
+  }
+
+  if (forceUpdate && isModelCached()) {
+    _log("Force update requested — re-downloading model...");
+  }
+
+  // Verify sinain-core's node_modules are present (installDeps runs first in launcher)
+  const transformersPath = path.join(CORE_DIR, "node_modules", "@huggingface", "transformers");
+  if (!fs.existsSync(transformersPath)) {
+    const msg = `sinain-core/node_modules not found at ${CORE_DIR}.\n` +
+      `  Run 'npm install' in sinain-core/ first, or let 'sinain start' handle it.`;
+    if (silent) { _warn(msg); return false; }
+    fail(msg);
+  }
+
+  _log(`Downloading sentence-transformer model (~90MB): ${MODEL_ID}`);
+  _log("This may take 30-60 seconds on a slow connection...");
+
+  const cacheDir = resolveHfCacheDir();
+  _log(`${DIM}Cache location: ${cacheDir}${RESET}`);
+
+  try {
+    // Load @huggingface/transformers from sinain-core's node_modules
+    // to guarantee the same module instance (and cache key) as the runtime.
+    const require = createRequire(path.join(CORE_DIR, "package.json"));
+    // Use dynamic import with the resolved path — createRequire gives us the path
+    const transformersEntry = require.resolve("@huggingface/transformers");
+    const { pipeline } = await import(transformersEntry);
+
+    const start = Date.now();
+
+    // Trigger the download by initialising the pipeline — identical call to
+    // EmbeddingService.loadAsync() in sinain-core/src/embedding/service.ts.
+    // When this resolves, the model is cached and subsequent calls (including
+    // sinain-core startup) are cache-hits with no network activity.
+    await pipeline("feature-extraction", MODEL_ID);
+
+    const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+    _ok(`Embedding model cached in ${elapsed}s`);
+
+    if (!silent) {
+      const cacheDir = resolveHfCacheDir();
+      console.log(`
+${GREEN}✓${RESET} Embedding model ready!
+  Model: ${MODEL_ID}
+  Cache: ${cacheDir}
+  sinain-core will load it from cache at startup (no network needed)
+`);
+    }
+    return true;
+  } catch (e) {
+    const isNetworkError =
+      e.message?.includes("fetch") ||
+      e.message?.includes("network") ||
+      e.message?.includes("ENOTFOUND") ||
+      e.message?.includes("ECONNREFUSED") ||
+      e.message?.includes("huggingface") ||
+      e.code === "ENOTFOUND" ||
+      e.code === "ECONNREFUSED";
+
+    if (isNetworkError) {
+      const networkMsg =
+        `Failed to download embedding model from huggingface.co.\n` +
+        `  Check network access. To skip and let runtime download (not recommended\n` +
+        `  for paranoid mode), set SINAIN_SKIP_EMBEDDING_SETUP=1.`;
+      if (silent) { _warn(networkMsg); return false; }
+      fail(networkMsg);
+    }
+
+    const errorMsg = `Embedding model download failed: ${e.message?.slice(0, 200)}`;
+    if (silent) { _warn(errorMsg); return false; }
+    fail(errorMsg);
+  }
+}

package/sinain-core/src/audio/pipeline.ts

@@ -212,6 +212,8 @@ export class AudioPipeline extends EventEmitter {
 
     let headerSkipped = name !== "sox";
     let headerBuf = Buffer.alloc(0);
+    let stderrAccum = "";
+    const spawnTime = Date.now();
 
     proc.stdout?.on("data", (data: Buffer) => {
       if (!this.running) return;
@@ -237,6 +239,12 @@ export class AudioPipeline extends EventEmitter {
       if (msg && !/^In:.*Out:/.test(msg)) {
         log(TAG, `${name} stderr: ${msg.slice(0, 200)}`);
       }
+      // Accumulate stderr for TCC detection on exit
+      stderrAccum += data.toString();
+      // Cap accumulation to avoid unbounded growth (4KB is enough for any TCC message)
+      if (stderrAccum.length > 4096) {
+        stderrAccum = stderrAccum.slice(-4096);
+      }
     });
 
     proc.on("error", (err) => {
@@ -252,6 +260,45 @@ export class AudioPipeline extends EventEmitter {
       if (this.running && code !== 0) {
         this.errorCount++;
         this.profiler?.gauge("audio.errors", this.errorCount);
+
+        // Detect TCC (macOS Screen Recording / Microphone) permission denial.
+        // sck-capture logs "declined TCCs" to stderr when the entitlement is
+        // missing. The chicken-and-egg: clicking "Allow" on the prompt doesn't
+        // apply to a running process — the user must restart Terminal and
+        // re-run. We print a prominent banner and request graceful shutdown
+        // so users aren't left wondering why the agent never escalates.
+        const elapsedMs = Date.now() - spawnTime;
+        const isTccDenial = stderrAccum.includes("declined TCCs");
+        if (isTccDenial && elapsedMs < 5000) {
+          process.stdout.write([
+            "",
+            "=======================================================================",
+            "  WARNING: Screen Recording permission needed",
+            "=======================================================================",
+            "",
+            "  sck-capture cannot access screen capture and audio without",
+            "  TCC (Screen Recording) permission from macOS.",
+            "",
+            "  If you just clicked Allow -- that is normal! macOS does not apply",
+            "  the permission to processes that are already running. To fix:",
+            "",
+            "    1. Press Ctrl+C to stop sinain",
+            "    2. Quit and restart your Terminal app (Cmd+Q, then reopen)",
+            "    3. Run again: npx @geravant/sinain@latest start",
+            "",
+            "  Already declined? Re-grant permission:",
+            "    System Settings > Privacy & Security > Screen Recording",
+            "    > enable Terminal (or your terminal app)",
+            "",
+            "=======================================================================",
+            "",
+          ].join("\n"));
+
+          // Emit TCC-specific error so index.ts can initiate graceful shutdown
+          this.emit("tcc-denied");
+          return;
+        }
+
         warn(TAG, `${name} exited unexpectedly, stopping pipeline`);
         this.stop();
       }

package/sinain-core/src/index.ts

@@ -543,7 +543,14 @@ async function importKnowledgeToLocal(data: string): Promise<string> {
   const dbPath = `${localDir}/knowledge-graph.db`;
 
   const __dir = dirname(fileURLToPath(import.meta.url));
-  const scriptsDir = resolve(__dir, "..", "..", "sinain-hud-plugin", "sinain-memory");
+  // Two package layouts are supported:
+  //   dev/monorepo: <repo>/sinain-core/src/ → ../../sinain-hud-plugin/sinain-memory
+  //   npm-published flat: <pkg>/sinain-core/src/ → ../../sinain-memory
+  const scriptsDir = [
+    resolve(__dir, "..", "..", "sinain-hud-plugin", "sinain-memory"),  // dev/monorepo layout
+    resolve(__dir, "..", "..", "sinain-memory"),                         // npm-published flat layout
+    resolve(__dir, "..", "sinain-memory"),                               // legacy alt
+  ].find(p => existsSync(`${p}/triplestore.py`)) || resolve(__dir, "..", "..", "sinain-memory");
 
   // Convert facts to graph ops for knowledge_integrator
   const graphOps = facts.map((f: any) => ({
@@ -834,6 +841,12 @@ async function main() {
     wsHandler.updateState({ audio: "muted" });
   });
 
+  systemAudioPipeline.on("tcc-denied", () => {
+    // Banner already printed by pipeline.ts. Initiate graceful shutdown so
+    // sinain exits cleanly rather than continuing with audio dead.
+    shutdown("TCC-DENIED").catch(() => process.exit(1));
+  });
+
   systemAudioPipeline.on("muted", () => {
     log(TAG, "system audio muted (capture process still running)");
     wsHandler.updateState({ audio: "muted" });
@@ -1006,6 +1019,23 @@ async function main() {
     }
   }
 
+  // Pre-populate the roster from agents.json profiles so launchers that
+  // don't run the bare-agent process (e.g. start.sh / start-local.sh) still
+  // surface the user's configured profiles in the overlay's agent picker.
+  // When the bare-agent IS running (npm install + cli.js start), its first
+  // /bareagent/register POST narrows the list to PATH-installed binaries —
+  // same final state as before, just with a usable initial state for the
+  // dev-loop launcher.
+  if (escalatorAgentsCfg?.profiles) {
+    const profileNames = Object.keys(escalatorAgentsCfg.profiles)
+      .filter((n) => AGENT_NAME_RE.test(n));
+    if (profileNames.length > 0) {
+      const defaultAgent = escalatorAgentsCfg.default ?? profileNames[0];
+      registerBareAgent(profileNames, defaultAgent);
+      log(TAG, `roster pre-populated from agents.json: ${profileNames.join(",")}`);
+    }
+  }
+
   // ── Create HTTP + WS server ──
   const server = createAppServer({
     config,

package/sinain-core/src/learning/entity-cache.ts

@@ -55,10 +55,14 @@ export class EntityCache {
         return;
       }
 
-      // Query entity names directly via SQLite
+      // Query entity names directly via SQLite.
+      // Two package layouts are supported:
+      //   dev/monorepo: <repo>/sinain-core/src/learning/ → ../../../sinain-hud-plugin/sinain-memory
+      //   npm-published flat: <pkg>/sinain-core/src/learning/ → ../../../sinain-memory
       const scriptCandidates = [
-        resolve(__dir, "..", "..", "sinain-hud-plugin", "sinain-memory", "graph_query.py"),
-        resolve(__dir, "..", "sinain-memory", "graph_query.py"),
+        resolve(__dir, "..", "..", "..", "sinain-hud-plugin", "sinain-memory", "graph_query.py"),  // dev/monorepo layout
+        resolve(__dir, "..", "..", "..", "sinain-memory", "graph_query.py"),                        // npm-published flat layout
+        resolve(__dir, "..", "..", "sinain-memory", "graph_query.py"),                             // legacy alt
       ];
       const scriptPath = scriptCandidates.find(p => existsSync(p));
       if (!scriptPath) return;

package/sinain-core/src/learning/local-curation.ts

@@ -23,18 +23,26 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 
 /** Resolve the sinain-memory Python scripts directory. */
 function resolveScriptsDir(): string {
-  // Look for sinain-memory scripts in known locations
+  // Look for sinain-memory scripts in known locations.
+  // Two package layouts are supported:
+  //   dev/monorepo: <repo>/sinain-core/src/learning/ → ../../../sinain-hud-plugin/sinain-memory
+  //   npm-published flat: <pkg>/sinain-core/src/learning/ → ../../../sinain-memory
   const candidates = [
-    resolve(__dirname, "..", "..", "..", "sinain-hud-plugin", "sinain-memory"),
-    resolve(__dirname, "..", "..", "sinain-memory"),
-    resolve(process.env.HOME || "", ".sinain", "sinain-memory"),
+    resolve(__dirname, "..", "..", "..", "sinain-hud-plugin", "sinain-memory"),  // dev/monorepo layout
+    resolve(__dirname, "..", "..", "..", "sinain-memory"),                         // npm-published flat layout
+    resolve(__dirname, "..", "..", "sinain-memory"),                               // legacy alt
+    resolve(process.env.HOME || "", ".sinain", "sinain-memory"),                  // user-local fallback
   ];
   for (const dir of candidates) {
     if (existsSync(resolve(dir, "session_distiller.py"))) {
       return dir;
     }
   }
-  return candidates[0]; // Fallback
+  error(TAG, `sinain-memory scripts not found. Searched ${candidates.length} locations:`);
+  for (const dir of candidates) {
+    error(TAG, `  - ${dir}`);
+  }
+  return candidates[candidates.length - 1]; // Return user-local path as sentinel
 }
 
 /** Resolve the local memory directory. */