synabun 2.0.10 → 2.2.0

package/setup.js

@@ -5,6 +5,10 @@
  *
  * Usage: node setup.js   (or: npm start)
  *
+ * The commands (mcp, doctor, profile, migrate-data, restore-backup, version)
+ * are listed by `synabun help`; `synabun mcp` never gets here (bin/synabun.js
+ * starts the MCP server itself).
+ *
  * 1. Checks Node.js version (>=22)
  * 2. Ensures data directory exists (~/.synabun or %APPDATA%/synabun)
  * 3. Migrates data from old scaffolded installs if detected
@@ -17,8 +21,8 @@
  * 8. Auto-opens browser to onboarding wizard (or main page if setup complete)
  */
 
-import { execFileSync, spawn, exec } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync, cpSync, readdirSync, mkdirSync, unlinkSync, createWriteStream, statSync, renameSync } from 'node:fs';
+import { execFileSync, exec } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync, cpSync, readdirSync, mkdirSync } from 'node:fs';
 import { resolve, dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { platform } from 'node:os';
@@ -52,9 +56,17 @@ import { packagedRuntime } from './lib/packaged-runtime.js';
 import {
   OPTIONAL_AT_ROOT, checkRuntimeDependencies, findInstalled, installAtPackageRoot, installKind, mcpCompiler,
 } from './lib/runtime-dependencies.js';
+import { mcpDistBuilt } from './lib/mcp-dist.js';
+import { superviseServer } from './lib/server-supervisor.js';
+import { MCP_COMMAND, nodeArgs, runNode } from './bin/synabun.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
+// The environment as this process got it, before the data home below is
+// settled into it: `node setup.js mcp` hands the MCP server exactly what
+// `node mcp-server/run.mjs` would get.
+const LAUNCH_ENV = { ...process.env };
+
 // ── ANSI color helpers ──
 
 const c = {
@@ -388,9 +400,10 @@ function installPlaywrightChromium() {
 
 // ── Phase 4: MCP server build ──
 
+// Built means dist/index.js and every module it imports (lib/mcp-dist.js): a checkout can hold a tracked
+// dist/index.js whose newer imports git ignores.
 function needsBuild() {
-  const distIndex = resolve(PACKAGE_ROOT, 'mcp-server', 'dist', 'index.js');
-  return !existsSync(distIndex);
+  return !mcpDistBuilt(PACKAGE_ROOT);
 }
 
 function buildMcpServer() {
@@ -456,333 +469,81 @@ function openBrowser(url) {
   }
 }
 
-// Sentinel exit code for supervised restart. Server exits with this code via
-// /api/server/restart; the supervisor below respawns instead of giving up.
-// 75 = sysexits EX_TEMPFAIL — conventional "transient, retry" signal.
-const RESTART_EXIT_CODE = 75;
-
-// Marker file written by /api/server/restart before tearing down. If the
-// server crashes during shutdown (e.g. native module mutex error in sqlite/
-// playwright/node-pty), the exit code will not be 75 — but the marker tells
-// the supervisor the user asked for a restart, so we respawn anyway.
-const RESTART_MARKER = resolve(DATA_HOME, 'restart-requested');
-
+// The server runs under lib/server-supervisor.js: started again when it asks
+// for a restart (exit code 75, or the restart marker) and when it crashes after
+// it was up (within the crash-loop guard, 5 starts in 60 s); after a crash the
+// server it starts finds a record of it, and tells the user's pages once. A
+// stop that was asked for (the stop marker, or the stop line on its stdout), a
+// clean end and a start that failed end this process too. The server's stdout
+// and stderr also go to DATA_HOME/data/server-stdout.log and server-stderr.log.
 function startServer() {
   const serverPath = resolve(PACKAGE_ROOT, 'neural-interface', 'server.js');
   const niDir = resolve(PACKAGE_ROOT, 'neural-interface');
   const setupComplete = isSetupComplete();
 
-  // Clear any stale marker from a previous run so we do not respawn on a
-  // clean exit from this child.
-  try { if (existsSync(RESTART_MARKER)) unlinkSync(RESTART_MARKER); } catch {}
-
   info('Starting Neural Interface server...');
   console.log('');
 
-  // Capture the server's stdout/stderr to log files so diagnostics survive
-  // regardless of how the supervisor itself was launched (Apps dropdown, manual
-  // `node setup.js`, or launchd). Previously logs only reached the launching
-  // terminal — when started outside a terminal they were lost, leaving
-  // data/server-*.log frozen at the last launchd run. Rotate at 50MB so capture
-  // never grows unbounded.
-  const LOG_DIR = resolve(DATA_HOME, 'data');
-  const STDOUT_LOG = resolve(LOG_DIR, 'server-stdout.log');
-  const STDERR_LOG = resolve(LOG_DIR, 'server-stderr.log');
-  try { mkdirSync(LOG_DIR, { recursive: true }); } catch {}
-  const rotateIfLarge = (p) => {
-    try { if (existsSync(p) && statSync(p).size > 50 * 1024 * 1024) renameSync(p, p + '.1'); } catch {}
-  };
-  rotateIfLarge(STDOUT_LOG);
-  rotateIfLarge(STDERR_LOG);
-  let outLog = null, errLog = null;
-  try { outLog = createWriteStream(STDOUT_LOG, { flags: 'a' }); } catch (e) { warn(`Could not open stdout log: ${e.message}`); }
-  try { errLog = createWriteStream(STDERR_LOG, { flags: 'a' }); } catch (e) { warn(`Could not open stderr log: ${e.message}`); }
-  // A full disk reports asynchronously from WriteStream.write(). Without an
-  // error listener that event terminates the supervisor itself, even though
-  // the child server's persistence paths already handle ENOSPC. Disable only
-  // the affected capture stream and keep the server console/supervision alive.
-  const disableLogStream = (kind, stream, error) => {
-    if (kind === 'stdout' && outLog === stream) outLog = null;
-    if (kind === 'stderr' && errLog === stream) errLog = null;
-    warn(`Could not persist ${kind} server log: ${error.message} — continuing without file capture.`);
-    try { stream.destroy(); } catch {}
-  };
-  const stdoutLog = outLog;
-  const stderrLog = errLog;
-  stdoutLog?.on('error', (error) => disableLogStream('stdout', stdoutLog, error));
-  stderrLog?.on('error', (error) => disableLogStream('stderr', stderrLog, error));
-  const stamp = `\n===== supervisor start ${new Date().toISOString()} (pid ${process.pid}) =====\n`;
-  try { outLog?.write(stamp); errLog?.write(stamp); } catch {}
-
-  let firstLaunch = true;
-  let currentChild = null;
-  let shuttingDown = false;
-  // The port the server last said it listens on: where a restart's report is read.
-  let listenPort = null;
-  const restartLog = [];
-  const CRASH_WINDOW_MS = 60_000;
-  const CRASH_LIMIT = 5;
-
-  // A restart that ends without a server keeps saying why until the page that
-  // waits for it has read it (a moment; 20 s at the most when nobody reads).
-  const exitAfterReport = (code, error) => {
-    const report = restartReport;
-    if (!report?.open) { process.exit(code); return; }
-    report.failed(error).finally(() => process.exit(code));
-  };
-
-  function spawnOnce() {
-    const child = spawn(process.execPath, ['--disable-warning=ExperimentalWarning', '--max-old-space-size=6144', serverPath], {
-      cwd: niDir,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      windowsHide: !!packagedRuntime(),
-      env: {
-        ...process.env,
-        SYNABUN_DATA_HOME: DATA_HOME,
-        MEMORY_DATA_DIR: resolve(DATA_HOME, 'mcp-data'),
-        SYNABUN_SUPERVISED: '1',
-      },
-    });
-    currentChild = child;
-    startPhase('server', { pid: child.pid });
-    child.on('error', (error) => {
-      fail(`Could not start the server: ${error.message}`);
-      startFailed('SERVER_SPAWN_FAILED', `the server could not be started: ${error.message}`);
-      exitAfterReport(1, { code: 'SERVER_SPAWN_FAILED', message: `the server could not be started: ${error.message}` });
-    });
-
-    let opened = !firstLaunch;
-    let announced = false;
-    child.stdout.on('data', (data) => {
-      const s = data.toString();
-      process.stdout.write(s);
-      try { outLog?.write(s); } catch {}
-      // The server prints its address from its listen callback: it is up.
-      if (!announced && s.includes('Server:')) {
-        announced = true;
-        const port = Number(s.match(/Server:\s+http:\/\/localhost:(\d+)/)?.[1]) || undefined;
-        if (port) listenPort = port;
-        startPhase('listening', { port });
-      }
-      if (!opened && s.includes('Server:')) {
-        opened = true;
-        const port = s.match(/Server:\s+http:\/\/localhost:(\d+)/)?.[1] || '3344';
-        const url = `http://localhost:${port}${setupComplete ? '/' : '/onboarding.html'}`;
-        // The Start Server button already has a tab waiting for the server.
-        if (process.env.SYNABUN_OPEN_BROWSER !== '0') setTimeout(() => openBrowser(url), 1500);
-      }
-    });
-    child.stderr.on('data', (data) => {
-      const s = data.toString();
-      process.stderr.write(s);
-      try { errLog?.write(s); } catch {}
-    });
-
-    child.on('exit', (code) => {
-      currentChild = null;
-      if (shuttingDown) return;
-
-      // Treat a present marker file the same as exit code 75. Native module
-      // crashes during shutdown can clobber the exit code; the marker keeps
-      // restart reliable in that case.
-      let restartRequested = code === RESTART_EXIT_CODE;
-      if (!restartRequested && existsSync(RESTART_MARKER)) {
-        restartRequested = true;
-        info(`Server exited with code ${code} but restart marker present — respawning.`);
-      }
-      try { if (existsSync(RESTART_MARKER)) unlinkSync(RESTART_MARKER); } catch {}
-
-      if (restartRequested) {
-        if (code === RESTART_EXIT_CODE) info('Server requested restart — respawning...');
-        const now = Date.now();
-        restartLog.push(now);
-        while (restartLog.length && now - restartLog[0] > CRASH_WINDOW_MS) restartLog.shift();
-        // The page that asked for this has no server to ask now: from here
-        // until the new one is listening, this supervisor says what happens.
+  const supervision = superviseServer({
+    serverPath,
+    cwd: niDir,
+    dataHome: DATA_HOME,
+    windowsHide: !!packagedRuntime(),
+    print: { info, warn, fail },
+    onPhase: startPhase,
+    onFailed: startFailed,
+    onListening: ({ port, first }) => {
+      // Only the first start opens a page: a server started again finds its pages open, and they reconnect.
+      if (!first) return;
+      const url = `http://localhost:${port || 3344}${setupComplete ? '/' : '/onboarding.html'}`;
+      // The Start Server button already has a tab waiting for the server.
+      if (process.env.SYNABUN_OPEN_BROWSER !== '0') setTimeout(() => openBrowser(url), 1500);
+    },
+    // A page that waits for the server while it is away has no server to ask: from the moment it exited to be
+    // started again until the new one is listening, this supervisor says what happens on the start beacon
+    // (lib/start-launcher.js openRestartReport). A supervisor that ends without a server says why there first.
+    reports: {
+      reopen(port) {
         try { restartReport?.close(); } catch {}
-        restartReport = openRestartReport({ port: listenPort || resolvePort({ dataHome: DATA_HOME }), dataHome: DATA_HOME, exited: true });
-        if (restartLog.length > CRASH_LIMIT) {
-          const message = `the server restarted ${restartLog.length} times in ${Math.round(CRASH_WINDOW_MS / 1000)} s`;
-          fail(`Server restarted ${restartLog.length} times in ${Math.round(CRASH_WINDOW_MS / 1000)}s — aborting supervisor.`);
-          startFailed('RESTART_LOOP', message);
-          exitAfterReport(1, { code: 'RESTART_LOOP', message });
-          return;
-        }
-        firstLaunch = false;
-        setTimeout(spawnOnce, 250);
-        return;
-      }
-
-      if (code !== 0 && code !== null) {
-        fail(`Server exited with code ${code}`);
-        startFailed('SERVER_EXITED', `the server exited with code ${code}`, { exitCode: code });
-        exitAfterReport(code, { code: 'SERVER_EXITED', message: `the server exited with code ${code}`, exitCode: code });
-        return;
-      }
-      process.exit(0);
-    });
-  }
-
-  spawnOnce();
-
-  const stop = (sig) => {
-    shuttingDown = true;
-    if (currentChild) {
-      try { currentChild.kill(sig); } catch {}
-    }
-    process.exit(0);
-  };
-  process.on('SIGINT', () => stop('SIGINT'));
-  process.on('SIGTERM', () => stop('SIGTERM'));
-}
-
-// ── CLI: profile subcommand ──
-
-const TOOL_GROUPS = {
-  memory:            { label: 'Memory',     tools: 6, alwaysOn: true },
-  category:          { label: 'Categories', tools: 1, alwaysOn: true },
-  sync:              { label: 'Sync',       tools: 1, alwaysOn: true },
-  loop:              { label: 'Loop',       tools: 1, alwaysOn: true },
-  profile:           { label: 'Profile',    tools: 1, alwaysOn: true },
-  git:               { label: 'Git',        tools: 1  },
-  image:             { label: 'Images',     tools: 1  },
-  whiteboard:        { label: 'Whiteboard', tools: 5  },
-  card:              { label: 'Cards',      tools: 5  },
-  tictactoe:         { label: 'TicTacToe',  tools: 1  },
-  browser:           { label: 'Browser',    tools: 18 },
-  browser_twitter:   { label: 'Twitter/X',  tools: 1  },
-  browser_facebook:  { label: 'Facebook',   tools: 1  },
-  browser_tiktok:    { label: 'TikTok',     tools: 4  },
-  browser_whatsapp:  { label: 'WhatsApp',   tools: 2  },
-  browser_instagram: { label: 'Instagram',  tools: 5  },
-  browser_linkedin:  { label: 'LinkedIn',   tools: 8  },
-  leonardo:          { label: 'Leonardo',   tools: 5  },
-  discord:           { label: 'Discord',    tools: 8  },
-  gsc:               { label: 'Google Search Console', tools: 30 },
-};
-
-function readRegistry(dataHome) {
-  const registryPath = resolve(dataHome, 'data', 'mcp-registry.json');
-  try {
-    if (existsSync(registryPath)) return JSON.parse(readFileSync(registryPath, 'utf-8'));
-  } catch {}
-  return null;
-}
-
-function getProfiles(dataHome) {
-  const registry = readRegistry(dataHome);
-  if (registry?.profiles) return registry.profiles;
-  // Fallback defaults
-  return {
-    core:       { label: 'Core',       groups: ['git', 'image'] },
-    standard:   { label: 'Standard',   groups: ['git', 'image', 'whiteboard', 'card', 'tictactoe'] },
-    twitter:    { label: 'Twitter/X',  groups: ['git', 'image', 'browser', 'browser_twitter'] },
-    facebook:   { label: 'Facebook',   groups: ['git', 'image', 'browser', 'browser_facebook'] },
-    tiktok:     { label: 'TikTok',     groups: ['git', 'image', 'browser', 'browser_tiktok'] },
-    whatsapp:   { label: 'WhatsApp',   groups: ['git', 'image', 'browser', 'browser_whatsapp'] },
-    instagram:  { label: 'Instagram',  groups: ['git', 'image', 'browser', 'browser_instagram'] },
-    linkedin:   { label: 'LinkedIn',   groups: ['git', 'image', 'browser', 'browser_linkedin'] },
-    discord:    { label: 'Discord',    groups: ['git', 'image', 'discord'] },
-    browser:    { label: 'Browser',    groups: ['git', 'image', 'whiteboard', 'card', 'tictactoe', 'browser', 'browser_twitter', 'browser_facebook', 'browser_tiktok', 'browser_whatsapp', 'browser_instagram', 'browser_linkedin', 'leonardo', 'gsc'] },
-    full:       { label: 'Full',       groups: ['git', 'image', 'whiteboard', 'card', 'tictactoe', 'browser', 'browser_twitter', 'browser_facebook', 'browser_tiktok', 'browser_whatsapp', 'browser_instagram', 'browser_linkedin', 'leonardo', 'discord', 'gsc'] },
-    leonardoai: { label: 'LeonardoAI', groups: ['leonardo'] },
-    gsc:        { label: 'GSC',        groups: ['git', 'image', 'browser', 'gsc'] },
-  };
-}
-
-function countProfileTools(groups) {
-  const alwaysOn = Object.values(TOOL_GROUPS).filter(g => g.alwaysOn).reduce((s, g) => s + g.tools, 0);
-  const groupTools = (groups || []).reduce((s, g) => s + (TOOL_GROUPS[g]?.tools || 0), 0);
-  return alwaysOn + groupTools;
-}
-
-function getCurrentProfile(dataHome) {
-  const profilePath = resolve(dataHome, 'data', 'active-profile.json');
-  try {
-    if (existsSync(profilePath)) {
-      const data = JSON.parse(readFileSync(profilePath, 'utf-8'));
-      if (data.profile) return data.profile;
-    }
-  } catch {}
-  return 'full';
-}
-
-function writeProfile(dataHome, profileName) {
-  const payload = JSON.stringify({ profile: profileName }, null, 2) + '\n';
-
-  // Write to data/active-profile.json (Neural Interface reads this)
-  const niPath = resolve(dataHome, 'data', 'active-profile.json');
-  const niDir = resolve(niPath, '..');
-  if (!existsSync(niDir)) mkdirSync(niDir, { recursive: true });
-  writeFileSync(niPath, payload, 'utf-8');
-
-  // Write to mcp-data/active-profile.json (MCP server watches this)
-  const mcpPath = resolve(dataHome, 'mcp-data', 'active-profile.json');
-  const mcpDir = resolve(mcpPath, '..');
-  if (!existsSync(mcpDir)) mkdirSync(mcpDir, { recursive: true });
-  writeFileSync(mcpPath, payload, 'utf-8');
+        restartReport = openRestartReport({ port, dataHome: DATA_HOME, exited: true });
+      },
+      async failed(error) {
+        const report = restartReport;
+        if (report?.open) await report.failed(error);
+      },
+    },
+    resolvePort: () => resolvePort({ dataHome: DATA_HOME }),
+  });
+  process.on('SIGINT', () => supervision.stop('SIGINT'));
+  process.on('SIGTERM', () => supervision.stop('SIGTERM'));
 }
 
-function handleProfileCommand(dataHome) {
-  const sub = process.argv[3];
-  const profiles = getProfiles(dataHome);
-  const current = getCurrentProfile(dataHome);
-
-  // synabun profile  OR  synabun profile list
-  if (!sub || sub === 'list') {
-    console.log('');
-    console.log(`  ${c.bold}Available MCP Profiles${c.reset}`);
-    console.log('');
-    for (const [name, prof] of Object.entries(profiles)) {
-      const label = prof.label || name;
-      const tools = countProfileTools(prof.groups);
-      const active = name === current ? ` ${c.green}← active${c.reset}` : '';
-      const groups = (prof.groups || []).join(', ');
-      console.log(`  ${c.cyan}${name.padEnd(14)}${c.reset} ${c.dim}${label.padEnd(12)}${c.reset} ~${String(tools).padStart(2)} tools  ${c.dim}[${groups}]${c.reset}${active}`);
-    }
-    console.log('');
-    console.log(`  ${c.dim}Usage: synabun profile set <name>${c.reset}`);
-    console.log('');
-    return;
-  }
-
-  // synabun profile get
-  if (sub === 'get') {
-    const prof = profiles[current];
-    const tools = prof ? countProfileTools(prof.groups) : '?';
-    console.log('');
-    console.log(`  ${c.bold}Current Profile:${c.reset} ${c.cyan}${current}${c.reset}  (~${tools} tools)`);
-    if (prof?.groups) console.log(`  ${c.dim}Groups: ${prof.groups.join(', ')}${c.reset}`);
-    console.log('');
-    return;
-  }
-
-  // synabun profile set <name>
-  if (sub === 'set') {
-    const name = process.argv[4]?.toLowerCase().trim();
-    if (!name) {
-      fail('Missing profile name. Usage: synabun profile set <name>');
-      console.log(`  ${c.dim}Run "synabun profile list" to see available profiles.${c.reset}`);
-      process.exit(1);
-    }
-    if (!profiles[name]) {
-      fail(`Unknown profile "${name}"`);
-      console.log('');
-      console.log(`  ${c.dim}Available profiles:${c.reset} ${Object.keys(profiles).join(', ')}`);
-      process.exit(1);
-    }
-    writeProfile(dataHome, name);
-    const prof = profiles[name];
-    const tools = countProfileTools(prof.groups);
-    ok(`Profile set to ${c.cyan}${name}${c.reset} (${prof.label}, ~${tools} tools)`);
-    console.log(`  ${c.dim}Groups: ${prof.groups.join(', ')}${c.reset}`);
-    console.log('');
-    console.log(`  ${c.dim}Running MCP servers will pick up the change automatically.${c.reset}`);
-    return;
-  }
-
-  fail(`Unknown subcommand "${sub}". Usage: synabun profile [list|get|set <name>]`);
-  process.exit(1);
+// ── synabun help ──
+
+function usage(version) {
+  return [
+    '',
+    `  ${c.bold}SynaBun v${version}${c.reset}: persistent memory for AI coding tools`,
+    '',
+    '  synabun                    start SynaBun: the Neural Interface on port 3344 (or NEURAL_PORT),',
+    '                             with the setup wizard on the first start',
+    '  synabun mcp                the MCP server on stdio, for an AI tool\'s MCP config:',
+    '                             "command": "synabun", "args": ["mcp"]',
+    '                             stdout carries the protocol only; logs go to stderr',
+    '  synabun doctor [--json]    the state of your data and your tool connections',
+    '  synabun tools [list | get | set <ids>]',
+    '                             SynaBun groups and default tools for future runtimes',
+    '  synabun migrate-data [--apply | --choose external|legacy]',
+    '                             copy an older install\'s data into the data folder (a dry run without --apply)',
+    '  synabun restore-backup --from <backup.zip> [--apply]',
+    '                             check a backup; --apply restores it',
+    '  synabun version            the installed version',
+    '  synabun help               this list',
+    '',
+    `  Data folder: ${DATA_HOME} (SYNABUN_DATA_HOME sets another)`,
+    '  Docs: https://synabun.ai/docs',
+    '',
+  ].join('\n');
 }
 
 // ── Main ──
@@ -792,10 +553,24 @@ async function main() {
 
   // ── Subcommand routing (before setup flow) ──
   const cmd = process.argv[2];
-  if (cmd === 'profile') {
-    handleProfileCommand(DATA_HOME);
+  if (cmd === MCP_COMMAND) {
+    // `synabun mcp` is started by bin/synabun.js without this file; this is
+    // `node setup.js mcp`, which must not print the banner on stdout either.
+    runNode(nodeArgs(process.argv.slice(2)), { env: LAUNCH_ENV, forwardSignals: true });
+    return;
+  }
+  if (cmd === 'help' || cmd === '--help' || cmd === '-h') {
+    console.log(usage(version));
     process.exit(0);
   }
+  if (cmd === 'profile') {
+    console.error('synabun profile was removed; use synabun tools [list | get | set <ids>].');
+    process.exit(1);
+  }
+  if (cmd === 'tools') {
+    const { runToolsCommand } = await import('./lib/tools-cli.js');
+    process.exit(runToolsCommand(process.argv.slice(3), { dataHome: DATA_HOME }));
+  }
   if (cmd === 'migrate-data') {
     handleMigrateDataCommand();
     process.exit(0);