synabun 2026.4.26-beta.5 → 2026.4.26-beta.7

package/neural-interface/server.js

@@ -1637,9 +1637,12 @@ app.post('/api/server/shutdown', async (req, res) => {
 
 // POST /api/system/run-update — Click-to-update flow for npm-installed users.
 //
-// Spawns updater.mjs in a NEW visible terminal window (cmd on Windows,
-// Terminal.app on macOS, x-terminal-emulator/gnome-terminal/konsole/xterm
-// fallback on Linux). The updater:
+// Spawns the per-OS updater shim (updater.cmd on Windows, updater.sh on
+// macOS/Linux) in a NEW visible terminal window. Each shim invokes
+// updater.mjs and handles its own "press a key to close" lifecycle so we
+// don't have to thread cmd /k or bash -c quoting through node's spawn.
+//
+// The updater shim:
 //   1. Waits for the server PID to exit
 //   2. Runs `npm install -g synabun@<tag>`
 //   3. Optionally relaunches synabun
@@ -1647,8 +1650,8 @@ app.post('/api/server/shutdown', async (req, res) => {
 //
 // Right after spawning the detached updater, we run gracefulShutdown +
 // process.exit so file handles in neural-interface/ release and npm's
-// rename succeeds. The updater handles waiting on us — it only starts npm
-// after our PID is gone.
+// rename succeeds. The updater polls our PID and only starts npm after
+// we're gone.
 app.post('/api/system/run-update', async (req, res) => {
   try {
     const tag = String((req.body?.tag || 'latest')).replace(/[^a-zA-Z0-9_.-]/g, '');
@@ -1658,73 +1661,148 @@ app.post('/api/system/run-update', async (req, res) => {
       return res.status(400).json({ error: `tag must be one of: ${[...allowedTags].join(', ')}` });
     }
 
-    const updaterPath = resolve(PACKAGE_ROOT, 'updater.mjs');
-    if (!existsSync(updaterPath)) {
-      return res.status(500).json({ error: `updater.mjs not found at ${updaterPath}. SynaBun install may be corrupt.` });
+    const plat = process.platform;
+    const shimPath = plat === 'win32'
+      ? resolve(PACKAGE_ROOT, 'updater.cmd')
+      : resolve(PACKAGE_ROOT, 'updater.sh');
+    const updaterMjsPath = resolve(PACKAGE_ROOT, 'updater.mjs');
+
+    if (!existsSync(updaterMjsPath)) {
+      return res.status(500).json({ error: `updater.mjs not found at ${updaterMjsPath}. SynaBun install may be corrupt — reinstall: npm install -g synabun@${tag}` });
+    }
+    if (!existsSync(shimPath)) {
+      return res.status(500).json({ error: `${plat === 'win32' ? 'updater.cmd' : 'updater.sh'} not found at ${shimPath}. SynaBun install may be corrupt — reinstall: npm install -g synabun@${tag}` });
+    }
+
+    // On Unix, ensure the shim is executable. npm publish preserves the
+    // executable bit only if it was set when packed; defensive chmod here
+    // covers users whose tarball lost it (some Windows-staged pipelines do).
+    if (plat !== 'win32') {
+      try { chmodSync(shimPath, 0o755); } catch {}
     }
 
     const serverPid = process.pid;
     const argsBase = ['--tag', tag, '--pid', String(serverPid)];
     if (autoRestart) argsBase.push('--restart');
 
-    const plat = process.platform;
     let spawned = null;
+    let launchError = null;
 
     if (plat === 'win32') {
-      // `cmd /c start "<title>" cmd /k "node <updater> ..."` opens a new
-      // visible cmd window that stays open after the script finishes (/k).
-      const nodeExe = process.execPath;
-      const cmdLine = `"${nodeExe}" "${updaterPath}" ${argsBase.map(a => `"${a}"`).join(' ')}`;
-      spawned = spawn('cmd', ['/c', 'start', '"SynaBun Update"', 'cmd', '/k', cmdLine], {
-        detached: true, stdio: 'ignore', windowsHide: false, shell: false,
-      });
+      // Use shell:true so cmd parses our string directly — bypasses node's
+      // arg-escape algorithm that was mangling the title arg ("SynaBun
+      // Update" was being eaten by start's title slot, leaving Windows to
+      // try to launch "Update" as a program).
+      //
+      // `start "" "<shim>" args` — empty title (cmd's start ALWAYS treats
+      // the first quoted arg as a title), then runs the .cmd shim with
+      // args. The shim handles its own pause-before-close.
+      const argsLine = argsBase.map(a => `"${String(a).replace(/"/g, '""')}"`).join(' ');
+      const cmdLine = `start "" "${shimPath}" ${argsLine}`;
+      try {
+        spawned = spawn(cmdLine, {
+          shell: true,
+          detached: true,
+          stdio: 'ignore',
+          windowsHide: false,
+        });
+      } catch (err) { launchError = err; }
     } else if (plat === 'darwin') {
-      // Use osascript to drive Terminal.app — opens a visible window the
-      // user can watch. Escape internal quotes for AppleScript string.
-      const nodeExe = process.execPath;
-      const cmd = `${JSON.stringify(nodeExe)} ${JSON.stringify(updaterPath)} ${argsBase.map(a => JSON.stringify(a)).join(' ')}`;
-      const escaped = cmd.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-      spawned = spawn('osascript', [
-        '-e', `tell application "Terminal" to activate`,
-        '-e', `tell application "Terminal" to do script "${escaped}"`,
-      ], { detached: true, stdio: 'ignore' });
+      // Drive Terminal.app via osascript. The shim path may contain spaces;
+      // wrap it in single quotes inside the AppleScript string. AppleScript
+      // string is wrapped in JS double-quote, so we escape JS backslashes
+      // and double-quotes after building the inner shell command.
+      const shellEscape = (s) => `'${String(s).replace(/'/g, `'\\''`)}'`;
+      const appleCmd = `${shellEscape(shimPath)} ${argsBase.map(shellEscape).join(' ')}`;
+      try {
+        spawned = spawn('osascript', [
+          '-e', 'tell application "Terminal" to activate',
+          '-e', `tell application "Terminal" to do script "${appleCmd.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`,
+        ], { detached: true, stdio: 'ignore' });
+      } catch (err) { launchError = err; }
     } else {
-      // Linux — try common terminal emulators in order, fall back to xterm.
-      const nodeExe = process.execPath;
-      const inner = `${nodeExe} ${updaterPath} ${argsBase.join(' ')}; echo; echo '[Press Enter to close]'; read`;
+      // Linux/BSD/etc — try common terminal emulators in order. Each gets
+      // the shim path as the program to run; the shim itself is a bash
+      // script so we let the terminal exec it directly without bash -c.
       const candidates = [
-        ['x-terminal-emulator', ['-e', `bash -c "${inner.replace(/"/g, '\\"')}"`]],
-        ['gnome-terminal', ['--', 'bash', '-c', inner]],
-        ['konsole', ['-e', 'bash', '-c', inner]],
-        ['xfce4-terminal', ['-e', `bash -c "${inner.replace(/"/g, '\\"')}"`]],
-        ['xterm', ['-e', 'bash', '-c', inner]],
+        ['x-terminal-emulator', ['-e', shimPath, ...argsBase]],
+        ['gnome-terminal',      ['--', shimPath, ...argsBase]],
+        ['konsole',             ['-e', shimPath, ...argsBase]],
+        ['xfce4-terminal',      ['-e', `${shimPath} ${argsBase.map(a => `"${a}"`).join(' ')}`]],
+        ['mate-terminal',       ['-e', `${shimPath} ${argsBase.map(a => `"${a}"`).join(' ')}`]],
+        ['lxterminal',          ['-e', shimPath, ...argsBase]],
+        ['terminator',          ['-e', `${shimPath} ${argsBase.map(a => `"${a}"`).join(' ')}`]],
+        ['alacritty',           ['-e', shimPath, ...argsBase]],
+        ['kitty',               [shimPath, ...argsBase]],
+        ['wezterm',             ['start', '--', shimPath, ...argsBase]],
+        ['urxvt',               ['-e', shimPath, ...argsBase]],
+        ['xterm',               ['-e', shimPath, ...argsBase]],
       ];
       for (const [bin, args] of candidates) {
+        let child = null;
         try {
-          spawned = spawn(bin, args, { detached: true, stdio: 'ignore' });
-          break;
-        } catch {}
+          child = spawn(bin, args, { detached: true, stdio: 'ignore' });
+        } catch {
+          continue;
+        }
+        // spawn() doesn't throw synchronously when bin is missing — it emits
+        // 'error' async (ENOENT). Probe briefly to detect that case before
+        // declaring success and unrefing.
+        const survived = await new Promise((resolveProbe) => {
+          let settled = false;
+          const onErr = () => {
+            if (settled) return;
+            settled = true;
+            child.removeAllListeners('error');
+            resolveProbe(false);
+          };
+          child.once('error', onErr);
+          setTimeout(() => {
+            if (settled) return;
+            settled = true;
+            child.removeAllListeners('error');
+            resolveProbe(true);
+          }, 150);
+        });
+        if (survived) { spawned = child; break; }
       }
       if (!spawned) {
-        return res.status(500).json({ error: 'No supported terminal emulator found. Install xterm or run `npm install -g synabun@' + tag + '` manually.' });
+        launchError = new Error(
+          'No supported terminal emulator found (tried: x-terminal-emulator, gnome-terminal, konsole, xfce4-terminal, mate-terminal, lxterminal, terminator, alacritty, kitty, wezterm, urxvt, xterm). ' +
+          `Install one (e.g. \`apt install xterm\`) or run manually: npm install -g synabun@${tag}`
+        );
       }
     }
 
+    if (!spawned) {
+      const msg = launchError?.message || `Failed to launch updater terminal on ${plat}`;
+      console.error('[server] run-update launch failed:', msg);
+      return res.status(500).json({ error: msg });
+    }
+
+    // Don't tie our shutdown to the spawned process — it's a long-living
+    // terminal we don't want to wait on.
     spawned.unref();
-    console.log(`[server] Updater terminal launched (tag=${tag}, autoRestart=${autoRestart}). Shutting down...`);
-    res.json({ ok: true, tag, autoRestart, updaterPath });
+    spawned.on('error', (err) => {
+      // Async ENOENT etc. — log but the response already went out.
+      console.error('[server] updater spawn async error:', err.message);
+    });
+
+    console.log(`[server] Updater terminal launched (tag=${tag}, autoRestart=${autoRestart}, shim=${shimPath}). Shutting down...`);
+    res.json({ ok: true, tag, autoRestart, shimPath, platform: plat });
 
     // Give the spawned terminal time to fully launch before we tear down
-    // (on Windows, `start` returns instantly but the new window takes a
-    // beat to actually init node). 1.2s is generous; updater polls our PID
-    // anyway so an extra second here is harmless.
+    // (on Windows `start` returns instantly but the new window takes a
+    // beat to init node; on macOS osascript dispatches AppleScript async).
+    // 1.2s is generous; updater polls our PID anyway so an extra second
+    // here is harmless.
     setTimeout(async () => {
       await gracefulShutdown('run-update');
       process.exit(0);
     }, 1200);
   } catch (err) {
     console.error('[server] run-update error:', err?.message);
-    res.status(500).json({ error: err.message });
+    if (!res.headersSent) res.status(500).json({ error: err.message });
   }
 });
 
@@ -4431,12 +4509,36 @@ function stopOpencodeServer() {
   stopOpencodeSSERelay();
   const managedPid = readOpencodeManagedPid();
   const procPid = _ocpProc?.pid || null;
+  const isWin = process.platform === 'win32';
+
+  // On Windows `process.kill(pid, 'SIGTERM')` is unreliable for non-Node
+  // children (cmd.exe shells, opencode native binaries). Use taskkill /T /F
+  // to walk the process tree and force-terminate every descendant.
+  // This is the recurring source of EBUSY errors during `npm install -g
+  // synabun@latest` — opencode-ai's `serve` process survives parent SynaBun
+  // exit and keeps file handles inside neural-interface/ open.
+  const winKill = (pid) => {
+    try {
+      spawn('taskkill', ['/pid', String(pid), '/T', '/F'], {
+        shell: true, windowsHide: true, stdio: 'ignore',
+      });
+    } catch {}
+  };
+
   if (_ocpProc && !_ocpProc.killed) {
-    try { _ocpProc.kill(); } catch {}
+    if (isWin && procPid) {
+      winKill(procPid);
+    } else {
+      try { _ocpProc.kill(); } catch {}
+    }
     _ocpProc = null;
   }
   if (managedPid && managedPid !== procPid) {
-    signalPids([managedPid], 'SIGTERM');
+    if (isWin) {
+      winKill(managedPid);
+    } else {
+      signalPids([managedPid], 'SIGTERM');
+    }
   }
   clearOpencodeManagedPid();
   _ocpReady = false;
@@ -23509,6 +23611,21 @@ function saveSessionSnapshot() {
 setInterval(saveSessionSnapshot, SESSION_SNAPSHOT_INTERVAL_MS);
 
 // Also try to save on clean shutdown (works with Ctrl+C, not window close)
-process.on('SIGINT', () => { stopOpencodeServer(); saveSessionSnapshot(); process.exit(0); });
-process.on('SIGTERM', () => { stopOpencodeServer(); saveSessionSnapshot(); process.exit(0); });
-process.on('exit', () => { stopOpencodeServer(); saveSessionSnapshot(); });
+// Manual termination paths (Ctrl+C, kill, parent shell exit) all flow through
+// gracefulShutdown — same teardown the in-app restart/shutdown/update paths
+// use. Without this, hand-killed servers still leave orphaned opencode +
+// agent children holding file handles, which blocks `npm install -g synabun`.
+process.on('SIGINT', async () => {
+  console.log('\n[server] SIGINT received.');
+  await gracefulShutdown('sigint');
+  process.exit(0);
+});
+process.on('SIGTERM', async () => {
+  console.log('\n[server] SIGTERM received.');
+  await gracefulShutdown('sigterm');
+  process.exit(0);
+});
+// `exit` fires after process.exit() — only safe for synchronous final tasks.
+// gracefulShutdown is async so we cannot await here; just snapshot + ocp stop
+// best-effort. The async paths above are the primary teardown.
+process.on('exit', () => { try { stopOpencodeServer(); } catch {} try { saveSessionSnapshot(); } catch {} });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synabun",
-  "version": "2026.4.26-beta.5",
+  "version": "2026.4.26-beta.7",
   "description": "Persistent vector memory for AI assistants",
   "license": "Apache-2.0",
   "author": "The SynaBun Authors",
@@ -18,6 +18,8 @@
     "postinstall.js",
     "preuninstall.js",
     "updater.mjs",
+    "updater.cmd",
+    "updater.sh",
     "mcp-server/package.json",
     "mcp-server/dist/",
     "mcp-server/tsconfig.json",

package/postinstall.js

@@ -197,6 +197,25 @@ function registerProtocolHandler() {
   }
 }
 
+// ── 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}"`);
+  }
+}
+
 // ── Main ──
 
 function main() {
@@ -207,6 +226,7 @@ function main() {
   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

@@ -69,6 +69,80 @@ async function tryGracefulServerShutdown() {
   }
 }
 
+// ── 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.
+    // Filter for our install path (escape backslashes for the -like wildcard).
+    // Stop-Process -Force kills synchronously; -ErrorAction SilentlyContinue
+    // suppresses "process already exited" noise.
+    const escaped = installPath.replace(/\\/g, '\\\\').replace(/'/g, `''`);
+    const ps = `
+$ErrorActionPreference = 'SilentlyContinue';
+Get-CimInstance Win32_Process |
+  Where-Object {
+    $_.ProcessId -ne ${selfPid} -and (
+      ($_.CommandLine -and $_.CommandLine -like '*${escaped}*') -or
+      ($_.ExecutablePath -and $_.ExecutablePath -like '${escaped}*')
+    )
+  } |
+  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,
+      });
+    } 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 = [

package/updater.cmd

@@ -0,0 +1,31 @@
+@echo off
+setlocal enableextensions
+title SynaBun Updater
+
+rem ───────────────────────────────────────────────────────
+rem Windows shim for the cross-platform updater (updater.mjs).
+rem Invoked by the running SynaBun server via:
+rem   start "" "<install>\updater.cmd" --tag X --pid Y [--restart]
+rem
+rem We use a shim instead of spawning node directly so cmd's
+rem quoting rules don't mangle the command line, and so the
+rem window stays open for the user to read npm output even
+rem if node exits unexpectedly.
+rem ───────────────────────────────────────────────────────
+
+set "SCRIPT_DIR=%~dp0"
+set "EXIT_CODE=0"
+
+rem %~dp0 ends with backslash. updater.mjs lives next to this file.
+node "%SCRIPT_DIR%updater.mjs" %*
+set EXIT_CODE=%ERRORLEVEL%
+
+echo.
+if %EXIT_CODE%==0 (
+  echo [Update finished. Press any key to close this window.]
+) else (
+  echo [Update exited with code %EXIT_CODE%. Press any key to close this window.]
+)
+pause >nul
+
+endlocal ^& exit /b %EXIT_CODE%

package/updater.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+# ───────────────────────────────────────────────────────
+# Unix shim for the cross-platform updater (updater.mjs).
+# Invoked by the running SynaBun server inside a fresh
+# terminal window — keeps the terminal open after node
+# exits so the user can read npm output and any errors.
+# ───────────────────────────────────────────────────────
+
+set +e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+NODE_BIN="${SYNABUN_NODE_BIN:-node}"
+
+# Pretty terminal title (no-op in some terminals).
+printf '\033]0;SynaBun Updater\007' 2>/dev/null || true
+
+"$NODE_BIN" "$SCRIPT_DIR/updater.mjs" "$@"
+EXIT_CODE=$?
+
+echo
+if [ "$EXIT_CODE" = "0" ]; then
+  echo "[Update finished. Press Enter to close this window.]"
+else
+  echo "[Update exited with code $EXIT_CODE. Press Enter to close this window.]"
+fi
+# Read one line. If stdin is closed (e.g. piped run), fall through immediately.
+read -r _ || true
+
+exit $EXIT_CODE