@geravant/sinain 1.8.0 → 1.10.0

package/config.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+/**
+ * sinain config — interactive section-based config editor.
+ * Edit individual settings without re-running the full onboard wizard.
+ */
+import * as p from "@clack/prompts";
+import {
+  c, guard, readEnv, writeEnv, summarizeConfig, runHealthCheck,
+  stepApiKey, stepTranscription, stepGateway, stepPrivacy, stepModel, stepAgent,
+  ENV_PATH, IS_WINDOWS, HOME, PKG_DIR,
+} from "./config-shared.js";
+import fs from "fs";
+import path from "path";
+
+// ── Section definitions ────────────────────────────────────────────────────
+
+const SECTIONS = [
+  { value: "apikey",        label: "API Key",        hint: "OpenRouter API key" },
+  { value: "transcription", label: "Transcription",  hint: "Cloud or local whisper" },
+  { value: "model",         label: "Model",          hint: "AI model for analysis" },
+  { value: "privacy",       label: "Privacy",        hint: "Standard / strict / paranoid" },
+  { value: "gateway",       label: "Gateway",        hint: "OpenClaw connection" },
+  { value: "agent",         label: "Agent",          hint: "Claude / Codex / Goose / ..." },
+  { value: "health",        label: "Health check",   hint: "Test core + gateway status" },
+];
+
+// ── Section handlers ───────────────────────────────────────────────────────
+
+async function runSection(section, existing) {
+  switch (section) {
+    case "apikey": {
+      const key = await stepApiKey(existing);
+      return { OPENROUTER_API_KEY: key };
+    }
+    case "transcription": {
+      const backend = await stepTranscription(existing);
+      const vars = { TRANSCRIPTION_BACKEND: backend };
+      if (backend === "local") {
+        const modelDir = path.join(HOME, "models");
+        const modelPath = path.join(modelDir, "ggml-large-v3-turbo.bin");
+        if (fs.existsSync(modelPath)) {
+          vars.LOCAL_WHISPER_MODEL = modelPath;
+        }
+      }
+      return vars;
+    }
+    case "model": {
+      const model = await stepModel(existing);
+      return { AGENT_MODEL: model };
+    }
+    case "privacy": {
+      const mode = await stepPrivacy(existing);
+      return { PRIVACY_MODE: mode };
+    }
+    case "gateway": {
+      return await stepGateway(existing);
+    }
+    case "agent": {
+      const agent = await stepAgent(existing);
+      return { SINAIN_AGENT: agent };
+    }
+    case "health": {
+      await runHealthCheck();
+      return null; // no vars to write
+    }
+  }
+}
+
+// ── List command ────────────────────────────────────────────────────────────
+
+function printConfigList(existing) {
+  const lines = summarizeConfig(existing);
+  if (lines.length === 0) {
+    console.log(c.dim("  No config found. Run: sinain onboard"));
+  } else {
+    console.log();
+    console.log(c.bold("  Current config") + c.dim(` (${ENV_PATH})`));
+    console.log();
+    for (const line of lines) console.log(`  ${line}`);
+    console.log();
+  }
+}
+
+// ── Main ───────────────────────────────────────────────────────────────────
+
+async function runConfigWizard(sectionsFilter) {
+  p.intro("sinain config");
+
+  const existing = readEnv();
+  if (Object.keys(existing).length === 0) {
+    p.log.warn("No config found. Run sinain onboard first.");
+    p.outro("sinain onboard");
+    return;
+  }
+
+  p.note(summarizeConfig(existing).join("\n"), "Current config");
+
+  // If specific sections requested via --sections, run just those
+  if (sectionsFilter && sectionsFilter.length > 0) {
+    for (const section of sectionsFilter) {
+      const vars = await runSection(section, existing);
+      if (vars) {
+        Object.assign(existing, vars);
+        writeEnv(existing);
+        p.log.success(`${section} updated.`);
+      }
+    }
+    p.outro("Done.");
+    return;
+  }
+
+  // Interactive loop
+  while (true) {
+    const choice = guard(await p.select({
+      message: "What to configure?",
+      options: [
+        ...SECTIONS,
+        { value: "__done", label: "Done", hint: "Save and exit" },
+      ],
+    }));
+
+    if (choice === "__done") break;
+
+    const vars = await runSection(choice, existing);
+    if (vars) {
+      Object.assign(existing, vars);
+      writeEnv(existing);
+      p.log.success(`${choice} updated.`);
+    }
+  }
+
+  p.outro("Config saved.");
+}
+
+// ── CLI entry point ────────────────────────────────────────────────────────
+
+const args = process.argv.slice(3); // skip node, cli.js, "config"
+
+if (args[0] === "list" || args[0] === "ls") {
+  printConfigList(readEnv());
+} else {
+  let sectionsFilter = null;
+  for (const arg of args) {
+    if (arg.startsWith("--sections=")) {
+      sectionsFilter = arg.slice(11).split(",").filter(Boolean);
+    }
+  }
+  runConfigWizard(sectionsFilter).catch((err) => {
+    console.error(c.red(`  Error: ${err.message}`));
+    process.exit(1);
+  });
+}

package/index.ts

@@ -8,7 +8,7 @@
  * - Strips <private> tags from tool results before persistence
  */
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync, statSync, chmodSync, copyFileSync } from "node:fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, statSync, copyFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 
@@ -358,8 +358,6 @@ export default function sinainHudPlugin(api: OpenClawPluginApi): void {
       const memorySource = cfg.memoryPath ? api.resolvePath(cfg.memoryPath) : undefined;
       if (memorySource) {
         store.deployDir(memorySource, "sinain-memory");
-        const gbPath = join(workspaceDir, "sinain-memory", "git_backup.sh");
-        if (existsSync(gbPath)) try { chmodSync(gbPath, 0o755); } catch {}
       }
 
       const modulesSource = cfg.modulesPath ? api.resolvePath(cfg.modulesPath) : undefined;

package/launcher.js

@@ -685,7 +685,13 @@ function loadUserEnv() {
       const eq = trimmed.indexOf("=");
       if (eq === -1) continue;
       const key = trimmed.slice(0, eq).trim();
-      const val = trimmed.slice(eq + 1).trim().replace(/^["']|["']$/g, "");
+      let val = trimmed.slice(eq + 1).trim();
+      if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+        val = val.slice(1, -1);
+      } else {
+        const ci = val.search(/\s+#/);
+        if (ci !== -1) val = val.slice(0, ci).trimEnd();
+      }
       // Don't override existing env vars
       if (!process.env[key]) {
         process.env[key] = val;

package/onboard.js

@@ -0,0 +1,345 @@
+#!/usr/bin/env node
+/**
+ * sinain onboard — interactive setup wizard using @clack/prompts
+ * Modeled after `openclaw onboard` for a familiar, polished experience.
+ */
+import * as p from "@clack/prompts";
+import fs from "fs";
+import path from "path";
+import { execFileSync } from "child_process";
+import {
+  c, guard, maskKey, readEnv, writeEnv, summarizeConfig, runHealthCheck,
+  stepApiKey, stepTranscription, stepGateway, stepPrivacy, stepModel,
+  HOME, SINAIN_DIR, ENV_PATH, PKG_DIR, IS_WINDOWS, IS_MAC,
+} from "./config-shared.js";
+
+// ── Header ──────────────────────────────────────────────────────────────────
+
+function printHeader() {
+  console.log();
+  console.log(c.bold("  ┌─────────────────────────────────────────┐"));
+  console.log(c.bold("  │                                         │"));
+  console.log(c.bold("  │") + c.cyan("    ╔═╗╦╔╗╔╔═╗╦╔╗╔  ╦ ╦╦ ╦╔╦╗        ") + c.bold("│"));
+  console.log(c.bold("  │") + c.cyan("    ╚═╗║║║║╠═╣║║║║  ╠═╣║ ║ ║║        ") + c.bold("│"));
+  console.log(c.bold("  │") + c.cyan("    ╚═╝╩╝╚╝╩ ╩╩╝╚╝  ╩ ╩╚═╝═╩╝        ") + c.bold("│"));
+  console.log(c.bold("  │") + c.dim("      Privacy-first AI overlay          ") + c.bold("│"));
+  console.log(c.bold("  │                                         │"));
+  console.log(c.bold("  └─────────────────────────────────────────┘"));
+  console.log();
+}
+
+// ── Steps (imported from config-shared.js) ──────────────────────────────────
+// stepApiKey, stepTranscription, stepGateway, stepPrivacy, stepModel
+// are imported above and accept an optional label parameter.
+
+async function stepOverlay(existing) {
+  // Check if overlay is already installed
+  const overlayPaths = [
+    path.join(SINAIN_DIR, "overlay", "SinainHUD.app"),
+    path.join(SINAIN_DIR, "overlay", "sinain_hud.exe"),
+  ];
+  const overlayInstalled = overlayPaths.some((p) => fs.existsSync(p));
+
+  const choice = guard(await p.select({
+    message: "Install overlay",
+    options: [
+      {
+        value: "download",
+        label: "Download pre-built app (recommended)",
+        hint: "No Flutter SDK needed",
+      },
+      {
+        value: "source",
+        label: "Build from source",
+        hint: "Requires Flutter SDK",
+      },
+      {
+        value: "skip",
+        label: overlayInstalled ? "Skip (already installed)" : "Skip for now",
+        hint: overlayInstalled ? "SinainHUD.app detected" : "Install later: sinain setup-overlay",
+      },
+    ],
+    initialValue: overlayInstalled ? "skip" : "download",
+  }));
+
+  if (choice === "download" || choice === "source") {
+    const s = p.spinner();
+    const label = choice === "download" ? "Downloading overlay..." : "Building overlay from source...";
+    s.start(label);
+    try {
+      // setup-overlay.js handles both modes via process.argv
+      if (choice === "source") process.argv.push("--from-source");
+      await import("./setup-overlay.js");
+      s.stop(c.green("Overlay installed."));
+    } catch (err) {
+      s.stop(c.yellow(`Failed: ${err.message}`));
+      p.note("Install manually: sinain setup-overlay", "Overlay");
+    }
+  }
+}
+
+// ── Main ────────────────────────────────────────────────────────────────────
+
+export async function runOnboard(args = {}) {
+  printHeader();
+  p.intro("SinainHUD setup");
+
+  const existing = readEnv(ENV_PATH);
+  const hasExisting = Object.keys(existing).length > 0;
+
+  // ── Existing config handling ────────────────────────────────────────────
+
+  let configAction = "fresh";
+  if (hasExisting) {
+    p.note(summarizeConfig(existing).join("\n"), "Existing config detected");
+
+    configAction = guard(await p.select({
+      message: "Config handling",
+      options: [
+        { value: "keep", label: "Use existing values" },
+        { value: "update", label: "Update values" },
+        { value: "reset", label: "Reset (start fresh)" },
+      ],
+      initialValue: "keep",
+    }));
+
+    if (configAction === "keep") {
+      p.log.success("Using existing configuration.");
+      await stepOverlay(existing);
+      await runHealthCheck();
+      printOutro();
+      return;
+    }
+
+    if (configAction === "reset") {
+      fs.unlinkSync(ENV_PATH);
+      p.log.info("Config reset.");
+    }
+  }
+
+  const base = configAction === "update" ? existing : {};
+
+  // ── Flow selection ──────────────────────────────────────────────────────
+
+  const flow = args.flow || guard(await p.select({
+    message: "Setup mode",
+    options: [
+      {
+        value: "quickstart",
+        label: "QuickStart",
+        hint: "Get running in 2 minutes. Configure details later.",
+      },
+      {
+        value: "advanced",
+        label: "Advanced",
+        hint: "Full control over privacy, models, and connections.",
+      },
+    ],
+    initialValue: "quickstart",
+  }));
+
+  const totalSteps = flow === "quickstart" ? 2 : 5;
+
+  // ── Collect vars ────────────────────────────────────────────────────────
+
+  const vars = { ...base };
+
+  // Step 1: API key (both flows)
+  const apiKey = await stepApiKey(base, `[1/${totalSteps}] OpenRouter API key`);
+  vars.OPENROUTER_API_KEY = apiKey;
+  p.log.success("API key saved.");
+
+  if (flow === "quickstart") {
+    // QuickStart: sensible defaults
+    vars.TRANSCRIPTION_BACKEND = base.TRANSCRIPTION_BACKEND || "openrouter";
+    vars.PRIVACY_MODE = base.PRIVACY_MODE || "standard";
+    vars.AGENT_MODEL = base.AGENT_MODEL || "google/gemini-2.5-flash-lite";
+    vars.ESCALATION_MODE = base.ESCALATION_MODE || "off";
+    vars.SINAIN_AGENT = base.SINAIN_AGENT || "claude";
+    if (!vars.OPENCLAW_WS_URL) {
+      vars.OPENCLAW_WS_URL = "";
+      vars.OPENCLAW_HTTP_URL = "";
+    }
+
+    p.note(
+      [
+        `Transcription: ${vars.TRANSCRIPTION_BACKEND}`,
+        `Privacy: ${vars.PRIVACY_MODE}`,
+        `Model: ${vars.AGENT_MODEL}`,
+        `Escalation: ${vars.ESCALATION_MODE}`,
+        "",
+        `Change later: sinain config`,
+      ].join("\n"),
+      "QuickStart defaults",
+    );
+  } else {
+    // Advanced flow: steps 2-5
+    const transcription = await stepTranscription(base, "[2/5] Audio transcription");
+    vars.TRANSCRIPTION_BACKEND = transcription;
+    p.log.success(`Using ${transcription === "openrouter" ? "cloud" : "local"} transcription.`);
+
+    if (transcription === "local") {
+      const modelDir = path.join(HOME, "models");
+      const modelPath = path.join(modelDir, "ggml-large-v3-turbo.bin");
+      if (!fs.existsSync(modelPath)) {
+        const download = guard(await p.confirm({
+          message: "Download Whisper model (~1.5 GB)?",
+          initialValue: true,
+        }));
+        if (download) {
+          const s = p.spinner();
+          s.start("Downloading Whisper model...");
+          try {
+            fs.mkdirSync(modelDir, { recursive: true });
+            execFileSync("curl", [
+              "-L", "--progress-bar",
+              "-o", modelPath,
+              "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-v3-turbo.bin",
+            ], { stdio: "inherit" });
+            s.stop(c.green("Model downloaded."));
+            vars.LOCAL_WHISPER_MODEL = modelPath;
+          } catch {
+            s.stop(c.yellow("Download failed. You can download manually later."));
+          }
+        }
+      } else {
+        vars.LOCAL_WHISPER_MODEL = modelPath;
+        p.log.info(`Whisper model found: ${c.dim(modelPath)}`);
+      }
+    }
+
+    const gatewayVars = await stepGateway(base, "[3/5] OpenClaw gateway");
+    Object.assign(vars, gatewayVars);
+    if (gatewayVars.ESCALATION_MODE === "off") {
+      p.log.info("Standalone mode (no gateway).");
+    } else {
+      p.log.success("Gateway configured.");
+    }
+
+    const privacy = await stepPrivacy(base, "[4/5] Privacy mode");
+    vars.PRIVACY_MODE = privacy;
+    p.log.success(`Privacy: ${privacy}.`);
+
+    const model = await stepModel(base, "[5/5] AI model for HUD analysis");
+    vars.AGENT_MODEL = model;
+    p.log.success(`Model: ${model}.`);
+
+    vars.SINAIN_AGENT = base.SINAIN_AGENT || "claude";
+  }
+
+  // ── Common defaults ───────────────────────────────────────────────────
+
+  vars.SINAIN_CORE_URL = vars.SINAIN_CORE_URL || "http://localhost:9500";
+  vars.SINAIN_POLL_INTERVAL = vars.SINAIN_POLL_INTERVAL || "5";
+  vars.SINAIN_HEARTBEAT_INTERVAL = vars.SINAIN_HEARTBEAT_INTERVAL || "900";
+  vars.AUDIO_CAPTURE_CMD = vars.AUDIO_CAPTURE_CMD || "screencapturekit";
+  vars.AUDIO_AUTO_START = vars.AUDIO_AUTO_START || "true";
+  vars.PORT = vars.PORT || "9500";
+
+  // ── Write config ──────────────────────────────────────────────────────
+
+  const s = p.spinner();
+  s.start("Writing configuration...");
+  writeEnv(vars);
+  s.stop(c.green(`Config saved: ${c.dim(ENV_PATH)}`));
+
+  // ── Overlay ───────────────────────────────────────────────────────────
+
+  await stepOverlay(base);
+
+  // ── Health check ──────────────────────────────────────────────────────
+
+  await runHealthCheck();
+
+  // ── What now ──────────────────────────────────────────────────────────
+
+  printOutro();
+
+  // ── Start? ────────────────────────────────────────────────────────────
+
+  const startNow = guard(await p.confirm({
+    message: "Start sinain now?",
+    initialValue: true,
+  }));
+
+  if (startNow) {
+    p.outro("Launching sinain...");
+    try {
+      await import("./launcher.js");
+    } catch (err) {
+      console.log(c.yellow(`  Launch failed: ${err.message}`));
+      console.log(c.dim("  Try manually: sinain start"));
+    }
+  } else {
+    p.outro("Run when ready: sinain start");
+  }
+}
+
+function printOutro() {
+  const hotkey = IS_WINDOWS ? "Ctrl+Shift" : "Cmd+Shift";
+  p.note(
+    [
+      "Hotkeys:",
+      `  ${hotkey}+Space — Show/hide overlay`,
+      `  ${hotkey}+E     — Cycle tabs (Stream → Agent → Tasks)`,
+      `  ${hotkey}+C     — Toggle click-through`,
+      `  ${hotkey}+M     — Cycle display mode`,
+      "",
+      "Docs: https://github.com/geravant/sinain-hud",
+      "Re-run: sinain onboard (or sinain onboard --advanced)",
+    ].join("\n"),
+    "What now",
+  );
+}
+
+// ── CLI entry point ─────────────────────────────────────────────────────────
+
+const cliArgs = process.argv.slice(2);
+const flags = {};
+for (const arg of cliArgs) {
+  if (arg === "--advanced") flags.flow = "advanced";
+  if (arg === "--quickstart") flags.flow = "quickstart";
+  if (arg.startsWith("--key=")) flags.key = arg.slice(6);
+  if (arg === "--non-interactive") flags.nonInteractive = true;
+  if (arg === "--reset") flags.reset = true;
+}
+
+if (flags.reset) {
+  if (fs.existsSync(ENV_PATH)) {
+    fs.unlinkSync(ENV_PATH);
+    console.log(c.green("  Config reset."));
+  }
+}
+
+if (flags.nonInteractive) {
+  const vars = {
+    OPENROUTER_API_KEY: flags.key || process.env.OPENROUTER_API_KEY || "",
+    TRANSCRIPTION_BACKEND: "openrouter",
+    PRIVACY_MODE: "standard",
+    AGENT_MODEL: "google/gemini-2.5-flash-lite",
+    ESCALATION_MODE: "off",
+    SINAIN_AGENT: "claude",
+    OPENCLAW_WS_URL: "",
+    OPENCLAW_HTTP_URL: "",
+    PORT: "9500",
+    AUDIO_CAPTURE_CMD: "screencapturekit",
+    AUDIO_AUTO_START: "true",
+    SINAIN_CORE_URL: "http://localhost:9500",
+    SINAIN_POLL_INTERVAL: "5",
+    SINAIN_HEARTBEAT_INTERVAL: "900",
+  };
+
+  if (!vars.OPENROUTER_API_KEY) {
+    console.error(c.red("  --key=<key> or OPENROUTER_API_KEY required for non-interactive mode."));
+    process.exit(1);
+  }
+
+  writeEnv(vars);
+  console.log(c.green(`  Config written to ${ENV_PATH}`));
+  process.exit(0);
+} else {
+  runOnboard(flags).catch((err) => {
+    console.error(c.red(`  Error: ${err.message}`));
+    process.exit(1);
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geravant/sinain",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "Ambient intelligence that sees what you see, hears what you hear, and acts on your behalf",
   "type": "module",
   "bin": {
@@ -14,6 +14,9 @@
   },
   "files": [
     "cli.js",
+    "config.js",
+    "config-shared.js",
+    "onboard.js",
     "launcher.js",
     "setup-overlay.js",
     "setup-sck-capture.js",
@@ -47,5 +50,8 @@
       "./index.ts"
     ]
   },
-  "license": "MIT"
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^1.1.0"
+  }
 }

package/sense_client/__main__.py

@@ -371,13 +371,17 @@ def main():
                 try:
                     from PIL import Image as PILImage
                     pil = PILImage.fromarray(frame) if isinstance(frame, np.ndarray) else frame
-                    scene = vision_provider.describe(pil, prompt=prompt or None)
-                    if scene:
-                        log(f"vision: {scene[:80]}...")
+                    result = vision_provider.describe(pil, prompt=prompt or None)
+                    scene = result.text
+                    v_cost = result.cost
+                    if scene or v_cost:
+                        if scene:
+                            log(f"vision: {scene[:80]}...")
                         ctx_ev = SenseEvent(type="context", ts=ts)
-                        ctx_ev.observation = SenseObservation(scene=scene)
+                        ctx_ev.observation = SenseObservation(scene=scene or "")
                         ctx_ev.meta = meta
                         ctx_ev.roi = package_full_frame(frame)
+                        ctx_ev.vision_cost = v_cost
                         sender.send(ctx_ev)
                 except Exception as e:
                     log(f"vision error: {e}")

package/sense_client/gate.py

@@ -43,6 +43,7 @@ class SenseEvent:
     diff: dict | None = None
     meta: SenseMeta = field(default_factory=SenseMeta)
     observation: SenseObservation = field(default_factory=SenseObservation)
+    vision_cost: dict | None = None  # {cost, tokens_in, tokens_out, model}
 
 
 class DecisionGate: