synabun 2026.4.26-beta.5 → 2026.4.26-beta.6

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 });
   }
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synabun",
-  "version": "2026.4.26-beta.5",
+  "version": "2026.4.26-beta.6",
   "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/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