synabun 1.3.0 → 2.0.0

package/postinstall.js

@@ -9,9 +9,11 @@
  */
 
 import { execSync } from 'node:child_process';
-import { existsSync, mkdirSync } from 'node:fs';
+import { existsSync, chmodSync } from 'node:fs';
 import { resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { platform } from 'node:os';
+import { registerStartLauncher } from './lib/start-launcher.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -31,27 +33,13 @@ function warn(msg) { console.log(`  ${c.yellow}!${c.reset} ${msg}`); }
 function fail(msg) { console.log(`  ${c.red}\u2717${c.reset} ${msg}`); }
 function info(msg) { console.log(`  ${c.cyan}\u2192${c.reset} ${msg}`); }
 
-// ── Ensure data directories exist ──
-
-function ensureDirectories() {
-  const dirs = [
-    resolve(__dirname, 'data'),
-    resolve(__dirname, 'mcp-server', 'data'),
-  ];
-  for (const dir of dirs) {
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-  }
-}
-
 // ── Dependency installation ──
 
 function needsInstall(dir) {
   return !existsSync(resolve(dir, 'node_modules', '.package-lock.json'));
 }
 
-function installDeps(name, dir) {
+function installDeps(name, dir, { includeDev = false } = {}) {
   if (!needsInstall(dir)) {
     ok(`${name} dependencies already installed`);
     return;
@@ -59,7 +47,8 @@ function installDeps(name, dir) {
 
   info(`Installing ${name} dependencies...`);
   try {
-    execSync('npm install', {
+    const omitFlag = includeDev ? '' : ' --omit=dev';
+    execSync(`npm install${omitFlag} --ignore-scripts`, {
       cwd: dir,
       stdio: 'inherit',
       timeout: 300_000,
@@ -72,6 +61,10 @@ function installDeps(name, dir) {
   }
 }
 
+function needsBuild() {
+  return !existsSync(resolve(__dirname, 'mcp-server', 'dist', 'index.js'));
+}
+
 // ── node-pty native rebuild ──
 
 function rebuildPty() {
@@ -103,18 +96,53 @@ function buildMcpServer() {
     return;
   }
 
-  info('Building MCP server...');
+  info('Building MCP server from source...');
   try {
-    execSync('npm run build', {
+    execSync('npx tsc', {
       cwd: resolve(__dirname, 'mcp-server'),
-      stdio: 'pipe',
-      timeout: 60_000,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 120_000,
     });
     ok('MCP server built');
   } catch (err) {
-    fail('MCP server build failed');
-    console.error(err.stderr?.toString() || err.message);
-    process.exit(1);
+    fail('MCP server build failed:');
+    const stdout = err.stdout?.toString().trim();
+    const stderr = err.stderr?.toString().trim();
+    if (stdout) console.error(stdout);
+    if (stderr) console.error(stderr);
+    if (!stdout && !stderr) console.error(err.message);
+  }
+}
+
+// ── Protocol handler registration ──
+//
+// The synabun:// handler behind the offline page's Start Server button. The
+// same registration runs on every start (setup.js), so this only makes the
+// button work before the first one.
+
+function registerProtocolHandler() {
+  const result = registerStartLauncher({ packageRoot: __dirname });
+  if (result.state === 'skipped') return;
+  if (result.ok) ok('Registered synabun:// protocol handler');
+  else warn(`Could not register synabun:// protocol handler (${result.errors[0]})`);
+}
+
+// ── Updater shim executable bit ──
+//
+// npm publish drops the executable bit on macOS/Linux when the tarball is
+// built on Windows (a common pipeline issue). The in-app updater needs
+// updater.sh to be executable so the per-OS terminal-launch path can
+// `exec()` it directly. Restore the bit defensively on every postinstall.
+
+function ensureUpdaterShExecutable() {
+  if (platform() === 'win32') return;
+  const shPath = resolve(__dirname, 'updater.sh');
+  if (!existsSync(shPath)) return;
+  try {
+    chmodSync(shPath, 0o755);
+    ok('updater.sh marked executable');
+  } catch (err) {
+    warn(`updater.sh chmod failed (${err.message}) — manual fix: chmod +x "${shPath}"`);
   }
 }
 
@@ -123,11 +151,12 @@ function buildMcpServer() {
 function main() {
   console.log(`\n  ${c.cyan}SynaBun${c.reset} ${c.dim}postinstall${c.reset}\n`);
 
-  ensureDirectories();
   installDeps('Neural Interface', resolve(__dirname, 'neural-interface'));
-  installDeps('MCP Server', resolve(__dirname, 'mcp-server'));
+  installDeps('MCP Server', resolve(__dirname, 'mcp-server'), { includeDev: needsBuild() });
   rebuildPty();
   buildMcpServer();
+  registerProtocolHandler();
+  ensureUpdaterShExecutable();
 
   console.log(`\n  ${c.green}\u2713${c.reset} Setup complete. Run ${c.cyan}synabun${c.reset} to start.\n`);
 }

package/preuninstall.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+
+/**
+ * SynaBun — NPM preuninstall script
+ *
+ * Runs before `npm uninstall synabun` AND before `npm i -g synabun@x`
+ * overwrites the existing install.
+ *
+ *   1. Politely ask any running SynaBun server to shut down so its child
+ *      processes (opencode sidecar, agents, pty terminals) release file
+ *      handles inside neural-interface/. Without this step, npm's rename
+ *      step fails with EBUSY on Windows.
+ *   2. Remove nested node_modules that cause EPERM/deep-path errors on Windows.
+ *   3. Remove the synabun:// protocol handler registration.
+ *
+ * Graceful — if any step fails, don't block the uninstall. npm will handle
+ * the remainder; the user can always retry.
+ */
+
+import { rmSync, existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execSync } from 'node:child_process';
+import { homedir, platform } from 'node:os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// ── Step 1: ask running SynaBun server to shut down cleanly ──
+// Default port 3344 (matches NEURAL_PORT default in server.js). If the user
+// changed NEURAL_PORT we miss them; that's acceptable since the next steps
+// degrade gracefully. We don't want to scan all ports — too invasive for a
+// preuninstall script.
+
+await tryGracefulServerShutdown();
+
+async function tryGracefulServerShutdown() {
+  const port = Number(process.env.NEURAL_PORT) || 3344;
+  const url = `http://127.0.0.1:${port}/api/server/shutdown`;
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 2000);
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: '{}',
+      signal: controller.signal,
+    });
+    clearTimeout(timeout);
+    if (!res.ok) return; // server returned but not OK — proceed anyway
+    // Wait for server to actually exit (poll with a HEAD request to /api/health
+    // or just sleep — sleep is simpler and uses no network).
+    for (let i = 0; i < 20; i++) {
+      await new Promise(r => setTimeout(r, 250));
+      try {
+        const ping = new AbortController();
+        const tt = setTimeout(() => ping.abort(), 500);
+        await fetch(`http://127.0.0.1:${port}/api/health`, { signal: ping.signal });
+        clearTimeout(tt);
+        // Still up — keep waiting.
+      } catch {
+        // Connection refused / aborted — server is gone.
+        break;
+      }
+    }
+    // Extra grace for child processes to release file handles on Windows.
+    await new Promise(r => setTimeout(r, 1500));
+  } catch {
+    // No server listening, fetch unavailable, etc. — just continue.
+  }
+}
+
+// ── Step 1b: kill any orphaned processes holding file handles ──
+//
+// Even after a graceful server shutdown (or when no server is running),
+// orphaned children can survive: opencode-ai sidecars spawned via cmd.exe,
+// MCP servers (claude-memory-mcp) spawned by Claude Code instances rather
+// than by SynaBun itself, agent processes, etc. On Windows these orphans
+// keep file handles inside the install dir open, causing EBUSY when npm
+// tries to rename it.
+//
+// We nuke any process whose command line references the SynaBun install
+// path. This catches every orphan regardless of how they got that way.
+// Skips the current PID (we are the preuninstall process itself).
+
+killOrphansInsideInstall();
+
+function killOrphansInsideInstall() {
+  const installPath = __dirname;
+  const selfPid = process.pid;
+  const plat = platform();
+
+  if (plat === 'win32') {
+    // PowerShell: Get-CimInstance returns every process with CommandLine.
+    // Pass the install path via env so this PowerShell command line does not
+    // itself contain the path we are trying to match and kill.
+    // Stop-Process -Force kills synchronously; -ErrorAction SilentlyContinue
+    // suppresses "process already exited" noise.
+    const ps = `
+$ErrorActionPreference = 'SilentlyContinue';
+$installPath = $env:SYNABUN_INSTALL_PATH;
+$selfPid = [int]$env:SYNABUN_PREUNINSTALL_PID;
+Get-CimInstance Win32_Process |
+  Where-Object {
+    $_.ProcessId -ne $selfPid -and
+    $_.ProcessId -ne $PID -and (
+      ($_.CommandLine -and $_.CommandLine -like "*$installPath*") -or
+      ($_.ExecutablePath -and $_.ExecutablePath -like "$installPath*")
+    )
+  } |
+  ForEach-Object {
+    Write-Host ('  Killing orphan PID ' + $_.ProcessId + ' (' + $_.Name + ')');
+    Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue
+  }
+	`.trim();
+    try {
+      execSync(`powershell -NoProfile -ExecutionPolicy Bypass -Command "${ps.replace(/"/g, '\\"').replace(/\n/g, ' ')}"`, {
+        stdio: 'inherit',
+        timeout: 8000,
+        env: {
+          ...process.env,
+          SYNABUN_INSTALL_PATH: installPath,
+          SYNABUN_PREUNINSTALL_PID: String(selfPid),
+        },
+      });
+    } catch {
+      // PowerShell unavailable, blocked, or timed out. Fall through.
+    }
+  } else {
+    // Unix: pgrep -f matches against the full command line. -P 1 skips
+    // self/children of init we shouldn't touch. We just enumerate then
+    // SIGKILL each one that isn't us.
+    try {
+      const out = execSync(`pgrep -f "${installPath.replace(/[/.*?+^$|(){}\\\[\]]/g, '\\$&')}"`, {
+        encoding: 'utf8',
+        timeout: 5000,
+      }).trim();
+      const pids = out.split('\n')
+        .map(s => Number(s.trim()))
+        .filter(n => Number.isFinite(n) && n > 0 && n !== selfPid);
+      for (const pid of pids) {
+        try { process.kill(pid, 'SIGKILL'); } catch {}
+      }
+    } catch {
+      // No matches or pgrep missing — fine.
+    }
+  }
+
+  // Brief grace for OS to release file handles after killing.
+  // Synchronous busy-wait so we run before the rmSync calls below.
+  const until = Date.now() + 1500;
+  while (Date.now() < until) { /* spin */ }
+}
+
+// ── Step 2: remove nested node_modules ──
+
+const dirs = [
+  resolve(__dirname, 'neural-interface', 'node_modules'),
+  resolve(__dirname, 'mcp-server', 'node_modules'),
+];
+
+for (const dir of dirs) {
+  try {
+    rmSync(dir, { recursive: true, force: true });
+  } catch {
+    // Non-fatal — npm will handle remaining cleanup
+  }
+}
+
+// ── Step 3: remove protocol handler ──
+
+const plat = platform();
+
+if (plat === 'win32') {
+  try {
+    execSync('reg delete "HKCU\\Software\\Classes\\synabun" /f', { stdio: 'pipe' });
+  } catch {}
+} else if (plat === 'darwin') {
+  const appPath = resolve(homedir(), '.synabun', 'SynaBun.app');
+  try {
+    rmSync(appPath, { recursive: true, force: true });
+  } catch {}
+} else {
+  const desktopFile = resolve(homedir(), '.local', 'share', 'applications', 'synabun.desktop');
+  try {
+    if (existsSync(desktopFile)) rmSync(desktopFile);
+  } catch {}
+}

package/scripts/restore-data-home-from-backup.mjs

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+
+/**
+ * Restore durable SynaBun state from a verified v2/v3 backup.
+ *
+ * The archive is fully checksum-verified before extraction. Restore happens in
+ * a sibling staging directory; the existing target is renamed (never deleted)
+ * immediately before the staged tree is atomically activated.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import { createHash } from 'node:crypto';
+import { DatabaseSync } from 'node:sqlite';
+import { basename, dirname, isAbsolute, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// Streaming reader: AdmZip buffered the whole archive, which Node refuses past
+// 2 GiB, so large data homes could be backed up but never restored.
+import {
+  extractZipEntry,
+  openZipArchive,
+  readBackupManifest,
+  verifyBackupChecksums,
+} from '../neural-interface/lib/backup-zip-reader.js';
+
+function pathIsInside(candidate, parent) {
+  const rel = relative(resolve(parent), resolve(candidate));
+  return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+}
+
+function timestamp(date) {
+  return date.toISOString().replace(/[:.]/g, '-');
+}
+
+/** Open the archive and stream-verify every checksum before anything is extracted. */
+async function parseArchive(backupPath) {
+  const zip = await openZipArchive(backupPath);
+  try {
+    const found = await readBackupManifest(zip);
+    if (!found || !found.prefix) throw new Error('Invalid backup: manifest.json is missing');
+    const { manifest, prefix } = found;
+    if (![2, 3].includes(manifest.version)) {
+      throw new Error(`Unsupported backup version: ${manifest.version}. Expected v2 or v3.`);
+    }
+    await verifyBackupChecksums(zip, { prefix, manifest, label: 'Invalid backup' });
+    return { zip, entries: zip.entries, manifest, prefix };
+  } catch (error) {
+    await zip.close().catch(() => {});
+    throw error;
+  }
+}
+
+function restoredRelativePath(entryName, prefix) {
+  const rel = entryName.slice(`${prefix}/`.length);
+  if (rel === 'env.bak') return '.env';
+  if (rel === 'database/memory.db') return 'mcp-data/memory.db';
+  if (rel.startsWith('data/') || rel.startsWith('mcp-data/')) return rel;
+  return null;
+}
+
+async function writeSelectedEntries({ zip, entries, prefix, stageRoot }) {
+  const selected = [];
+  for (const entry of entries) {
+    if (entry.isDirectory || !entry.name.startsWith(`${prefix}/`)) continue;
+    const rel = restoredRelativePath(entry.name, prefix);
+    if (!rel) continue;
+    const target = resolve(stageRoot, rel);
+    if (!pathIsInside(target, stageRoot) || target === resolve(stageRoot)) throw new Error(`Unsafe backup path: ${entry.name}`);
+    selected.push({ entry, rel, target });
+  }
+  for (const { entry, target } of selected) await extractZipEntry(zip, entry, target);
+  return [...new Set(selected.map(item => item.rel))].sort();
+}
+
+function normalizeEnv(stageRoot, targetRoot) {
+  const envPath = resolve(stageRoot, '.env');
+  const values = new Map([
+    ['SYNABUN_DATA_HOME', resolve(targetRoot)],
+    ['MEMORY_DATA_DIR', resolve(targetRoot, 'mcp-data')],
+    ['SQLITE_DB_PATH', resolve(targetRoot, 'mcp-data', 'memory.db')],
+    ['DOTENV_PATH', resolve(targetRoot, '.env')],
+  ]);
+  const original = existsSync(envPath) ? readFileSync(envPath, 'utf-8') : '';
+  const seen = new Set();
+  const lines = original.split(/\r?\n/).map(line => {
+    const match = line.match(/^(\s*(?:export\s+)?([A-Z][A-Z0-9_]*)\s*=\s*)(.*)$/);
+    if (!match || !values.has(match[2])) return line;
+    seen.add(match[2]);
+    return `${match[1]}${values.get(match[2])}`;
+  });
+  for (const [key, value] of values) {
+    if (!seen.has(key)) lines.push(`${key}=${value}`);
+  }
+  writeFileSync(envPath, `${lines.join('\n').replace(/^\n+|\n+$/g, '')}\n`, 'utf-8');
+}
+
+function walkJson(root, current = root, result = []) {
+  if (!existsSync(current)) return result;
+  const stat = statSync(current);
+  if (stat.isFile()) {
+    if (current.endsWith('.json')) result.push(current);
+    return result;
+  }
+  for (const name of readdirSync(current)) walkJson(root, resolve(current, name), result);
+  return result;
+}
+
+/**
+ * JSON that does not parse is restored exactly as it was backed up and
+ * reported. The checksums already proved these bytes match the archive, so a
+ * bad file here was bad in the source. One torn hook-state write
+ * (data/pending-remember/*.json) used to refuse the restore of a whole data home.
+ */
+function findInvalidJson(stageRoot) {
+  const invalid = [];
+  for (const path of walkJson(stageRoot)) {
+    try { JSON.parse(readFileSync(path, 'utf-8')); }
+    catch (error) { invalid.push({ path: relative(stageRoot, path), error: error.message }); }
+  }
+  return invalid;
+}
+
+function validateStage(stageRoot) {
+  const dbPath = resolve(stageRoot, 'mcp-data', 'memory.db');
+  if (!existsSync(dbPath)) throw new Error('Backup does not contain database/memory.db');
+  let database;
+  try {
+    database = new DatabaseSync(dbPath, { readOnly: true });
+    const integrityRow = database.prepare('PRAGMA integrity_check').get();
+    const integrity = integrityRow?.integrity_check || integrityRow?.integrity || 'unknown';
+    if (integrity !== 'ok') throw new Error(`SQLite integrity check returned: ${integrity}`);
+    const memories = Number(database.prepare('SELECT COUNT(*) AS count FROM memories').get()?.count || 0);
+    let categories = null;
+    try { categories = Number(database.prepare('SELECT COUNT(*) AS count FROM categories').get()?.count || 0); } catch {}
+    return { integrity, memories, categories, sizeBytes: statSync(dbPath).size };
+  } finally {
+    try { database?.close(); } catch {}
+  }
+}
+
+export async function restoreDataHomeFromBackup({
+  backupPath,
+  targetRoot,
+  legacyRoot = null,
+  apply = false,
+  now = () => new Date(),
+} = {}) {
+  if (!backupPath || !targetRoot) throw new Error('backupPath and targetRoot are required');
+  const backup = resolve(backupPath);
+  const target = resolve(targetRoot);
+  if (!existsSync(backup)) throw new Error(`Backup not found: ${backup}`);
+
+  const parsed = await parseArchive(backup);
+  const createdAt = now();
+  const targetName = basename(target).replace(/^\.+/, '') || 'synabun';
+  const parent = dirname(target);
+  const stage = resolve(parent, `.${targetName}.restore-stage-${process.pid}-${Date.now()}`);
+  const displacedTarget = resolve(parent, `.${targetName}.pre-restore-${timestamp(createdAt)}`);
+  let activated = false;
+  let targetMoved = false;
+  try {
+    mkdirSync(parent, { recursive: true });
+    mkdirSync(stage, { recursive: true });
+    const restoredFiles = await writeSelectedEntries({ ...parsed, stageRoot: stage });
+    normalizeEnv(stage, target);
+    const database = validateStage(stage);
+    const invalidJson = findInvalidJson(stage);
+    const existingManifest = existsSync(resolve(target, '.synabun-data-home.json'))
+      ? JSON.parse(readFileSync(resolve(target, '.synabun-data-home.json'), 'utf-8'))
+      : {};
+    const acknowledgedLegacyRoots = legacyRoot ? [resolve(legacyRoot)] : [];
+    const manifest = {
+      version: 1,
+      installationId: existingManifest.installationId || createHash('sha256').update(`${process.pid}:${Date.now()}:${Math.random()}`).digest('hex').slice(0, 32),
+      dataSchemaVersion: 1,
+      activatedAt: createdAt.toISOString(),
+      activationReason: 'verified-backup-restore',
+      restoredFrom: backup,
+      restoredBackupVersion: parsed.manifest.version,
+      restoredBackupCreatedAt: parsed.manifest.created || parsed.manifest.createdAt || null,
+      acknowledgedLegacyRoots,
+    };
+    writeFileSync(resolve(stage, '.synabun-data-home.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf-8');
+    const result = {
+      applied: false,
+      backupPath: backup,
+      targetRoot: target,
+      displacedTarget: existsSync(target) ? displacedTarget : null,
+      manifest: parsed.manifest,
+      database,
+      invalidJson,
+      restoredFiles,
+    };
+    if (!apply) return result;
+
+    if (existsSync(target)) {
+      renameSync(target, displacedTarget);
+      targetMoved = true;
+    }
+    renameSync(stage, target);
+    activated = true;
+    return { ...result, applied: true };
+  } catch (error) {
+    if (targetMoved && !existsSync(target) && existsSync(displacedTarget)) renameSync(displacedTarget, target);
+    throw error;
+  } finally {
+    await parsed.zip.close().catch(() => {});
+    if (!activated) rmSync(stage, { recursive: true, force: true });
+  }
+}
+
+function option(name) {
+  const index = process.argv.indexOf(name);
+  return index >= 0 ? process.argv[index + 1] : null;
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  try {
+    const result = await restoreDataHomeFromBackup({
+      backupPath: option('--backup') || option('--from'),
+      targetRoot: option('--target'),
+      legacyRoot: option('--legacy-root'),
+      apply: process.argv.includes('--apply'),
+    });
+    console.log(JSON.stringify(result, null, 2));
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+  }
+}