@geravant/sinain 1.2.1 → 1.4.0

package/cli.js

@@ -6,6 +6,7 @@ import fs from "fs";
 import path from "path";
 
 const cmd = process.argv[2];
+const IS_WINDOWS = os.platform() === "win32";
 
 switch (cmd) {
   case "start":
@@ -20,6 +21,10 @@ switch (cmd) {
     await showStatus();
     break;
 
+  case "setup":
+    await runSetupWizard();
+    break;
+
   case "setup-overlay":
     await import("./setup-overlay.js");
     break;
@@ -41,39 +46,185 @@ switch (cmd) {
     break;
 }
 
+// ── Setup wizard (standalone) ─────────────────────────────────────────────────
+
+async function runSetupWizard() {
+  // Force-run the wizard even if .env exists (re-configure)
+  const { setupWizard } = await import("./launcher.js?setup-only");
+  // The wizard is embedded in launcher.js; we import the module dynamically.
+  // Since launcher.js runs main() on import, we instead inline a lightweight version.
+
+  const readline = await import("readline");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+
+  const HOME = os.homedir();
+  const SINAIN_DIR = path.join(HOME, ".sinain");
+  const envPath = path.join(SINAIN_DIR, ".env");
+
+  const BOLD = "\x1b[1m";
+  const DIM = "\x1b[2m";
+  const GREEN = "\x1b[32m";
+  const YELLOW = "\x1b[33m";
+  const RESET = "\x1b[0m";
+  const IS_WIN = os.platform() === "win32";
+
+  const cmdExists = (cmd) => {
+    try { import("child_process").then(cp => cp.execSync(`which ${cmd}`, { stdio: "pipe" })); return true; }
+    catch { return false; }
+  };
+  // Synchronous version
+  const { execSync } = await import("child_process");
+  const cmdExistsSync = (cmd) => {
+    try { execSync(`which ${cmd}`, { stdio: "pipe" }); return true; }
+    catch { return false; }
+  };
+
+  if (fs.existsSync(envPath)) {
+    const overwrite = await ask(`  ${envPath} already exists. Overwrite? [y/N]: `);
+    if (overwrite.trim().toLowerCase() !== "y") {
+      console.log("  Aborted.");
+      rl.close();
+      return;
+    }
+  }
+
+  console.log();
+  console.log(`${BOLD}── Sinain Setup Wizard ─────────────────${RESET}`);
+  console.log(`  Configuring ${DIM}~/.sinain/.env${RESET}`);
+  console.log();
+
+  const vars = {};
+
+  // Transcription backend
+  let transcriptionBackend = "openrouter";
+  const hasWhisper = !IS_WIN && cmdExistsSync("whisper-cli");
+
+  if (IS_WIN) {
+    console.log(`  ${DIM}(Local whisper not available on Windows — using OpenRouter)${RESET}`);
+  } else if (hasWhisper) {
+    const choice = await ask(`  Transcription backend? [${BOLD}local${RESET}/cloud]: `);
+    transcriptionBackend = choice.trim().toLowerCase() === "cloud" ? "openrouter" : "local";
+  } else {
+    const install = await ask(`  whisper-cli not found. Install via Homebrew? [Y/n]: `);
+    if (!install.trim() || install.trim().toLowerCase() === "y") {
+      try {
+        execSync("brew install whisper-cpp", { stdio: "inherit" });
+        const modelDir = path.join(HOME, "models");
+        const modelPath = path.join(modelDir, "ggml-large-v3-turbo.bin");
+        if (!fs.existsSync(modelPath)) {
+          console.log(`  ${DIM}Downloading model (~1.5 GB)...${RESET}`);
+          fs.mkdirSync(modelDir, { recursive: true });
+          execSync(`curl -L --progress-bar -o "${modelPath}" "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-v3-turbo.bin"`, { stdio: "inherit" });
+        }
+        transcriptionBackend = "local";
+        vars.LOCAL_WHISPER_MODEL = modelPath;
+      } catch {
+        console.log(`  ${YELLOW}Install failed — falling back to OpenRouter${RESET}`);
+      }
+    }
+  }
+  vars.TRANSCRIPTION_BACKEND = transcriptionBackend;
+
+  // API key
+  if (transcriptionBackend === "openrouter") {
+    const key = await ask(`  OpenRouter API key (sk-or-...): `);
+    if (key.trim()) vars.OPENROUTER_API_KEY = key.trim();
+  } else {
+    const key = await ask(`  OpenRouter API key for vision/OCR (optional): `);
+    if (key.trim()) vars.OPENROUTER_API_KEY = key.trim();
+  }
+
+  // Agent
+  const agent = await ask(`  Agent? [${BOLD}claude${RESET}/codex/goose/junie/aider]: `);
+  vars.SINAIN_AGENT = agent.trim().toLowerCase() || "claude";
+
+  // Escalation
+  console.log(`\n  ${DIM}Escalation: off | selective | focus | rich${RESET}`);
+  const esc = await ask(`  Escalation mode? [${BOLD}selective${RESET}]: `);
+  vars.ESCALATION_MODE = esc.trim().toLowerCase() || "selective";
+
+  // Gateway
+  const gw = await ask(`  OpenClaw gateway? [y/N]: `);
+  if (gw.trim().toLowerCase() === "y") {
+    const url = await ask(`  Gateway WS URL [ws://localhost:18789]: `);
+    vars.OPENCLAW_WS_URL = url.trim() || "ws://localhost:18789";
+    const token = await ask(`  Auth token (48-char hex): `);
+    if (token.trim()) {
+      vars.OPENCLAW_WS_TOKEN = token.trim();
+      vars.OPENCLAW_HTTP_TOKEN = token.trim();
+    }
+    vars.OPENCLAW_HTTP_URL = vars.OPENCLAW_WS_URL.replace(/^ws/, "http") + "/hooks/agent";
+    vars.OPENCLAW_SESSION_KEY = "agent:main:sinain";
+  }
+
+  vars.SINAIN_POLL_INTERVAL = "5";
+  vars.SINAIN_HEARTBEAT_INTERVAL = "900";
+  vars.PRIVACY_MODE = "standard";
+
+  // Write
+  fs.mkdirSync(SINAIN_DIR, { recursive: true });
+  const lines = ["# sinain configuration — generated by setup wizard", `# ${new Date().toISOString()}`, ""];
+  for (const [k, v] of Object.entries(vars)) lines.push(`${k}=${v}`);
+  lines.push("");
+  fs.writeFileSync(envPath, lines.join("\n"));
+
+  rl.close();
+  console.log(`\n  ${GREEN}✓${RESET} Config written to ${envPath}\n`);
+}
+
 // ── Stop ──────────────────────────────────────────────────────────────────────
 
 async function stopServices() {
   let killed = false;
 
-  const patterns = [
-    "tsx.*src/index.ts",
-    "tsx watch src/index.ts",
-    "python3 -m sense_client",
-    "Python -m sense_client",
-    "flutter run -d macos",
-    "sinain_hud.app/Contents/MacOS/sinain_hud",
-    "sinain-agent/run.sh",
-  ];
-
-  for (const pat of patterns) {
-    try {
-      execSync(`pkill -f "${pat}"`, { stdio: "pipe" });
-      killed = true;
-    } catch { /* not running */ }
+  if (IS_WINDOWS) {
+    const exes = ["sinain_hud.exe", "tsx.cmd", "python3.exe", "python.exe"];
+    for (const exe of exes) {
+      try {
+        execSync(`taskkill /F /IM "${exe}" 2>NUL`, { stdio: "pipe" });
+        killed = true;
+      } catch { /* not running */ }
+    }
+  } else {
+    const patterns = [
+      "tsx.*src/index.ts",
+      "tsx watch src/index.ts",
+      "python3 -m sense_client",
+      "Python -m sense_client",
+      "flutter run -d macos",
+      "sinain_hud.app/Contents/MacOS/sinain_hud",
+      "sinain-agent/run.sh",
+    ];
+
+    for (const pat of patterns) {
+      try {
+        execSync(`pkill -f "${pat}"`, { stdio: "pipe" });
+        killed = true;
+      } catch { /* not running */ }
+    }
   }
 
   // Free port 9500
   try {
-    const pid = execSync("lsof -i :9500 -sTCP:LISTEN -t", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    if (pid) {
-      execSync(`kill ${pid}`, { stdio: "pipe" });
-      killed = true;
+    if (IS_WINDOWS) {
+      const out = execSync('netstat -ano | findstr ":9500" | findstr "LISTENING"', { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+      const pid = out.split(/\s+/).pop();
+      if (pid && pid !== "0") {
+        execSync(`taskkill /F /PID ${pid}`, { stdio: "pipe" });
+        killed = true;
+      }
+    } else {
+      const pid = execSync("lsof -i :9500 -sTCP:LISTEN -t", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+      if (pid) {
+        execSync(`kill ${pid}`, { stdio: "pipe" });
+        killed = true;
+      }
     }
   } catch { /* port already free */ }
 
   // Clean PID file
-  const pidFile = "/tmp/sinain-pids.txt";
+  const pidFile = path.join(os.tmpdir(), "sinain-pids.txt");
   if (fs.existsSync(pidFile)) {
     fs.unlinkSync(pidFile);
   }
@@ -107,7 +258,7 @@ async function showStatus() {
     console.log(`  ${CYAN}core${RESET}     :9500   ${RED}✗${RESET}  stopped`);
   }
 
-  // Sense: check pgrep
+  // Sense: check process
   const senseUp = isProcessRunning("python3 -m sense_client") || isProcessRunning("Python -m sense_client");
   if (senseUp) {
     console.log(`  ${YELLOW}sense${RESET}            ${GREEN}✓${RESET}  running`);
@@ -116,7 +267,7 @@ async function showStatus() {
   }
 
   // Overlay
-  const overlayUp = isProcessRunning("sinain_hud.app") || isProcessRunning("flutter run -d macos");
+  const overlayUp = isProcessRunning("sinain_hud");
   if (overlayUp) {
     console.log(`  ${MAGENTA}overlay${RESET}          ${GREEN}✓${RESET}  running`);
   } else {
@@ -124,7 +275,7 @@ async function showStatus() {
   }
 
   // Agent
-  const agentUp = isProcessRunning("sinain-agent/run.sh");
+  const agentUp = isProcessRunning("sinain-agent");
   if (agentUp) {
     console.log(`  ${GREEN}agent${RESET}            ${GREEN}✓${RESET}  running`);
   } else {
@@ -147,8 +298,13 @@ function isPortOpen(port) {
 
 function isProcessRunning(pattern) {
   try {
-    execSync(`pgrep -f "${pattern}"`, { stdio: "pipe" });
-    return true;
+    if (IS_WINDOWS) {
+      const out = execSync(`tasklist /FI "IMAGENAME eq ${pattern}.exe" 2>NUL`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+      return out.includes(pattern);
+    } else {
+      execSync(`pgrep -f "${pattern}"`, { stdio: "pipe" });
+      return true;
+    }
   } catch {
     return false;
   }
@@ -158,19 +314,25 @@ function isProcessRunning(pattern) {
 
 function printUsage() {
   console.log(`
-sinain — AI overlay system for macOS
+sinain — AI overlay system for macOS and Windows
 
 Usage:
   sinain start [options]       Launch sinain services
   sinain stop                  Stop all sinain services
   sinain status                Check what's running
-  sinain setup-overlay         Clone and build the overlay app
+  sinain setup                 Run interactive setup wizard (~/.sinain/.env)
+  sinain setup-overlay         Download pre-built overlay app
   sinain install               Install OpenClaw plugin (server-side)
 
 Start options:
   --no-sense                   Skip screen capture (sense_client)
-  --no-overlay                 Skip Flutter overlay
+  --no-overlay                 Skip overlay
   --no-agent                   Skip agent poll loop
   --agent=<name>               Agent to use: claude, codex, goose, aider (default: claude)
+
+Setup-overlay options:
+  --from-source                Build from Flutter source instead of downloading
+  --update                     Force re-download even if version matches
 `);
+
 }

package/launcher.js

@@ -25,7 +25,8 @@ const RESET   = "\x1b[0m";
 const PKG_DIR = path.dirname(new URL(import.meta.url).pathname);
 const HOME = os.homedir();
 const SINAIN_DIR = path.join(HOME, ".sinain");
-const PID_FILE = "/tmp/sinain-pids.txt";
+const PID_FILE = path.join(os.tmpdir(), "sinain-pids.txt");
+const IS_WINDOWS = os.platform() === "win32";
 
 // ── Parse flags ─────────────────────────────────────────────────────────────
 
@@ -59,6 +60,12 @@ async function main() {
   await preflight();
   console.log();
 
+  // Run setup wizard on first launch (no ~/.sinain/.env)
+  const userEnvPath = path.join(SINAIN_DIR, ".env");
+  if (!fs.existsSync(userEnvPath)) {
+    await setupWizard(userEnvPath);
+  }
+
   // Load user config
   loadUserEnv();
 
@@ -139,14 +146,23 @@ async function main() {
   // Start overlay
   let overlayStatus = "skipped";
   if (!skipOverlay) {
-    const overlayDir = findOverlayDir();
-    const hasFlutter = commandExists("flutter");
-    if (overlayDir && hasFlutter) {
-      log("Starting overlay...");
-      startProcess("overlay", "flutter", ["run", "-d", "macos"], {
-        cwd: overlayDir,
-        color: MAGENTA,
-      });
+    const overlay = findOverlay();
+    if (overlay?.type === "prebuilt") {
+      // Remove macOS quarantine if present (ad-hoc signed app)
+      if (!IS_WINDOWS) {
+        try {
+          const xattrs = execSync(`xattr "${overlay.path}"`, { encoding: "utf-8" });
+          if (xattrs.includes("com.apple.quarantine")) {
+            execSync(`xattr -dr com.apple.quarantine "${overlay.path}"`, { stdio: "pipe" });
+          }
+        } catch { /* no quarantine or xattr failed — try launching anyway */ }
+      }
+
+      log("Starting overlay (pre-built)...");
+      const binary = IS_WINDOWS
+        ? overlay.path  // sinain_hud.exe
+        : path.join(overlay.path, "Contents/MacOS/sinain_hud");
+      startProcess("overlay", binary, [], { color: MAGENTA });
       await sleep(2000);
       const overlayChild = children.find(c => c.name === "overlay");
       if (overlayChild && !overlayChild.proc.killed && overlayChild.proc.exitCode === null) {
@@ -156,10 +172,29 @@ async function main() {
         warn("overlay exited early — check logs above");
         overlayStatus = "failed";
       }
-    } else if (!overlayDir) {
-      warn("overlay not found — run: sinain setup-overlay");
+    } else if (overlay?.type === "source") {
+      const hasFlutter = commandExists("flutter");
+      if (hasFlutter) {
+        log("Starting overlay (flutter run)...");
+        const device = IS_WINDOWS ? "windows" : "macos";
+        startProcess("overlay", "flutter", ["run", "-d", device], {
+          cwd: overlay.path,
+          color: MAGENTA,
+        });
+        await sleep(2000);
+        const overlayChild = children.find(c => c.name === "overlay");
+        if (overlayChild && !overlayChild.proc.killed && overlayChild.proc.exitCode === null) {
+          ok(`overlay running (pid:${overlayChild.pid})`);
+          overlayStatus = "running";
+        } else {
+          warn("overlay exited early — check logs above");
+          overlayStatus = "failed";
+        }
+      } else {
+        warn("flutter not found — overlay source found but can't build");
+      }
     } else {
-      warn("flutter not found — overlay skipped");
+      warn("overlay not found — run: sinain setup-overlay");
     }
   }
 
@@ -227,7 +262,7 @@ async function preflight() {
     skipSense = true;
   }
 
-  // Flutter (optional)
+  // Flutter (optional — only needed if no pre-built overlay)
   if (commandExists("flutter")) {
     try {
       const flutterVer = execSync("flutter --version 2>&1", { encoding: "utf-8" }).split("\n")[0].split(" ")[1];
@@ -236,8 +271,14 @@ async function preflight() {
       ok("flutter (version unknown)");
     }
   } else {
-    warn("flutter not found — overlay will be skipped");
-    skipOverlay = true;
+    const prebuiltName = IS_WINDOWS ? "sinain_hud.exe" : "sinain_hud.app";
+    const prebuiltApp = path.join(SINAIN_DIR, "overlay-app", prebuiltName);
+    if (fs.existsSync(prebuiltApp)) {
+      ok("overlay: pre-built app");
+    } else {
+      warn("no overlay available — run: sinain setup-overlay");
+      skipOverlay = true;
+    }
   }
 
   // Port 9500
@@ -250,12 +291,148 @@ async function preflight() {
   }
 }
 
+// ── Setup wizard ─────────────────────────────────────────────────────────────
+
+async function setupWizard(envPath) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+
+  console.log();
+  console.log(`${BOLD}── First-time setup ────────────────────${RESET}`);
+  console.log(`  Configuring ${DIM}~/.sinain/.env${RESET}`);
+  console.log();
+
+  const vars = {};
+
+  // 1. Transcription backend — auto-detect whisper-cli
+  let transcriptionBackend = "openrouter";
+  const hasWhisper = !IS_WINDOWS && commandExists("whisper-cli");
+
+  if (IS_WINDOWS) {
+    console.log(`  ${DIM}(Local whisper not available on Windows — using OpenRouter)${RESET}`);
+  } else if (hasWhisper) {
+    const choice = await ask(`  Transcription backend? [${BOLD}local${RESET}/cloud] (local = whisper-cli, no API key): `);
+    if (choice.trim().toLowerCase() === "cloud") {
+      transcriptionBackend = "openrouter";
+    } else {
+      transcriptionBackend = "local";
+    }
+  } else {
+    const installWhisper = await ask(`  whisper-cli not found. Install via Homebrew? [Y/n]: `);
+    if (!installWhisper.trim() || installWhisper.trim().toLowerCase() === "y") {
+      try {
+        console.log(`  ${DIM}Installing whisper-cpp...${RESET}`);
+        execSync("brew install whisper-cpp", { stdio: "inherit" });
+
+        // Download model
+        const modelDir = path.join(HOME, "models");
+        const modelPath = path.join(modelDir, "ggml-large-v3-turbo.bin");
+        if (!fs.existsSync(modelPath)) {
+          console.log(`  ${DIM}Downloading ggml-large-v3-turbo (~1.5 GB)...${RESET}`);
+          fs.mkdirSync(modelDir, { recursive: true });
+          execSync(
+            `curl -L --progress-bar -o "${modelPath}" "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-v3-turbo.bin"`,
+            { stdio: "inherit" }
+          );
+        }
+
+        transcriptionBackend = "local";
+        vars.LOCAL_WHISPER_MODEL = modelPath;
+        ok("whisper-cpp installed");
+      } catch {
+        warn("whisper-cpp install failed — falling back to OpenRouter");
+        transcriptionBackend = "openrouter";
+      }
+    } else {
+      transcriptionBackend = "openrouter";
+    }
+  }
+  vars.TRANSCRIPTION_BACKEND = transcriptionBackend;
+
+  // 2. OpenRouter API key (if cloud backend or for vision/OCR)
+  if (transcriptionBackend === "openrouter") {
+    let key = "";
+    while (!key) {
+      key = await ask(`  OpenRouter API key (sk-or-...): `);
+      key = key.trim();
+      if (key && !key.startsWith("sk-or-")) {
+        console.log(`  ${YELLOW}⚠${RESET} Key should start with sk-or-. Try again or press Enter to skip.`);
+        const retry = await ask(`  Use this key anyway? [y/N]: `);
+        if (retry.trim().toLowerCase() !== "y") { key = ""; continue; }
+      }
+      if (!key) {
+        console.log(`  ${DIM}You can set OPENROUTER_API_KEY later in ~/.sinain/.env${RESET}`);
+        break;
+      }
+    }
+    if (key) vars.OPENROUTER_API_KEY = key;
+  } else {
+    // Still ask for OpenRouter key (needed for vision/OCR)
+    const key = await ask(`  OpenRouter API key for vision/OCR (optional, Enter to skip): `);
+    if (key.trim()) vars.OPENROUTER_API_KEY = key.trim();
+  }
+
+  // 3. Agent selection
+  const agentChoice = await ask(`  Agent? [${BOLD}claude${RESET}/codex/goose/junie/aider]: `);
+  vars.SINAIN_AGENT = agentChoice.trim().toLowerCase() || "claude";
+
+  // 4. Escalation mode
+  console.log();
+  console.log(`  ${DIM}Escalation modes:${RESET}`);
+  console.log(`    off       — no escalation to gateway`);
+  console.log(`    selective — score-based (errors, questions trigger it)`);
+  console.log(`    focus     — always escalate every tick`);
+  console.log(`    rich      — always escalate with maximum context`);
+  const escMode = await ask(`  Escalation mode? [off/${BOLD}selective${RESET}/focus/rich]: `);
+  vars.ESCALATION_MODE = escMode.trim().toLowerCase() || "selective";
+
+  // 5. OpenClaw gateway
+  const hasGateway = await ask(`  Do you have an OpenClaw gateway? [y/N]: `);
+  if (hasGateway.trim().toLowerCase() === "y") {
+    const wsUrl = await ask(`  Gateway WebSocket URL [ws://localhost:18789]: `);
+    vars.OPENCLAW_WS_URL = wsUrl.trim() || "ws://localhost:18789";
+
+    const wsToken = await ask(`  Gateway auth token (48-char hex): `);
+    if (wsToken.trim()) {
+      vars.OPENCLAW_WS_TOKEN = wsToken.trim();
+      vars.OPENCLAW_HTTP_TOKEN = wsToken.trim();
+    }
+
+    // Derive HTTP URL from WS URL
+    const httpBase = vars.OPENCLAW_WS_URL.replace(/^ws/, "http");
+    vars.OPENCLAW_HTTP_URL = `${httpBase}/hooks/agent`;
+    vars.OPENCLAW_SESSION_KEY = "agent:main:sinain";
+  }
+
+  // 6. Agent-specific defaults
+  vars.SINAIN_POLL_INTERVAL = "5";
+  vars.SINAIN_HEARTBEAT_INTERVAL = "900";
+  vars.PRIVACY_MODE = "standard";
+
+  // Write .env
+  fs.mkdirSync(path.dirname(envPath), { recursive: true });
+  const lines = [];
+  lines.push("# sinain configuration — generated by setup wizard");
+  lines.push(`# ${new Date().toISOString()}`);
+  lines.push("");
+  for (const [key, val] of Object.entries(vars)) {
+    lines.push(`${key}=${val}`);
+  }
+  lines.push("");
+  fs.writeFileSync(envPath, lines.join("\n"));
+
+  rl.close();
+
+  console.log();
+  ok(`Config written to ${envPath}`);
+  console.log();
+}
+
 // ── User environment ────────────────────────────────────────────────────────
 
 function loadUserEnv() {
   const envPaths = [
     path.join(SINAIN_DIR, ".env"),
-    path.join(PKG_DIR, "sinain-core/.env"),
   ];
 
   for (const envPath of envPaths) {
@@ -345,31 +522,51 @@ async function installDeps() {
 
 function killStale() {
   let killed = false;
-  const patterns = [
-    "sinain_hud.app/Contents/MacOS/sinain_hud",
-    "flutter run -d macos",
-    "python3 -m sense_client",
-    "Python -m sense_client",
-    "tsx.*src/index.ts",
-    "tsx watch src/index.ts",
-    "sinain-agent/run.sh",
-  ];
 
-  for (const pat of patterns) {
+  if (IS_WINDOWS) {
+    const exes = ["sinain_hud.exe", "tsx.cmd"];
+    for (const exe of exes) {
+      try {
+        execSync(`taskkill /F /IM "${exe}" 2>NUL`, { stdio: "pipe" });
+        killed = true;
+      } catch { /* not running */ }
+    }
+    // Free port 9500
     try {
-      execSync(`pkill -f "${pat}"`, { stdio: "pipe" });
-      killed = true;
-    } catch { /* not running */ }
-  }
-
-  // Free port 9500
-  try {
-    const pid = execSync("lsof -i :9500 -sTCP:LISTEN -t", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    if (pid) {
-      execSync(`kill ${pid}`, { stdio: "pipe" });
-      killed = true;
+      const out = execSync('netstat -ano | findstr ":9500" | findstr "LISTENING"', { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+      const pid = out.split(/\s+/).pop();
+      if (pid && pid !== "0") {
+        execSync(`taskkill /F /PID ${pid}`, { stdio: "pipe" });
+        killed = true;
+      }
+    } catch { /* already free */ }
+  } else {
+    const patterns = [
+      "sinain_hud.app/Contents/MacOS/sinain_hud",
+      "flutter run -d macos",
+      "python3 -m sense_client",
+      "Python -m sense_client",
+      "tsx.*src/index.ts",
+      "tsx watch src/index.ts",
+      "sinain-agent/run.sh",
+    ];
+
+    for (const pat of patterns) {
+      try {
+        execSync(`pkill -f "${pat}"`, { stdio: "pipe" });
+        killed = true;
+      } catch { /* not running */ }
     }
-  } catch { /* already free */ }
+
+    // Free port 9500
+    try {
+      const pid = execSync("lsof -i :9500 -sTCP:LISTEN -t", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+      if (pid) {
+        execSync(`kill ${pid}`, { stdio: "pipe" });
+        killed = true;
+      }
+    } catch { /* already free */ }
+  }
 
   // Clean old PID file
   if (fs.existsSync(PID_FILE)) {
@@ -461,17 +658,24 @@ function generateMcpConfig() {
 
 // ── Overlay discovery ───────────────────────────────────────────────────────
 
-function findOverlayDir() {
-  // 1. Sibling overlay/ (running from cloned repo)
+function findOverlay() {
+  // 1. Dev monorepo: sibling overlay/ with pubspec.yaml (Flutter source)
   const siblingOverlay = path.join(PKG_DIR, "..", "overlay");
   if (fs.existsSync(path.join(siblingOverlay, "pubspec.yaml"))) {
-    return siblingOverlay;
+    return { type: "source", path: siblingOverlay };
+  }
+
+  // 2. Pre-built app (downloaded by setup-overlay)
+  const prebuiltName = IS_WINDOWS ? "sinain_hud.exe" : "sinain_hud.app";
+  const prebuiltApp = path.join(SINAIN_DIR, "overlay-app", prebuiltName);
+  if (fs.existsSync(prebuiltApp)) {
+    return { type: "prebuilt", path: prebuiltApp };
   }
 
-  // 2. ~/.sinain/overlay/ (installed via setup-overlay)
+  // 3. Legacy: ~/.sinain/overlay/ source install (setup-overlay --from-source)
   const installedOverlay = path.join(SINAIN_DIR, "overlay");
   if (fs.existsSync(path.join(installedOverlay, "pubspec.yaml"))) {
-    return installedOverlay;
+    return { type: "source", path: installedOverlay };
   }
 
   return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geravant/sinain",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "description": "Ambient AI overlay invisible to screen capture — real-time insights from audio + screen context",
   "type": "module",
   "bin": {

package/setup-overlay.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// sinain setup-overlay — clone and build the Flutter overlay app
+// sinain setup-overlay — download pre-built overlay app (or build from source)
 
 import { execSync } from "child_process";
 import fs from "fs";
@@ -8,75 +8,245 @@ import os from "os";
 
 const HOME = os.homedir();
 const SINAIN_DIR = path.join(HOME, ".sinain");
+const APP_DIR = path.join(SINAIN_DIR, "overlay-app");
+const VERSION_FILE = path.join(APP_DIR, "version.json");
+const IS_WINDOWS = os.platform() === "win32";
+
+// Platform-specific asset and app path
+const ASSET_NAME = IS_WINDOWS ? "sinain_hud_windows.zip" : "sinain_hud.app.zip";
+const APP_PATH = IS_WINDOWS
+  ? path.join(APP_DIR, "sinain_hud.exe")
+  : path.join(APP_DIR, "sinain_hud.app");
+
+const REPO = "anthillnet/sinain-hud";
+const RELEASES_API = `https://api.github.com/repos/${REPO}/releases`;
+
+// Legacy source-build paths
 const REPO_DIR = path.join(SINAIN_DIR, "overlay-repo");
 const OVERLAY_LINK = path.join(SINAIN_DIR, "overlay");
 
 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-overlay]${RESET} ${msg}`); }
-function ok(msg)  { console.log(`${BOLD}[setup-overlay]${RESET} ${GREEN}✓${RESET} ${msg}`); }
+function log(msg)  { console.log(`${BOLD}[setup-overlay]${RESET} ${msg}`); }
+function ok(msg)   { console.log(`${BOLD}[setup-overlay]${RESET} ${GREEN}✓${RESET} ${msg}`); }
+function warn(msg) { console.log(`${BOLD}[setup-overlay]${RESET} ${YELLOW}⚠${RESET} ${msg}`); }
 function fail(msg) { console.error(`${BOLD}[setup-overlay]${RESET} ${RED}✗${RESET} ${msg}`); process.exit(1); }
 
-// Check flutter
-try {
-  execSync("which flutter", { stdio: "pipe" });
-} catch {
-  fail("flutter not found. Install it: https://docs.flutter.dev/get-started/install");
+// ── Parse flags ──────────────────────────────────────────────────────────────
+
+const args = process.argv.slice(2);
+const fromSource = args.includes("--from-source");
+const forceUpdate = args.includes("--update");
+
+if (fromSource) {
+  await buildFromSource();
+} else {
+  await downloadPrebuilt();
 }
 
-const flutterVer = execSync("flutter --version 2>&1", { encoding: "utf-8" }).split("\n")[0];
-ok(`flutter: ${flutterVer}`);
+// ── Download pre-built .app ──────────────────────────────────────────────────
 
-fs.mkdirSync(SINAIN_DIR, { recursive: true });
+async function downloadPrebuilt() {
+  fs.mkdirSync(APP_DIR, { recursive: true });
 
-// Clone or update
-if (fs.existsSync(path.join(REPO_DIR, ".git"))) {
-  log("Updating existing overlay repo...");
-  execSync("git pull --ff-only", { cwd: REPO_DIR, stdio: "inherit" });
-  ok("Repository updated");
-} else {
-  log("Cloning overlay (sparse checkout — only overlay/ directory)...");
-  if (fs.existsSync(REPO_DIR)) {
-    fs.rmSync(REPO_DIR, { recursive: true, force: true });
+  // Find latest overlay release
+  log("Checking for latest overlay release...");
+  let release;
+  try {
+    const res = await fetch(`${RELEASES_API}?per_page=20`, {
+      signal: AbortSignal.timeout(10000),
+      headers: { "Accept": "application/vnd.github+json" },
+    });
+    if (!res.ok) throw new Error(`GitHub API returned ${res.status}`);
+    const releases = await res.json();
+    release = releases.find(r => r.tag_name?.startsWith("overlay-v"));
+    if (!release) throw new Error("No overlay release found");
+  } catch (e) {
+    fail(`Failed to fetch releases: ${e.message}\n  Try: sinain setup-overlay --from-source`);
   }
-  execSync(
-    `git clone --depth 1 --filter=blob:none --sparse https://github.com/anthillnet/sinain-hud.git "${REPO_DIR}"`,
-    { stdio: "inherit" }
-  );
-  execSync("git sparse-checkout set overlay", { cwd: REPO_DIR, stdio: "inherit" });
-  ok("Repository cloned");
-}
 
-// Build
-const overlayDir = path.join(REPO_DIR, "overlay");
-if (!fs.existsSync(path.join(overlayDir, "pubspec.yaml"))) {
-  fail("overlay/pubspec.yaml not found — sparse checkout may have failed");
-}
+  const tag = release.tag_name;
+  const version = tag.replace("overlay-v", "");
 
-log("Installing Flutter dependencies...");
-execSync("flutter pub get", { cwd: overlayDir, stdio: "inherit" });
+  // Check if already up-to-date
+  if (!forceUpdate && fs.existsSync(VERSION_FILE) && fs.existsSync(APP_PATH)) {
+    try {
+      const local = JSON.parse(fs.readFileSync(VERSION_FILE, "utf-8"));
+      if (local.tag === tag) {
+        ok(`Overlay already up-to-date (${version})`);
+        return;
+      }
+      log(`Updating: ${local.tag} → ${tag}`);
+    } catch { /* corrupt version file — re-download */ }
+  }
 
-log("Building overlay (this may take a few minutes)...");
-execSync("flutter build macos", { cwd: overlayDir, stdio: "inherit" });
-ok("Overlay built successfully");
+  // Find the .zip asset for this platform
+  const zipAsset = release.assets?.find(a => a.name === ASSET_NAME);
+  if (!zipAsset) {
+    fail(`Release ${tag} has no ${ASSET_NAME} asset.\n  Try: sinain setup-overlay --from-source`);
+  }
 
-// Symlink ~/.sinain/overlay → the overlay source dir
-try {
-  if (fs.existsSync(OVERLAY_LINK)) {
-    fs.unlinkSync(OVERLAY_LINK);
+  // Download with progress
+  log(`Downloading overlay ${version} for ${IS_WINDOWS ? "Windows" : "macOS"} (${formatBytes(zipAsset.size)})...`);
+  const zipPath = path.join(APP_DIR, ASSET_NAME);
+
+  try {
+    const res = await fetch(zipAsset.browser_download_url, {
+      signal: AbortSignal.timeout(120000),
+      redirect: "follow",
+    });
+    if (!res.ok) throw new Error(`Download failed: ${res.status}`);
+
+    const total = parseInt(res.headers.get("content-length") || "0");
+    const chunks = [];
+    let downloaded = 0;
+
+    const reader = res.body.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      downloaded += value.length;
+      if (total > 0) {
+        const pct = Math.round((downloaded / total) * 100);
+        process.stdout.write(`\r${BOLD}[setup-overlay]${RESET} ${DIM}${pct}% (${formatBytes(downloaded)} / ${formatBytes(total)})${RESET}`);
+      }
+    }
+    process.stdout.write("\n");
+
+    const buffer = Buffer.concat(chunks);
+    fs.writeFileSync(zipPath, buffer);
+    ok(`Downloaded ${formatBytes(buffer.length)}`);
+  } catch (e) {
+    fail(`Download failed: ${e.message}`);
+  }
+
+  // Remove old app if present
+  if (fs.existsSync(APP_PATH)) {
+    fs.rmSync(APP_PATH, { recursive: true, force: true });
   }
-  fs.symlinkSync(overlayDir, OVERLAY_LINK);
-  ok(`Symlinked: ${OVERLAY_LINK} → ${overlayDir}`);
-} catch (e) {
-  // Symlink may fail on some systems — fall back to just noting the path
-  log(`Overlay built at: ${overlayDir}`);
+
+  // Extract
+  log("Extracting...");
+  if (IS_WINDOWS) {
+    try {
+      execSync(
+        `powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${APP_DIR}' -Force"`,
+        { stdio: "pipe" }
+      );
+    } catch (e) {
+      fail(`Extraction failed: ${e.message}`);
+    }
+  } else {
+    // ditto preserves macOS extended attributes (critical for code signing)
+    try {
+      execSync(`ditto -x -k "${zipPath}" "${APP_DIR}"`, { stdio: "pipe" });
+    } catch {
+      try {
+        execSync(`unzip -o -q "${zipPath}" -d "${APP_DIR}"`, { stdio: "pipe" });
+      } catch (e) {
+        fail(`Extraction failed: ${e.message}`);
+      }
+    }
+
+    // Remove quarantine attribute (ad-hoc signed app downloaded from internet)
+    try {
+      execSync(`xattr -cr "${APP_PATH}"`, { stdio: "pipe" });
+    } catch { /* xattr may not be needed */ }
+  }
+
+  // Write version marker
+  fs.writeFileSync(VERSION_FILE, JSON.stringify({
+    tag,
+    version,
+    installedAt: new Date().toISOString(),
+  }, null, 2));
+
+  // Clean up zip
+  fs.unlinkSync(zipPath);
+
+  ok(`Overlay ${version} installed`);
+  console.log(`
+${GREEN}✓${RESET} Overlay ready!
+  Location: ${APP_PATH}
+  The overlay will auto-start with: ${BOLD}sinain start${RESET}
+`);
 }
 
-console.log(`
+// ── Build from source (legacy) ───────────────────────────────────────────────
+
+async function buildFromSource() {
+  // Check flutter
+  try {
+    execSync("which flutter", { stdio: "pipe" });
+  } catch {
+    fail("flutter not found. Install it: https://docs.flutter.dev/get-started/install");
+  }
+
+  const flutterVer = execSync("flutter --version 2>&1", { encoding: "utf-8" }).split("\n")[0];
+  ok(`flutter: ${flutterVer}`);
+
+  fs.mkdirSync(SINAIN_DIR, { recursive: true });
+
+  // Clone or update
+  if (fs.existsSync(path.join(REPO_DIR, ".git"))) {
+    log("Updating existing overlay repo...");
+    execSync("git pull --ff-only", { cwd: REPO_DIR, stdio: "inherit" });
+    ok("Repository updated");
+  } else {
+    log("Cloning overlay (sparse checkout — only overlay/ directory)...");
+    if (fs.existsSync(REPO_DIR)) {
+      fs.rmSync(REPO_DIR, { recursive: true, force: true });
+    }
+    execSync(
+      `git clone --depth 1 --filter=blob:none --sparse https://github.com/${REPO}.git "${REPO_DIR}"`,
+      { stdio: "inherit" }
+    );
+    execSync("git sparse-checkout set overlay", { cwd: REPO_DIR, stdio: "inherit" });
+    ok("Repository cloned");
+  }
+
+  // Build
+  const overlayDir = path.join(REPO_DIR, "overlay");
+  if (!fs.existsSync(path.join(overlayDir, "pubspec.yaml"))) {
+    fail("overlay/pubspec.yaml not found — sparse checkout may have failed");
+  }
+
+  log("Installing Flutter dependencies...");
+  execSync("flutter pub get", { cwd: overlayDir, stdio: "inherit" });
+
+  const buildTarget = IS_WINDOWS ? "windows" : "macos";
+  log(`Building overlay for ${buildTarget} (this may take a few minutes)...`);
+  execSync(`flutter build ${buildTarget}`, { cwd: overlayDir, stdio: "inherit" });
+  ok("Overlay built successfully");
+
+  // Symlink ~/.sinain/overlay → the overlay source dir
+  try {
+    if (fs.existsSync(OVERLAY_LINK)) {
+      fs.unlinkSync(OVERLAY_LINK);
+    }
+    fs.symlinkSync(overlayDir, OVERLAY_LINK);
+    ok(`Symlinked: ${OVERLAY_LINK} → ${overlayDir}`);
+  } catch (e) {
+    log(`Overlay built at: ${overlayDir}`);
+  }
+
+  console.log(`
 ${GREEN}✓${RESET} Overlay setup complete!
   The overlay will auto-start with: ${BOLD}sinain start${RESET}
-  Or run manually: cd ${overlayDir} && flutter run -d macos
+  Or run manually: cd ${overlayDir} && flutter run -d ${IS_WINDOWS ? "windows" : "macos"}
 `);
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}

package/sinain-agent/CLAUDE.md

@@ -82,6 +82,6 @@ Your working memory lives at `~/.openclaw/workspace/memory/`:
 
 ## Privacy
 
-The HUD overlay is invisible to screen capture. All content you receive has already been privacy-stripped by sinain-core. Your responses appear only on the ghost overlay — they are never captured in screenshots or recordings.
+The HUD overlay is invisible to screen capture. All content you receive has already been privacy-stripped by sinain-core. Your responses appear only on the invisible overlay — they are never captured in screenshots or recordings.
 
 Never include `<private>` tagged content in your responses — it will be stripped automatically, but avoid echoing it.

package/sinain-agent/run.sh

@@ -3,12 +3,19 @@ set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
-# Load .env if present (does not override existing env vars)
+# Load .env as fallback — does NOT override vars already in the environment
+# (e.g. vars set by the launcher from ~/.sinain/.env)
 if [ -f "$SCRIPT_DIR/.env" ]; then
-  set -a
-  # shellcheck source=/dev/null
-  . "$SCRIPT_DIR/.env"
-  set +a
+  while IFS='=' read -r key val; do
+    # Skip comments and blank lines
+    [[ -z "$key" || "$key" =~ ^[[:space:]]*# ]] && continue
+    key=$(echo "$key" | xargs)  # trim whitespace
+    val=$(echo "$val" | xargs)
+    # Only set if not already in environment
+    if [ -z "${!key+x}" ]; then
+      export "$key=$val"
+    fi
+  done < "$SCRIPT_DIR/.env"
 fi
 
 MCP_CONFIG="${MCP_CONFIG:-$SCRIPT_DIR/mcp-config.json}"