nodedex 0.1.0

package/scripts/nodedex-entry.mjs

@@ -0,0 +1,396 @@
+#!/usr/bin/env node
+/**
+ * NodeDex CLI entry point.
+ *
+ *   nodedex         First run → the setup wizard; configured → the server
+ *   nodedex run     Start the MCP + API server (never the wizard)
+ *   nodedex tui     Launch the console / onboarding wizard
+ *   nodedex setup   Wizard, or headless with flags (see help)
+ *   nodedex help    Show usage
+ *
+ * Back-compat: `nodedex-server` (no args) ALWAYS starts the server (never interactive).
+ * In the repo, build first with `npm run build` in server/ (this loads ../dist/server.js);
+ * the published npm package ships dist/ + the compiled TUI (tui-dist/) ready to run.
+ */
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { dirname, resolve, join } from "node:path";
+import { homedir } from "node:os";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const args = process.argv.slice(2);
+const cmd = (args[0] || "").toLowerCase();
+
+const HELP = `nodedex — persistent knowledge-graph memory for AI agents
+
+Usage:
+  nodedex run       Start the MCP + API server (+ any enabled capture watchers)
+  nodedex connect   Print the connection card: the RIGHT url per client location
+                    (host / Docker / LAN), token rule, and copy-paste test commands.
+                    --json for machine-readable (agents).
+  nodedex tui       Launch the operator console
+  nodedex onboard   Run the setup wizard (provider / model / port / db)
+  nodedex setup     Same as onboard; with flags = HEADLESS setup (for agents/scripts):
+    --provider openrouter --key sk-or-...   [--model google/gemini-2.5-flash-lite]
+    --provider local --base-url http://localhost:11434/v1 --model <id>
+    [--port 3001] [--db <name>] [--capture hermes,claude-code | none] [--dry-run]
+  nodedex uninstall Remove ALL local data + config (~/.nodedex) — asks first;
+                    --yes skips the prompt (scripts). Does not remove the package.
+  nodedex help      Show this message
+
+Reconfigure = re-run \`nodedex onboard\` (wizard) or \`nodedex setup\` with flags
+(headless — merges into the existing config, e.g. just --key or --model).
+
+With no command: first run launches the setup wizard; once configured it starts
+the server (same as \`nodedex run\`). \`nodedex-server\` always starts the server.
+Headless example (what an agent runs after asking its user):
+  nodedex setup --provider openrouter --key sk-or-... --db memory --capture claude-code
+  nodedex run`;
+
+// The server is env-only; the TUI normally injects provider/port/db env at launch
+// (tui/src/config.ts: providerEnv + launchServer). `nodedex run` does the SAME
+// translation here, from ~/.nodedex/config.json, so it works standalone — otherwise
+// the bare server defaults to keyless gemini. Keep this mapping in sync with
+// config.ts. Explicit env always wins (fill-if-unset).
+const OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+const OPENROUTER_DEFAULT_MODEL = "google/gemini-2.5-flash";
+
+function applyConfigEnv() {
+  let c;
+  try {
+    c = JSON.parse(readFileSync(join(homedir(), ".nodedex", "config.json"), "utf8"));
+  } catch {
+    return; // no config yet — the server falls back to its own .env / defaults
+  }
+  const set = (k, v) => {
+    if (v != null && v !== "" && !process.env[k]) process.env[k] = String(v);
+  };
+  if (c.provider === "openrouter" && c.openrouter_key) {
+    set("AI_PROVIDER", "openai-compatible");
+    set("OPENAI_BASE_URL", OPENROUTER_BASE_URL);
+    set("OPENAI_API_KEY", c.openrouter_key);
+    set("AI_MODEL", c.model || OPENROUTER_DEFAULT_MODEL);
+  } else if (c.provider === "local" && c.base_url && c.model) {
+    set("AI_PROVIDER", "openai-compatible");
+    set("OPENAI_BASE_URL", c.base_url);
+    set("OPENAI_API_KEY", "local");
+    set("AI_MODEL", c.model);
+  }
+  set("PORT", c.port);
+  set("WORKSPACE_DB_PATH", c.dbPath);
+  // Arc mode ON, matching the TUI's launch env (servers.ts). Without this, watcher-fed
+  // turns (turn_number present) route to the retired per-turn v1 path and NO-OP — the
+  // whole capture story silently dead on a headless install. Found the hard way in the
+  // 2026-07-02 dogfood run: a bare `node dist/server.js` captured nothing.
+  set("NODEDEX_ARC_EXTRACTION", "1");
+}
+
+function startServer() {
+  applyConfigEnv();
+  const distServer = resolve(here, "../dist/server.js");
+  if (!existsSync(distServer)) {
+    console.error(
+      "[nodedex] dist/server.js not found — build the server first: `npm run build` (in server/)."
+    );
+    process.exit(1);
+  }
+  // On Windows a bare absolute path ("C:\\...") is rejected by the ESM loader;
+  // it must be a file:// URL.
+  import(pathToFileURL(distServer).href);
+  startEnabledWatchers();
+}
+
+// Headless path parity with the TUI: `nodedex run` also brings up whichever capture
+// watchers the config enables (the TUI spawns its own when it runs; this covers
+// server-only / agent-driven installs where no TUI is ever opened).
+function startEnabledWatchers() {
+  let c = {};
+  try { c = JSON.parse(readFileSync(join(homedir(), ".nodedex", "config.json"), "utf8")); } catch { return; }
+  const defs = [
+    { key: "hermesCapture", script: "hermes-statedb-watcher.mjs", name: "hermes" },
+    { key: "claudeCapture", script: "claude-code-watcher.mjs", name: "claude-code" },
+  ];
+  for (const d of defs) {
+    if (!c[d.key] || c[d.key].enabled === false) continue; // only spawn what setup/TUI explicitly enabled
+    const script = resolve(here, "../adapters", d.script);
+    if (!existsSync(script)) continue;
+    const child = spawn(process.execPath, [script], { cwd: resolve(here, ".."), stdio: ["ignore", "inherit", "inherit"] });
+    child.on("error", (e) => console.error(`[nodedex] ${d.name} watcher failed to start: ${e.message}`));
+    console.error(`[nodedex] ${d.name} capture watcher started (pid ${child.pid}).`);
+  }
+}
+
+// ─── Headless setup (agent/script-driven — no TUI) ─────────────────────────────
+// Writes the SAME ~/.nodedex/config.json the wizard writes, so `nodedex run`, the
+// TUI, and the watchers all pick it up identically. Deterministic on purpose: an
+// agent installing NodeDex for its user runs ONE command instead of improvising.
+function flagValue(name) {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : undefined;
+}
+
+async function headlessSetup() {
+  const provider = (flagValue("--provider") || "").toLowerCase();
+  const dryRun = args.includes("--dry-run");
+  if (provider !== "openrouter" && provider !== "local") {
+    console.error("[nodedex setup] --provider must be 'openrouter' or 'local'. See `nodedex help`.");
+    process.exit(1);
+  }
+  const patch = { provider, onboarded: true };
+
+  if (provider === "openrouter") {
+    const key = flagValue("--key");
+    if (!key) { console.error("[nodedex setup] --key sk-or-... is required for --provider openrouter."); process.exit(1); }
+    // Same validation as the wizard: a typo fails HERE, not at first extraction.
+    try {
+      const r = await fetch(`${OPENROUTER_BASE_URL}/key`, { headers: { Authorization: `Bearer ${key}` }, signal: AbortSignal.timeout(8000) });
+      if (!r.ok) { console.error(`[nodedex setup] OpenRouter rejected the key (${r.status}).`); process.exit(1); }
+    } catch (e) {
+      console.error(`[nodedex setup] couldn't reach OpenRouter to validate the key (${e?.message ?? e}).`);
+      process.exit(1);
+    }
+    patch.openrouter_key = key;
+    patch.model = flagValue("--model") || "google/gemini-2.5-flash-lite";
+  } else {
+    const baseUrl = flagValue("--base-url");
+    const model = flagValue("--model");
+    if (!baseUrl || !model) { console.error("[nodedex setup] --base-url and --model are required for --provider local."); process.exit(1); }
+    patch.base_url = baseUrl;
+    patch.model = model;
+  }
+
+  const port = Number(flagValue("--port"));
+  patch.port = Number.isInteger(port) && port > 0 ? port : 3001;
+
+  const db = flagValue("--db") || "workspace";
+  patch.dbPath = /[\\/]/.test(db)
+    ? db // explicit path given
+    : join(homedir(), ".nodedex", `${db.trim().replace(/[^a-z0-9_-]/gi, "-").replace(/^-+|-+$/g, "") || "workspace"}.db`);
+
+  // Capture consent is EXPLICIT here (no checkbox screen): the caller — typically an
+  // agent that just asked its user — names the hosts. Default: none (read-only setup).
+  const capture = (flagValue("--capture") || "none").toLowerCase();
+  const hosts = new Set(capture === "none" ? [] : capture.split(",").map((s) => s.trim()).filter(Boolean));
+  patch.hermesCapture = { enabled: hosts.has("hermes") };
+  patch.claudeCapture = { enabled: hosts.has("claude-code") || hosts.has("claude") };
+
+  const configPath = join(homedir(), ".nodedex", "config.json");
+  let existing = {};
+  try { existing = JSON.parse(readFileSync(configPath, "utf8")); } catch { /* fresh install */ }
+  const merged = { ...existing, ...patch };
+
+  if (dryRun) {
+    const masked = { ...merged, openrouter_key: merged.openrouter_key ? merged.openrouter_key.slice(0, 8) + "…" : undefined };
+    console.log("[nodedex setup] DRY-RUN — would write to " + configPath + ":");
+    console.log(JSON.stringify(masked, null, 2));
+    return;
+  }
+  const { mkdirSync, writeFileSync } = await import("node:fs");
+  mkdirSync(join(homedir(), ".nodedex"), { recursive: true });
+  writeFileSync(configPath, JSON.stringify(merged, null, 2));
+  console.log(`[nodedex setup] config written → ${configPath}`);
+  console.log(`  provider=${provider}  model=${merged.model}  port=${merged.port}`);
+  console.log(`  db=${merged.dbPath}`);
+  console.log(`  capture: hermes=${patch.hermesCapture.enabled} claude-code=${patch.claudeCapture.enabled}`);
+  console.log(`Next: \`nodedex run\` starts the server (+ enabled watchers).`);
+  console.log(`Connect your agent to http://127.0.0.1:${merged.port}/mcp — snippets: ~/.nodedex/connect-snippets.md (written by the TUI) or the README.`);
+}
+
+// Launch the TUI (operator console + first-run onboarding wizard). Two layouts:
+//   packaged (npx / npm install): the compiled TUI ships INSIDE this package at
+//     tui-dist/ and runs on plain node (its deps — ink/react — are package deps);
+//   repo/dev: the sibling tui/ package, run from source via tsx.
+function launchTui(extraArgs = []) {
+  const packagedCli = resolve(here, "../tui-dist/cli.js");
+  const repoTuiDir = resolve(here, "../../tui");
+  let spawnArgs, cwd;
+  if (existsSync(packagedCli)) {
+    spawnArgs = [packagedCli, ...extraArgs];
+    cwd = resolve(here, "..");
+  } else if (existsSync(resolve(repoTuiDir, "src/cli.tsx"))) {
+    spawnArgs = ["--import", "tsx/esm", "src/cli.tsx", ...extraArgs];
+    cwd = repoTuiDir;
+  } else {
+    console.error("[nodedex] no TUI found (neither packaged tui-dist/ nor a repo tui/). Reinstall the package.");
+    process.exit(1);
+  }
+  const child = spawn(process.execPath, spawnArgs, { cwd, stdio: "inherit" });
+  child.on("error", (err) => {
+    console.error(`[nodedex] failed to launch the TUI: ${err.message}`);
+    process.exit(1);
+  });
+  child.on("exit", (code) => process.exit(code ?? 0));
+}
+
+// ─── `nodedex uninstall` — remove ~/.nodedex (data + config). DESTRUCTIVE. ─────
+// Mirrors tui/scripts/uninstall.mjs so packaged (npx) installs have a way out too.
+// Does NOT remove the package itself or the NodeDex entry in the agent host's MCP
+// config. `--yes` skips the prompt (agent/script-driven).
+async function uninstall() {
+  const { rmSync, readdirSync } = await import("node:fs");
+  const home = join(homedir(), ".nodedex");
+  if (!existsSync(home)) {
+    console.log(`Nothing to remove — ${home} doesn't exist.`);
+    return;
+  }
+  let dbs = [];
+  try { dbs = readdirSync(home).filter((f) => f.endsWith(".db")); } catch { /* unreadable */ }
+  console.log(`\nThis will permanently DELETE:\n  ${home}\n`);
+  console.log("Including:");
+  console.log("  • your config + OpenRouter API key");
+  console.log(`  • ${dbs.length} knowledge-graph database(s): ${dbs.join(", ") || "(none)"}`);
+  console.log("  • server logs + reflect-pause state");
+  console.log("\nThis cannot be undone. It does NOT remove the nodedex package, or the NodeDex");
+  console.log("entry in your agent host's MCP config — remove those yourself.\n");
+
+  if (!args.includes("--yes")) {
+    const readline = await import("node:readline/promises");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ans = (await rl.question('Type "delete" to confirm: ')).trim().toLowerCase();
+    rl.close();
+    if (ans !== "delete") {
+      console.log("Aborted — nothing removed.");
+      return;
+    }
+  }
+  try {
+    rmSync(home, { recursive: true, force: true });
+  } catch (e) {
+    console.log(`\nFailed to remove ${home}: ${e?.message ?? e}`);
+    console.log("A server may still be holding a database file. Stop all NodeDex servers, then re-run.");
+    process.exit(1);
+  }
+  console.log(`\nRemoved ${home}.`);
+  console.log("Also remove the NodeDex MCP entry from your agent host's config.");
+}
+
+// First run? (mirrors tui/src/config.ts needsOnboarding, without importing it)
+function isOnboarded() {
+  try {
+    const c = JSON.parse(readFileSync(join(homedir(), ".nodedex", "config.json"), "utf8"));
+    if (!c.onboarded) return false;
+    if (c.provider === "openrouter") return !!c.openrouter_key;
+    if (c.provider === "local") return !!(c.base_url && c.model);
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+// ─── `nodedex connect` — the connection card ───────────────────────────────────
+// THE fix for "connecting is messy": one command that reports ground truth instead
+// of the user/agent guessing at ip × port × token. Reads the live server list
+// (tui-session.json), probes health, and prints the RIGHT url for each client
+// location + the exact test command to run from there. --json for agents.
+async function connectCard() {
+  const asJson = args.includes("--json");
+  let session = {};
+  try { session = JSON.parse(readFileSync(join(homedir(), ".nodedex", "tui-session.json"), "utf8")); } catch { /* none */ }
+  let managed = Array.isArray(session?.managed) ? session.managed : [];
+  if (managed.length === 0) {
+    // No TUI-managed record — probe the config/default port directly (headless installs).
+    let port = 3001;
+    try { port = JSON.parse(readFileSync(join(homedir(), ".nodedex", "config.json"), "utf8"))?.port || 3001; } catch { /* default */ }
+    managed = [{ port, token: process.env.NODEDEX_API_TOKEN || "" }];
+  }
+
+  const servers = [];
+  for (const m of managed) {
+    if (!m?.port) continue;
+    let up = false, db = null;
+    try {
+      const r = await fetch(`http://127.0.0.1:${m.port}/api/health`, { signal: AbortSignal.timeout(2500) });
+      up = r.ok;
+      try { db = (await r.json())?.db ?? null; } catch { /* health may be bodyless */ }
+    } catch { /* down */ }
+    servers.push({ port: m.port, token: m.token || "", up, db });
+  }
+
+  // Best-effort LAN address (for a remote machine / LAN agent).
+  const { networkInterfaces } = await import("node:os");
+  let lanIp = null;
+  for (const ifaces of Object.values(networkInterfaces() || {})) {
+    for (const i of ifaces || []) {
+      if (i.family === "IPv4" && !i.internal && !String(i.address).startsWith("169.254.")) { lanIp = i.address; break; }
+    }
+    if (lanIp) break;
+  }
+
+  if (asJson) {
+    console.log(JSON.stringify({
+      token_rule: "same-machine connections NEVER need the token; Docker/remote ALWAYS do (unless NODEDEX_STRICT_TOKEN=1)",
+      servers: servers.map((s) => ({
+        up: s.up, port: s.port, db: s.db,
+        from_this_machine: { mcp: `http://127.0.0.1:${s.port}/mcp`, token_needed: false },
+        from_docker: { mcp: `http://host.docker.internal:${s.port}/mcp`, token_needed: !!s.token, token: s.token || null, linux_note: "add --add-host=host.docker.internal:host-gateway" },
+        from_lan: lanIp ? { mcp: `http://${lanIp}:${s.port}/mcp`, token_needed: !!s.token, token: s.token || null, note: "server must be started with NODEDEX_BIND_HOST=0.0.0.0" } : null,
+      })),
+    }, null, 2));
+    return;
+  }
+
+  if (servers.length === 0) { console.log("[nodedex connect] no server known — run `nodedex run` (or the TUI) first."); return; }
+  console.log("NodeDex connection card — the ONE token rule: same machine = no token; Docker/remote = token.\n");
+  for (const s of servers) {
+    console.log(`● port ${s.port}  ${s.up ? "UP" : "DOWN — start it: nodedex run"}${s.db ? `  db=${s.db}` : ""}`);
+    console.log(`  From THIS machine (Claude Code, local agents):`);
+    console.log(`    http://127.0.0.1:${s.port}/mcp        (no token, ever)`);
+    console.log(`    test: curl http://127.0.0.1:${s.port}/api/health`);
+    console.log(`  From INSIDE Docker (agent in a container):`);
+    console.log(`    http://host.docker.internal:${s.port}/mcp${s.token ? `   + header  Authorization: Bearer ${s.token}` : "   (no token configured — set one for network exposure)"}`);
+    console.log(`    test (run INSIDE the container): curl ${s.token ? `-H "Authorization: Bearer ${s.token}" ` : ""}http://host.docker.internal:${s.port}/api/health`);
+    console.log(`    Linux: add  --add-host=host.docker.internal:host-gateway  to the container.`);
+    if (lanIp) console.log(`  From ANOTHER machine on your network: http://${lanIp}:${s.port}/mcp  (token required; server needs NODEDEX_BIND_HOST=0.0.0.0)`);
+    console.log("");
+  }
+  console.log(`If a Docker connect fails: (1) run the in-container curl above — if it hangs, it's networking
+(host-gateway flag / Windows firewall "allow" prompt for node), not NodeDex; (2) 401 = missing/wrong
+token header; (3) NEVER use "localhost" from a container (that's the container itself).`);
+}
+
+// Bare `npx nodedex` on a fresh machine = the setup wizard, not a keyless server.
+// `nodedex run`/`start` (and the `nodedex-server` bin name) always mean the server —
+// scripts and process managers must never be surprised by an interactive wizard.
+const invokedAsServer = String(process.argv[1] || "").toLowerCase().includes("nodedex-server");
+
+switch (cmd) {
+  case "":
+    if (!invokedAsServer && !isOnboarded()) {
+      console.error("[nodedex] first run — launching the setup wizard (use `nodedex run` to skip straight to the server).");
+      launchTui(["--onboard"]);
+      break;
+    }
+    startServer();
+    break;
+  case "run":
+  case "start":
+    startServer();
+    break;
+  case "connect":
+  case "doctor":
+    void connectCard();
+    break;
+  case "uninstall":
+    void uninstall();
+    break;
+  case "tui":
+  case "dashboard":
+    launchTui();
+    break;
+  case "onboard":
+  case "setup":
+    // Flags present → headless (agent/script-driven); bare → the interactive wizard.
+    if (args.some((a) => a.startsWith("--"))) void headlessSetup();
+    else launchTui(["--onboard"]);
+    break;
+  case "help":
+  case "-h":
+  case "--help":
+    console.log(HELP);
+    break;
+  default:
+    console.error(`[nodedex] unknown command: ${args[0]}\n`);
+    console.log(HELP);
+    process.exit(1);
+}

package/tui-dist/App.js

@@ -0,0 +1,185 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// App.tsx — shell v3: three views (memory · feed · health), one quiet chrome.
+// Top line = brand + view bar; bottom line = the StatusLine (single home for
+// connection/graph/pipeline/spend numbers). Two poll cadences: fast 2s over
+// LOCAL endpoints, slow 30s for the OpenRouter balance. Input is guarded by
+// isRawModeSupported so a non-TTY (piped) context still renders.
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Box, Text, useApp, useInput, useStdin } from "ink";
+import { Brand, ViewBar, StatusLine } from "./components.js";
+import { MemoryTab } from "./memory.js";
+import { FeedTab } from "./feed.js";
+import { HealthTab } from "./health.js";
+import { fetchDashboard, fetchBalance, getBase, setBase } from "./api.js";
+import { killAllManaged, restoreSession, launchWatcher, isWatcherRunning } from "./servers.js";
+import { loadHermesCapture, loadClaudeCapture } from "./config.js";
+import { theme } from "./theme.js";
+import { useTermSize } from "./hooks.js";
+const VIEWS = ["memory", "feed", "health"];
+const MEMORY = 0;
+const FEED = 1;
+const HEALTH = 2;
+const VERSION = "0.3.0";
+const FAST_MS = 2000;
+const SLOW_MS = 30000;
+export function App() {
+    const { exit } = useApp();
+    const { isRawModeSupported } = useStdin();
+    const { rows } = useTermSize();
+    const [dash, setDash] = useState(null);
+    const [balance, setBalance] = useState({ remaining: null, available: false });
+    const [active, setActive] = useState(MEMORY);
+    const [auto, setAuto] = useState(true);
+    // Restore the last server+db BEFORE the first poll so we land on the right one (a
+    // restart reconnects if it's up, else relaunches the managed server on the same
+    // port+db). Polling waits on this so the first frame isn't aimed at the default base.
+    const [booting, setBooting] = useState(true);
+    // A pane's free-text input mode (search, edit rows) owns the keyboard — while it
+    // captures, the shell must not act on q/esc/digits. Ref, not state, so the input
+    // handler sees the current value without re-subscribing.
+    const captureRef = useRef(false);
+    const onCapture = useCallback((v) => { captureRef.current = v; }, []);
+    const refresh = useCallback(async () => { setDash(await fetchDashboard()); }, []);
+    // Kill any servers the TUI launched before leaving — never leave a managed
+    // child (or a held port) behind. Belt-and-suspenders: also on process exit.
+    const doExit = useCallback(() => {
+        try {
+            killAllManaged();
+        }
+        catch { /* */ }
+        try {
+            exit();
+        }
+        catch { /* */ }
+        // Force the process down shortly after the soft unmount; pending handles (a
+        // managed server's pipes, scan timers) can keep the loop alive otherwise.
+        const t = setTimeout(() => process.exit(0), 120);
+        if (typeof t.unref === "function")
+            t.unref();
+    }, [exit]);
+    useEffect(() => {
+        const onProcExit = () => killAllManaged();
+        // SIGTERM/SIGHUP terminate WITHOUT running 'exit' handlers — handle explicitly.
+        const onSignal = () => { killAllManaged(); process.exit(0); };
+        process.on("exit", onProcExit);
+        process.on("SIGINT", onSignal);
+        process.on("SIGTERM", onSignal);
+        process.on("SIGHUP", onSignal);
+        return () => {
+            process.off("exit", onProcExit);
+            process.off("SIGINT", onSignal);
+            process.off("SIGTERM", onSignal);
+            process.off("SIGHUP", onSignal);
+        };
+    }, []);
+    // One-time startup restore: reconnect to (or relaunch) the last server+db, then
+    // release the boot gate so polling begins against the right base.
+    useEffect(() => {
+        let alive = true;
+        (async () => {
+            try {
+                const url = await restoreSession();
+                if (alive && url)
+                    setBase(url);
+            }
+            catch { /* default base */ }
+            // Reconcile capture watchers: whatever the user left enabled comes back up with
+            // the servers (each watcher self-locates the live server, order doesn't matter).
+            try {
+                if (loadHermesCapture().enabled)
+                    launchWatcher();
+            }
+            catch { /* best-effort */ }
+            try {
+                if (loadClaudeCapture().enabled)
+                    launchWatcher("claude-code");
+            }
+            catch { /* best-effort */ }
+            if (alive)
+                setBooting(false);
+        })();
+        return () => { alive = false; };
+    }, []);
+    // Fast poll — local endpoints only. Held until boot restore picks the base.
+    useEffect(() => {
+        if (booting)
+            return;
+        let alive = true;
+        const run = async () => {
+            const d = await fetchDashboard();
+            if (alive)
+                setDash(d);
+        };
+        run();
+        if (!auto)
+            return () => { alive = false; };
+        const id = setInterval(run, FAST_MS);
+        return () => { alive = false; clearInterval(id); };
+    }, [auto, booting]);
+    // Slow poll — balance hits OpenRouter, keep it gentle. Also waits on boot.
+    useEffect(() => {
+        if (booting)
+            return;
+        let alive = true;
+        const run = async () => {
+            const b = await fetchBalance();
+            if (alive)
+                setBalance(b);
+        };
+        run();
+        const id = setInterval(run, SLOW_MS);
+        return () => { alive = false; clearInterval(id); };
+    }, [booting]);
+    useInput((input, key) => {
+        if (key.ctrl && input === "c") {
+            doExit();
+            return;
+        }
+        if (captureRef.current)
+            return; // a pane's input mode owns the keyboard
+        if (input === "q") {
+            doExit();
+            return;
+        }
+        if (key.tab) {
+            setActive((a) => (key.shift ? a - 1 + VIEWS.length : a + 1) % VIEWS.length);
+            return;
+        }
+        if (input >= "1" && input <= String(VIEWS.length)) {
+            setActive(Number(input) - 1);
+            return;
+        }
+        // r/j/k etc. belong to the views; only global leftovers here.
+        if (active === FEED && input === "r")
+            void refresh();
+        if (input === "a")
+            setAuto((v) => !v);
+    }, 
+    // Strict boolean: ink's useInput only skips raw mode when isActive === false.
+    { isActive: isRawModeSupported === true });
+    const captureDots = [
+        { name: "claude", on: isWatcherRunning("claude-code") },
+        { name: "hermes", on: isWatcherRunning("hermes") },
+    ];
+    let body;
+    if (active === HEALTH) {
+        // Health stays usable when the connection is down — that's where you fix it.
+        body = _jsx(HealthTab, { dash: dash, balance: balance, isActive: isRawModeSupported === true, onCapture: onCapture, onConnect: () => void refresh() });
+    }
+    else if (!dash) {
+        body = (_jsx(Box, { paddingY: 1, children: _jsx(Text, { color: theme.dim, children: `connecting to ${getBase()} …` }) }));
+    }
+    else if (!dash.ok) {
+        body = (_jsxs(Box, { flexDirection: "column", paddingY: 1, children: [_jsx(Text, { color: theme.danger, children: `● server unreachable at ${getBase()}` }), _jsx(Text, { color: theme.dim, children: "fix it in health [3] \u2014 switch server / db, or `nodedex run`" })] }));
+    }
+    else if (active === MEMORY) {
+        body = _jsx(MemoryTab, { isActive: isRawModeSupported === true, onCapture: onCapture });
+    }
+    else {
+        body = _jsx(FeedTab, { dash: dash, isActive: isRawModeSupported === true });
+    }
+    return (
+    // height-pinned to the terminal so the frame is a CONSTANT size across views —
+    // ink repaints in place instead of emitting a taller/shorter frame that scrolls.
+    _jsxs(Box, { flexDirection: "column", paddingX: 1, height: rows, overflow: "hidden", children: [_jsxs(Box, { flexShrink: 0, justifyContent: "space-between", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(Brand, {}), _jsx(Box, { marginLeft: 3, children: _jsx(ViewBar, { views: VIEWS, active: active }) })] }), _jsx(Text, { color: theme.dim, children: `v${VERSION}` })] }), _jsx(Box, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: body }), _jsx(Box, { flexShrink: 0, marginTop: 1, children: _jsx(StatusLine, { dash: dash, balance: balance, captureDots: captureDots }) })] }));
+}