@geravant/sinain 1.8.0 → 1.10.0

package/.env.example

@@ -3,8 +3,18 @@
 # The launcher reads this file on every start. sinain-core and sinain-agent
 # inherit all vars via the launcher's process environment.
 
-# ── Required ─────────────────────────────────────────────────────────────────
+# ── Context Analysis (HUD summarizer) ────────────────────────────────────────
+# Provider: openrouter (cloud, needs API key) or ollama (local, free)
+ANALYSIS_PROVIDER=openrouter
+ANALYSIS_MODEL=google/gemini-2.5-flash-lite
+# ANALYSIS_VISION_MODEL=google/gemini-2.5-flash  # auto-upgrade for image ticks
+# ANALYSIS_ENDPOINT=                             # default per provider; override for custom
+# ANALYSIS_API_KEY=                              # uses OPENROUTER_API_KEY if not set
+# ANALYSIS_FALLBACK_MODELS=google/gemini-2.5-flash,anthropic/claude-3.5-haiku
+
+# ── API Keys ─────────────────────────────────────────────────────────────────
 OPENROUTER_API_KEY=                # get one free at https://openrouter.ai
+                                   # used by context analysis + transcription
 
 # ── Privacy ──────────────────────────────────────────────────────────────────
 PRIVACY_MODE=standard              # off | standard | strict | paranoid
@@ -75,18 +85,6 @@ TRANSCRIPTION_LANGUAGE=en-US
 # LOCAL_WHISPER_MODEL=~/models/ggml-large-v3-turbo.bin
 # LOCAL_WHISPER_TIMEOUT_MS=15000
 
-# ── Local Agent Loop ─────────────────────────────────────────────────────────
-AGENT_ENABLED=true
-AGENT_MODEL=google/gemini-2.5-flash-lite
-# AGENT_FALLBACK_MODELS=google/gemini-2.5-flash,anthropic/claude-3.5-haiku
-AGENT_MAX_TOKENS=300
-AGENT_TEMPERATURE=0.3
-AGENT_PUSH_TO_FEED=true
-AGENT_DEBOUNCE_MS=3000
-AGENT_MAX_INTERVAL_MS=30000
-AGENT_COOLDOWN_MS=10000
-AGENT_MAX_AGE_MS=120000            # context window lookback (2 min)
-
 # ── OpenClaw / NemoClaw Gateway ──────────────────────────────────────────────
 # Leave blank to run without a gateway (bare agent mode).
 # The setup wizard fills these in if you have an OpenClaw gateway.
@@ -111,3 +109,6 @@ SITUATION_MD_PATH=~/.openclaw/workspace/SITUATION.md
 # ── Tracing ──────────────────────────────────────────────────────────────────
 TRACE_ENABLED=true
 TRACE_DIR=~/.sinain-core/traces
+
+# ── Cost Display ─────────────────────────────────────────────────────────────
+COST_DISPLAY_ENABLED=false            # show LLM cost counter in overlay (always logged to stdout)

package/HEARTBEAT.md

@@ -59,4 +59,4 @@ SINAIN_BACKUP_REPO=<git-url> npx sinain
 - Token printed at end (or visible in Brev dashboard → Gateway Token)
 - Mac side: `./setup-nemoclaw.sh` → 5 prompts → overlay starts
 
-Memory is git-backed via `git_backup.sh` on every heartbeat tick. New instances restore instantly via `SINAIN_BACKUP_REPO`.
+Memory is backed up via knowledge snapshots to `~/.sinain/knowledge-snapshots/`. New instances restore instantly via `SINAIN_BACKUP_REPO`.

package/README.md

@@ -29,13 +29,12 @@ Five lifecycle hooks, one tool, four commands, and a background service:
 
 | Tool | Purpose |
 |---|---|
-| `sinain_heartbeat_tick` | Executes all heartbeat mechanical work (git backup, signal analysis, insight synthesis, log writing). Returns structured JSON with results, recommended actions, and Telegram output. |
+| `sinain_heartbeat_tick` | Executes all heartbeat mechanical work (signal analysis, insight synthesis, log writing). Returns structured JSON with results, recommended actions, and Telegram output. |
 
 The heartbeat tool accepts `{ sessionSummary: string, idle: boolean }` and runs:
-1. `bash sinain-memory/git_backup.sh` (30s timeout)
-2. `uv run python3 sinain-memory/signal_analyzer.py` (60s timeout)
-3. `uv run python3 sinain-memory/insight_synthesizer.py` (60s timeout)
-4. Writes log entry to `memory/playbook-logs/YYYY-MM-DD.jsonl`
+1. `uv run python3 sinain-memory/signal_analyzer.py` (60s timeout)
+2. `uv run python3 sinain-memory/insight_synthesizer.py` (60s timeout)
+3. Writes log entry to `memory/playbook-logs/YYYY-MM-DD.jsonl`
 
 ### Commands
 
@@ -114,8 +113,6 @@ Also ensures these directories exist:
 - `memory/`, `memory/playbook-archive/`, `memory/playbook-logs/`
 - `memory/eval-logs/`, `memory/eval-reports/`
 
-The `git_backup.sh` script is automatically made executable (chmod 755) after sync.
-
 After syncing modules, the plugin generates `memory/sinain-playbook-effective.md` — a merged view of active module patterns (sorted by priority) plus the base playbook.
 
 ## Heartbeat Compliance Validation

package/cli.js

@@ -24,8 +24,19 @@ switch (cmd) {
     await showStatus();
     break;
 
+  case "onboard":
+    await import("./onboard.js");
+    break;
+
+  case "config":
+    await import("./config.js");
+    break;
+
   case "setup":
-    await runSetupWizard();
+    // Legacy — redirect to onboard
+    console.log("\x1b[33m  ⚠ `sinain setup` is deprecated. Use: sinain onboard\x1b[0m");
+    console.log("\x1b[2m    Or: sinain onboard --advanced for full options\x1b[0m\n");
+    await import("./onboard.js");
     break;
 
   case "setup-overlay":
@@ -513,10 +524,13 @@ function printUsage() {
 sinain — AI overlay system for macOS and Windows
 
 Usage:
+  sinain onboard               Interactive setup wizard (recommended)
+  sinain onboard --advanced    Full setup with privacy, models, gateway options
+  sinain onboard --reset       Reset config and start fresh
   sinain start [options]       Launch sinain services
   sinain stop                  Stop all sinain services
   sinain status                Check what's running
-  sinain setup                 Run interactive setup wizard (~/.sinain/.env)
+  sinain setup                 (deprecated — use onboard)
   sinain setup-overlay         Download pre-built overlay app
   sinain setup-sck-capture     Download sck-capture audio binary (macOS)
   sinain export-knowledge      Export knowledge for transfer to another machine

package/config-shared.js

@@ -0,0 +1,469 @@
+/**
+ * Shared helpers and step functions for sinain onboard + sinain config.
+ * Both commands import from here to avoid duplication.
+ */
+import * as p from "@clack/prompts";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import net from "net";
+import { execFileSync } from "child_process";
+
+export const HOME = os.homedir();
+export const SINAIN_DIR = path.join(HOME, ".sinain");
+export const ENV_PATH = path.join(SINAIN_DIR, ".env");
+export const PKG_DIR = path.dirname(new URL(import.meta.url).pathname);
+export const IS_WINDOWS = os.platform() === "win32";
+export const IS_MAC = os.platform() === "darwin";
+
+// ── Colors ──────────────────────────────────────────────────────────────────
+
+export const c = {
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+  red: (s) => `\x1b[31m${s}\x1b[0m`,
+  dim: (s) => `\x1b[2m${s}\x1b[0m`,
+  bold: (s) => `\x1b[1m${s}\x1b[0m`,
+  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+};
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+export function guard(value) {
+  if (p.isCancel(value)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  return value;
+}
+
+export function cmdExists(cmd) {
+  try {
+    execFileSync(IS_WINDOWS ? "where" : "which", [cmd], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function isPortOpen(port) {
+  return new Promise((resolve) => {
+    const sock = new net.Socket();
+    sock.setTimeout(800);
+    sock.on("connect", () => { sock.destroy(); resolve(true); });
+    sock.on("error", () => resolve(false));
+    sock.on("timeout", () => { sock.destroy(); resolve(false); });
+    sock.connect(port, "127.0.0.1");
+  });
+}
+
+export function maskKey(key) {
+  if (!key || key.length < 12) return "****";
+  return key.slice(0, 8) + "..." + key.slice(-4);
+}
+
+/** Read existing .env into a key=value map */
+export function readEnv(envPath = ENV_PATH) {
+  if (!fs.existsSync(envPath)) return {};
+  const content = fs.readFileSync(envPath, "utf-8");
+  const vars = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    const key = trimmed.slice(0, eq).trim();
+    const val = trimmed.slice(eq + 1).trim();
+    if (val) vars[key] = val;
+  }
+  return vars;
+}
+
+/** Write vars to .env, preserving template structure */
+export function writeEnv(vars) {
+  fs.mkdirSync(SINAIN_DIR, { recursive: true });
+
+  const examplePath = path.join(PKG_DIR, ".env.example");
+  let template = fs.existsSync(examplePath)
+    ? fs.readFileSync(examplePath, "utf-8")
+    : "";
+
+  if (template) {
+    for (const [k, v] of Object.entries(vars)) {
+      const regex = new RegExp(`^#?\\s*${k}=.*$`, "m");
+      if (regex.test(template)) {
+        template = template.replace(regex, `${k}=${v}`);
+      } else {
+        template += `\n${k}=${v}`;
+      }
+    }
+    template = `# Generated by sinain — ${new Date().toISOString()}\n${template}`;
+    fs.writeFileSync(ENV_PATH, template);
+  } else {
+    const lines = [
+      "# sinain configuration",
+      `# Generated by sinain — ${new Date().toISOString()}`,
+      "",
+    ];
+    for (const [k, v] of Object.entries(vars)) lines.push(`${k}=${v}`);
+    lines.push("");
+    fs.writeFileSync(ENV_PATH, lines.join("\n"));
+  }
+}
+
+export async function fetchHealth(port = 9500) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/health`, { signal: AbortSignal.timeout(2000) });
+    return await res.json();
+  } catch { return null; }
+}
+
+/** Build a config summary for display */
+export function summarizeConfig(existing) {
+  const lines = [];
+  if (existing.OPENROUTER_API_KEY) lines.push(`API Key:       ${maskKey(existing.OPENROUTER_API_KEY)}`);
+  if (existing.TRANSCRIPTION_BACKEND) lines.push(`Transcription: ${existing.TRANSCRIPTION_BACKEND}`);
+  if (existing.AGENT_MODEL) lines.push(`Model:         ${existing.AGENT_MODEL}`);
+  if (existing.PRIVACY_MODE) lines.push(`Privacy:       ${existing.PRIVACY_MODE}`);
+  if (existing.ESCALATION_MODE) lines.push(`Escalation:    ${existing.ESCALATION_MODE}`);
+  if (existing.OPENCLAW_WS_URL) lines.push(`Gateway:       ${existing.OPENCLAW_WS_URL}`);
+  if (existing.SINAIN_AGENT) lines.push(`Agent:         ${existing.SINAIN_AGENT}`);
+  return lines;
+}
+
+// ── Health check ────────────────────────────────────────────────────────────
+
+export async function runHealthCheck() {
+  const checks = [];
+
+  const coreUp = await isPortOpen(9500);
+  if (coreUp) {
+    checks.push(c.green("  sinain-core: reachable (port 9500)"));
+    const health = await fetchHealth();
+    if (health) {
+      const audioState = health.audio?.state || health.audioPipeline?.state;
+      if (audioState === "active" || audioState === "running") {
+        checks.push(c.green("  Audio pipeline: active"));
+      } else {
+        checks.push(c.yellow("  Audio pipeline: inactive — check audio device settings"));
+      }
+      const screenActive = health.screen?.state === "active" || health.senseActive;
+      if (screenActive) {
+        checks.push(c.green("  Screen capture: active"));
+      } else {
+        if (IS_MAC) {
+          checks.push(c.yellow("  Screen capture: inactive"));
+          checks.push(c.dim("    Grant Screen Recording in System Settings → Privacy & Security"));
+        } else {
+          checks.push(c.yellow("  Screen capture: inactive"));
+        }
+      }
+      const gwConnected = health.escalation?.gatewayConnected;
+      if (gwConnected) {
+        checks.push(c.green("  OpenClaw gateway: connected"));
+      } else if (health.escalation?.mode === "off") {
+        checks.push(c.dim("  OpenClaw gateway: not configured (standalone mode)"));
+      } else {
+        checks.push(c.yellow("  OpenClaw gateway: not connected"));
+      }
+    }
+  } else {
+    checks.push(c.dim("  sinain-core: not running"));
+    checks.push(c.dim("  Start with: sinain start (or ./start.sh)"));
+  }
+
+  if (checks.length > 0) {
+    p.note(checks.join("\n"), "System health");
+  }
+}
+
+// ── Step functions ──────────────────────────────────────────────────────────
+// label param: optional prefix like "[1/5]" for onboard, omitted for config
+
+export async function stepApiKey(existing, label = "OpenRouter API key") {
+  const current = existing.OPENROUTER_API_KEY;
+  const message = current
+    ? `${label} ${c.dim(`(current: ${maskKey(current)})`)}`
+    : label;
+
+  p.note(
+    `Key is stored in plain text at ${c.dim(ENV_PATH)}.\nDon't commit this file or share it.`,
+    "Security",
+  );
+
+  const key = guard(await p.text({
+    message,
+    placeholder: current ? "Press Enter to keep current" : "sk-or-v1-...",
+    defaultValue: current || "",
+    validate: (val) => {
+      if (!val && !current) return "API key is required. Get one free at https://openrouter.ai/keys";
+    },
+  }));
+
+  return key || current;
+}
+
+export async function stepTranscription(existing, label = "Audio transcription") {
+  const current = existing.TRANSCRIPTION_BACKEND || "openrouter";
+  const hasWhisper = !IS_WINDOWS && cmdExists("whisper-cli");
+
+  const choice = guard(await p.select({
+    message: label,
+    options: [
+      {
+        value: "openrouter",
+        label: "Cloud (OpenRouter)",
+        hint: "Uses your OpenRouter key, no setup needed",
+      },
+      {
+        value: "local",
+        label: "Local (Whisper)",
+        hint: hasWhisper ? "whisper-cli detected on this machine" : "~1.5 GB download, fully private",
+      },
+    ],
+    initialValue: current,
+  }));
+
+  if (choice === "local" && !hasWhisper && IS_MAC) {
+    const install = guard(await p.confirm({
+      message: "whisper-cli not found. Install via Homebrew?",
+      initialValue: true,
+    }));
+    if (install) {
+      const s = p.spinner();
+      s.start("Installing whisper-cpp...");
+      try {
+        execFileSync("brew", ["install", "whisper-cpp"], { stdio: "pipe" });
+        s.stop(c.green("whisper-cpp installed."));
+      } catch {
+        s.stop(c.yellow("Install failed — falling back to cloud."));
+        return "openrouter";
+      }
+    }
+  }
+
+  return choice;
+}
+
+export async function stepGateway(existing, label = "OpenClaw gateway") {
+  p.note(
+    "The gateway gives sinain a persistent AI agent (Claude/Codex/Goose)\n" +
+    "that handles complex tasks, background research, and multi-step actions.\n" +
+    "Without it, sinain still works — HUD analysis runs locally via OpenRouter.",
+    "What is a gateway?",
+  );
+
+  const choice = guard(await p.select({
+    message: label,
+    options: [
+      {
+        value: "skip",
+        label: "Skip / Disable",
+        hint: "HUD works fine without it — add later with sinain config",
+      },
+      {
+        value: "local",
+        label: "Local gateway",
+        hint: "Install & start openclaw on this machine",
+      },
+      {
+        value: "remote",
+        label: "Remote gateway",
+        hint: "Connect to existing gateway (URL + token)",
+      },
+    ],
+    initialValue: existing.OPENCLAW_WS_URL ? "remote" : "skip",
+  }));
+
+  if (choice === "skip") {
+    return {
+      OPENCLAW_WS_URL: "",
+      OPENCLAW_HTTP_URL: "",
+      OPENCLAW_WS_TOKEN: "",
+      OPENCLAW_HTTP_TOKEN: "",
+      ESCALATION_MODE: "off",
+    };
+  }
+
+  if (choice === "local") {
+    return await setupLocalGateway(existing);
+  }
+
+  // remote
+  const wsUrl = guard(await p.text({
+    message: "Gateway WebSocket URL",
+    placeholder: "Example: ws://192.168.1.100:18789",
+    defaultValue: existing.OPENCLAW_WS_URL || "",
+    validate: (val) => {
+      if (!val) return "URL is required";
+      if (!val.startsWith("ws://") && !val.startsWith("wss://")) return "Must start with ws:// or wss://";
+    },
+  }));
+
+  const token = guard(await p.text({
+    message: "Gateway auth token (48-char hex)",
+    placeholder: existing.OPENCLAW_WS_TOKEN ? "Press Enter to keep current" : "Paste token here",
+    defaultValue: existing.OPENCLAW_WS_TOKEN || "",
+  }));
+
+  const s = p.spinner();
+  s.start("Testing gateway connection...");
+  try {
+    const parsed = new URL(wsUrl);
+    const port = parseInt(parsed.port || "18789");
+    const reachable = await isPortOpen(port);
+    if (reachable) {
+      s.stop(c.green("Gateway reachable."));
+    } else {
+      s.stop(c.yellow("Gateway not reachable — config saved anyway."));
+    }
+  } catch {
+    s.stop(c.yellow("Could not parse URL — config saved anyway."));
+  }
+
+  const httpUrl = wsUrl.replace(/^ws/, "http") + "/hooks/agent";
+  return {
+    OPENCLAW_WS_URL: wsUrl,
+    OPENCLAW_HTTP_URL: httpUrl,
+    OPENCLAW_WS_TOKEN: token,
+    OPENCLAW_HTTP_TOKEN: token,
+    OPENCLAW_SESSION_KEY: "agent:main:sinain",
+    ESCALATION_MODE: "rich",
+  };
+}
+
+async function setupLocalGateway(existing) {
+  const hasOpenclaw = cmdExists("openclaw");
+
+  if (!hasOpenclaw) {
+    const install = guard(await p.confirm({
+      message: "openclaw CLI not found. Install globally via npm?",
+      initialValue: true,
+    }));
+    if (install) {
+      const s = p.spinner();
+      s.start("Installing openclaw...");
+      try {
+        execFileSync("npm", ["install", "-g", "openclaw@latest"], { stdio: "pipe", timeout: 120_000 });
+        s.stop(c.green("openclaw installed."));
+      } catch {
+        s.stop(c.red("Installation failed."));
+        p.note(
+          "Install manually: npm install -g openclaw\nThen re-run setup.",
+          "Manual install",
+        );
+        return { OPENCLAW_WS_URL: "", OPENCLAW_HTTP_URL: "", ESCALATION_MODE: "off" };
+      }
+    } else {
+      return { OPENCLAW_WS_URL: "", OPENCLAW_HTTP_URL: "", ESCALATION_MODE: "off" };
+    }
+  }
+
+  const s = p.spinner();
+  s.start("Checking gateway...");
+  const gatewayUp = await isPortOpen(18789);
+
+  const ocJsonPath = path.join(HOME, ".openclaw/openclaw.json");
+  let token = "";
+  if (fs.existsSync(ocJsonPath)) {
+    try {
+      const ocConfig = JSON.parse(fs.readFileSync(ocJsonPath, "utf-8"));
+      token = ocConfig.gateway?.auth?.token || "";
+    } catch { /* ignore */ }
+  }
+
+  if (gatewayUp) {
+    s.stop(c.green("Gateway already running (port 18789)."));
+  } else {
+    s.stop(c.yellow("Gateway not running."));
+    p.note("Start your gateway:\n  openclaw gateway run\n  or: openclaw onboard --install-daemon", "Next step");
+  }
+
+  return {
+    OPENCLAW_WS_URL: "ws://localhost:18789",
+    OPENCLAW_HTTP_URL: "http://localhost:18789/hooks/agent",
+    OPENCLAW_WS_TOKEN: token,
+    OPENCLAW_HTTP_TOKEN: token,
+    OPENCLAW_SESSION_KEY: "agent:main:sinain",
+    ESCALATION_MODE: "rich",
+  };
+}
+
+export async function stepPrivacy(existing, label = "Privacy mode") {
+  const current = existing.PRIVACY_MODE || "standard";
+  return guard(await p.select({
+    message: label,
+    options: [
+      {
+        value: "off",
+        label: "Off",
+        hint: "No filtering — screen text, credentials, everything sent to cloud",
+      },
+      {
+        value: "standard",
+        label: "Standard",
+        hint: "Auto-redacts cards, API keys, tokens before sending to cloud",
+      },
+      {
+        value: "strict",
+        label: "Strict",
+        hint: "Only summaries leave your machine, no raw screen text or audio",
+      },
+      {
+        value: "paranoid",
+        label: "Paranoid",
+        hint: "Zero cloud calls — needs Whisper + Ollama installed or nothing works",
+      },
+    ],
+    initialValue: current,
+  }));
+}
+
+export async function stepModel(existing, label = "AI model for HUD analysis") {
+  const current = existing.AGENT_MODEL || "google/gemini-2.5-flash-lite";
+  const knownModels = [
+    "google/gemini-2.5-flash-lite",
+    "google/gemini-2.5-flash",
+    "anthropic/claude-3.5-haiku",
+  ];
+
+  const choice = guard(await p.select({
+    message: label,
+    options: [
+      { value: "google/gemini-2.5-flash-lite", label: "gemini-2.5-flash-lite", hint: "Fastest, cheapest — recommended" },
+      { value: "google/gemini-2.5-flash", label: "gemini-2.5-flash", hint: "Better quality, slightly more expensive" },
+      { value: "anthropic/claude-3.5-haiku", label: "claude-3.5-haiku", hint: "Anthropic, fast and affordable" },
+      { value: "custom", label: "Custom", hint: "Enter any model ID from openrouter.ai/models" },
+    ],
+    initialValue: knownModels.includes(current) ? current : "custom",
+  }));
+
+  if (choice === "custom") {
+    return guard(await p.text({
+      message: "Model ID (from openrouter.ai/models)",
+      placeholder: "provider/model-name",
+      defaultValue: knownModels.includes(current) ? "" : current,
+      validate: (val) => {
+        if (!val) return "Model ID is required";
+        if (!val.includes("/")) return "Format: provider/model-name";
+      },
+    }));
+  }
+
+  return choice;
+}
+
+export async function stepAgent(existing, label = "Bare agent") {
+  const current = existing.SINAIN_AGENT || "claude";
+  return guard(await p.select({
+    message: label,
+    options: [
+      { value: "claude", label: "Claude Code", hint: "Calls sinain tools directly — recommended" },
+      { value: "codex", label: "Codex", hint: "Calls sinain tools directly" },
+      { value: "goose", label: "Goose", hint: "Calls sinain tools directly" },
+      { value: "junie", label: "Junie", hint: "JetBrains IDE agent" },
+      { value: "aider", label: "Aider", hint: "Receives text only, no tool access" },
+    ],
+    initialValue: current,
+  }));
+}