@geravant/sinain 1.23.2 → 1.23.4

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,7 +1,7 @@
 {
   "name": "@geravant/sinain",
-  "version": "1.23.2",
-  "description": "Ambient intelligence that sees what you see, hears what you hear, and acts on your behalf",
+  "version": "1.23.4",
+  "description": "Context OS — captures what you see and hear, distills it into a private knowledge graph for AI-powered work",
   "type": "module",
   "bin": {
     "sinain": "./cli.js",
@@ -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-agent/agents.example.json

@@ -53,10 +53,10 @@
   "agentMaxTurns": 8,
   "spawnMaxTurns": 25,
 
-  "allowedTools": "mcp__sinain",
+  "allowedTools": "mcp__sinain ToolSearch",
   "escAllowedTools": "${allowedTools} Bash(git:*) Edit Write Read Glob Grep LS",
   "spawnAllowedTools": "${allowedTools} Bash(git:*) Edit Write Read Glob Grep LS",
-  "autoApproveTools": "Read Glob Grep Ls Cat mcp__sinain*",
+  "autoApproveTools": "Read Glob Grep Ls Cat mcp__sinain* ToolSearch",
 
   "analyzer": {
     "debounceMs": 6000,

package/sinain-agent/run.sh

@@ -259,6 +259,12 @@ invoke_agent() {
           # still routes each call to the overlay for user Allow/Deny. Widen the
           # whitelist so the hook can do its job. Override via SINAIN_SPAWN_ALLOWED_TOOLS.
           local spawn_allowed="${SINAIN_SPAWN_ALLOWED_TOOLS:-${ALLOWED_TOOLS} Bash(git:*) Edit Write Read Glob Grep LS}"
+          # ToolSearch is a built-in Claude Code uses to load deferred MCP tool
+          # schemas. Without it pre-approved, every escalation that needs an
+          # un-cached sinain_* tool triggers a permission prompt — Test Mac
+          # hit this on overlay-v1.24.5 (~4 prompts per 7min). Always include
+          # regardless of agents.json content (defense-in-depth).
+          spawn_allowed="$spawn_allowed ToolSearch"
           if [ "$quiet" = "true" ]; then
             "$bin" \
               --mcp-config "$MCP_CONFIG" \
@@ -278,6 +284,9 @@ invoke_agent() {
         else
           # Escalation path. Override via SINAIN_ESC_ALLOWED_TOOLS.
           local esc_allowed="${SINAIN_ESC_ALLOWED_TOOLS:-${ALLOWED_TOOLS} Bash(git:*) Edit Write Read Glob Grep LS}"
+          # See spawn_allowed comment above — ToolSearch must be pre-approved
+          # or every escalation triggers a permission prompt.
+          esc_allowed="$esc_allowed ToolSearch"
           if [ "$quiet" = "true" ]; then
             "$bin" \
               --mcp-config "$MCP_CONFIG" \

package/sinain-core/src/index.ts

@@ -1019,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,