@chatpanel/bridge 0.2.12 → 0.2.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/bridge",
-  "version": "0.2.12",
+  "version": "0.2.13",
   "type": "module",
   "description": "Local bridge that exposes the AI coding agents installed on your machine — Claude Code (CLI), Codex (CLI), and Gemini CLI — to the ChatPanel Chrome extension over a localhost SSE endpoint. Bring your own agent.",
   "keywords": [

package/src/server.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 // ChatPanel Bridge — a tiny localhost server that exposes the coding agents
-// running on this machine (Claude Code via the Agent SDK, Codex and Gemini via
-// their CLIs) to the ChatPanel Chrome extension. Zero runtime dependencies
-// beyond the optional Claude Agent SDK.
+// running on this machine (Claude Code, Codex and Gemini, each via its CLI) to
+// the ChatPanel Chrome extension. Zero runtime dependencies.
 //
-//   GET  /health  → { ok, version, agents: [{id,label,available,reason}] }
+//   GET  /health  → { ok, version, agents: [...], update: {current,latest,…} }
+//   POST /update  → self-update to the latest release (compiled binary installs)
 //   POST /chat    → Server-Sent Events stream of { type, ... }:
 //                     {type:'delta', text}    incremental assistant text
 //                     {type:'tool',  name, summary}
@@ -19,10 +19,11 @@ import os from 'node:os';
 import * as claude from './engines/claude.js';
 import * as codex from './engines/codex.js';
 import * as gemini from './engines/gemini.js';
-import { installService, uninstallService, serviceStatus } from './service.js';
+import { installService, uninstallService, serviceStatus, restartService } from './service.js';
 import { enrichPath, findAgentBin } from './env.js';
+import { checkForUpdate, selfUpdate } from './update.js';
 
-const VERSION = '0.2.12';
+const VERSION = '0.2.13';
 const HOST = process.env.CHATPANEL_BRIDGE_HOST || '127.0.0.1';
 const PORT = Number(process.env.CHATPANEL_BRIDGE_PORT) || 4319;
 
@@ -81,7 +82,20 @@ async function handleHealth(res) {
       return { id, label, available: a.ok, reason: a.reason };
     }),
   );
-  json(res, 200, { ok: true, version: VERSION, agents });
+  const update = await checkForUpdate(VERSION).catch(() => ({ current: VERSION, updateAvailable: false }));
+  json(res, 200, { ok: true, version: VERSION, agents, update });
+}
+
+// POST /update — self-update (compiled-binary installs). Swaps the binary, replies,
+// then restarts the service into the new version. npm installs get instructions.
+async function handleUpdate(res) {
+  try {
+    const result = await selfUpdate(VERSION); // throws on npm install / no update / failure
+    json(res, 200, { ok: true, updated: true, from: result.from, to: result.to });
+    res.on('finish', () => setTimeout(() => restartService(), 400));
+  } catch (e) {
+    json(res, 400, { ok: false, error: String(e?.message || e) });
+  }
 }
 
 async function handleChat(req, res) {
@@ -187,6 +201,7 @@ const server = createServer(async (req, res) => {
     }
     if (req.method === 'POST' && url.pathname === '/chat') return handleChat(req, res);
     if (req.method === 'POST' && url.pathname === '/complete') return handleComplete(req, res);
+    if (req.method === 'POST' && url.pathname === '/update') return handleUpdate(res);
     json(res, 404, { error: 'Not found' });
   } catch (e) {
     json(res, 500, { error: e?.message || String(e) });
@@ -218,6 +233,7 @@ Usage:
   chatpanel-bridge --install    run automatically at login, in the background
   chatpanel-bridge --uninstall  remove the login auto-start
   chatpanel-bridge --status     show whether auto-start is set up
+  chatpanel-bridge --update     download & install the latest version, then restart
   chatpanel-bridge --version    print the version
 
 Env: CHATPANEL_BRIDGE_HOST, CHATPANEL_BRIDGE_PORT`);
@@ -269,4 +285,17 @@ function runCli() {
   return false;
 }
 
-if (!runCli()) startServer();
+if (process.argv.includes('--update')) {
+  (async () => {
+    try {
+      const r = await selfUpdate(VERSION);
+      log('info', `Updated v${r.from} → v${r.to}. Restarting the background service…`);
+      restartService();
+    } catch (e) {
+      log('error', 'Update failed: ' + (e?.message || e));
+      process.exitCode = 1;
+    }
+  })();
+} else if (!runCli()) {
+  startServer();
+}

package/src/service.js

@@ -12,7 +12,7 @@
 import os from 'node:os';
 import path from 'node:path';
 import { mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
-import { spawnSync } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 
 const LABEL = 'net.chatpanel.bridge';
 const DISPLAY = 'ChatPanel Bridge';
@@ -157,3 +157,37 @@ export function uninstallService() {
 export function serviceStatus() {
   return byPlatform(macStatus, winStatus, linStatus);
 }
+
+// Restart the installed service into a freshly-swapped binary (used by self-
+// update). Detached so it survives the restart killing the caller — works whether
+// invoked from inside the service (POST /update) or a CLI `--update`.
+//   • macOS  — `launchctl kickstart -k` kills + relaunches the LaunchAgent.
+//   • Linux  — `systemctl --user restart`.
+//   • Windows — kill the running bridge, wait ~2s (port frees), relaunch via the
+//               hidden VBS, then delete the renamed old-*.exe.
+export function restartService() {
+  try {
+    if (process.platform === 'darwin') {
+      const uid = typeof process.getuid === 'function' ? process.getuid() : 0;
+      spawn('launchctl', ['kickstart', '-k', `gui/${uid}/${LABEL}`], { detached: true, stdio: 'ignore' }).unref();
+      return true;
+    }
+    if (process.platform === 'linux') {
+      spawn('systemctl', ['--user', 'restart', 'chatpanel-bridge'], { detached: true, stdio: 'ignore' }).unref();
+      return true;
+    }
+    if (process.platform === 'win32') {
+      const vbs = winVbs();
+      const dir = path.dirname(process.execPath);
+      const cmd =
+        `taskkill /IM chatpanel-bridge.exe /F >nul 2>&1 & ` +
+        `timeout /t 2 >nul & wscript.exe "${vbs}" & ` +
+        `del /q "${path.join(dir, 'chatpanel-bridge.old-*.exe')}" >nul 2>&1`;
+      spawn('cmd', ['/c', cmd], { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+      return true;
+    }
+  } catch {
+    /* fall through */
+  }
+  return false;
+}

package/src/update.js

@@ -0,0 +1,154 @@
+// In-app updater for the standalone binary.
+//
+// The bridge is a background service the user never opens, so the EXTENSION
+// surfaces "update available" (from /health) and offers a one-click Update that
+// calls POST /update. The bridge downloads the new binary, swaps it in, and the
+// service relaunches into the new version.
+//
+// Cross-platform swap + relaunch (users come from anywhere):
+//   • macOS  — atomic rename over the running file; KeepAlive relaunches on exit.
+//   • Linux  — atomic rename; `systemctl --user restart` relaunches.
+//   • Windows — can't overwrite a running .exe, so we RENAME the running exe aside
+//               and drop the new one in its place, then a detached helper waits for
+//               this process to exit (freeing the port) and relaunches it.
+//
+// No-ops for npx/node installs — npm owns those; only compiled binaries self-update.
+
+import os from 'node:os';
+import path from 'node:path';
+import { chmod, rename, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { isCompiledBinary } from './env.js';
+
+const REPO = 'chatpanel/chatpanel-bridge';
+const LATEST_API = `https://api.github.com/repos/${REPO}/releases/latest`;
+const CHECK_EVERY_MS = 6 * 60 * 60 * 1000; // 6h
+const CACHE = path.join(os.homedir(), '.chatpanel', 'update-check.json');
+const UA = { 'User-Agent': 'chatpanel-bridge-updater' };
+
+// Release asset name for THIS platform (matches release-binaries.yml outputs).
+// macOS publishes arm64 only; Intel Macs use `npx` (managed → no self-update).
+function assetName() {
+  if (process.platform === 'darwin') return process.arch === 'arm64' ? 'chatpanel-bridge-macos-arm64' : null;
+  if (process.platform === 'linux') return 'chatpanel-bridge-linux-x64';
+  if (process.platform === 'win32') return 'chatpanel-bridge-windows-x64.exe';
+  return null;
+}
+
+function parseVersion(s = '') {
+  const m = /(\d+(?:\.\d+){0,3})/.exec(s || '');
+  return m ? m[1] : null;
+}
+// >0 if a is newer than b.
+function cmp(a, b) {
+  const pa = String(a).split('.').map(Number);
+  const pb = String(b).split('.').map(Number);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const d = (pa[i] || 0) - (pb[i] || 0);
+    if (d) return d > 0 ? 1 : -1;
+  }
+  return 0;
+}
+
+async function readCache() {
+  try {
+    return JSON.parse(await readFile(CACHE, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+async function writeCache(obj) {
+  try {
+    await mkdir(path.dirname(CACHE), { recursive: true });
+    await writeFile(CACHE, JSON.stringify(obj));
+  } catch {
+    /* best effort */
+  }
+}
+
+// Returns { current, latest, updateAvailable, mode, canSelfUpdate, assetUrl, npmCommand }.
+//   mode 'binary' → compiled standalone build (macOS/Linux curl install, or the
+//                   optional Windows .exe). POST /update self-replaces in place.
+//   mode 'npm'    → npx/node install (the default on Windows). The bridge can't
+//                   swap its own files; the extension shows `npmCommand` instead.
+// Both report updateAvailable so the user always gets the notice — only the action
+// differs. Throttled to CHECK_EVERY_MS unless `force`.
+export async function checkForUpdate(current, { force = false } = {}) {
+  const mode = isCompiledBinary() ? 'binary' : 'npm';
+  const want = assetName();
+
+  let latest = null;
+  let assetUrl = null;
+  const cache = await readCache();
+  if (!force && cache && Date.now() - cache.checkedAt < CHECK_EVERY_MS) {
+    latest = cache.latest;
+    assetUrl = cache.assetUrl;
+  } else {
+    try {
+      const res = await fetch(LATEST_API, { headers: { Accept: 'application/vnd.github+json', ...UA } });
+      if (res.ok) {
+        const data = await res.json();
+        latest = parseVersion(data.tag_name) || parseVersion(data.name);
+        assetUrl = want ? (data.assets || []).find((a) => a.name === want)?.browser_download_url || null : null;
+        await writeCache({ checkedAt: Date.now(), latest, assetUrl });
+      } else {
+        latest = cache?.latest || null;
+        assetUrl = cache?.assetUrl || null;
+      }
+    } catch {
+      latest = cache?.latest || null;
+      assetUrl = cache?.assetUrl || null;
+    }
+  }
+  const updateAvailable = !!latest && cmp(latest, current) > 0;
+  // One-click in-place update is only possible for a compiled binary with a
+  // matching release asset; npm installs update via the command.
+  const canSelfUpdate = mode === 'binary' && !!assetUrl;
+  return {
+    current,
+    latest,
+    updateAvailable,
+    mode,
+    canSelfUpdate,
+    assetUrl,
+    npmCommand: mode === 'npm' ? 'npm i -g @chatpanel/bridge@latest' : null,
+  };
+}
+
+// Download the latest binary and swap it in. Does NOT restart — the caller sends
+// its HTTP response first, then triggers restartService(). Throws on any failure,
+// leaving the running binary untouched.
+export async function selfUpdate(current) {
+  if (!isCompiledBinary()) {
+    throw new Error('Self-update applies only to the standalone binary. Update the npm/npx version with npm.');
+  }
+  const info = await checkForUpdate(current, { force: true });
+  if (!info.assetUrl) throw new Error('No downloadable build for this platform — use `npx @chatpanel/bridge`.');
+  if (!info.updateAvailable) {
+    throw new Error(info.latest ? `Already on the latest version (v${current}).` : 'Could not reach the update server.');
+  }
+
+  const target = process.execPath; // the running binary's own path
+  const dir = path.dirname(target);
+  const tmp = path.join(dir, `.chatpanel-bridge.new-${Date.now()}`);
+
+  const res = await fetch(info.assetUrl, { headers: UA });
+  if (!res.ok || !res.body) throw new Error(`Download failed (${res.status}).`);
+  const buf = Buffer.from(await res.arrayBuffer());
+  if (buf.length < 1_000_000) throw new Error('Downloaded file looks too small — aborting to avoid a broken bridge.');
+
+  await writeFile(tmp, buf);
+  if (process.platform !== 'win32') await chmod(tmp, 0o755);
+
+  if (process.platform === 'win32') {
+    // A running .exe can't be overwritten, but it CAN be renamed. Move it aside,
+    // drop the new one in place; the old (renamed) file is cleaned up after exit.
+    const aside = path.join(dir, `chatpanel-bridge.old-${Date.now()}.exe`);
+    await rename(target, aside);
+    await rename(tmp, target);
+  } else {
+    // POSIX: atomic rename over the running file. The live process keeps the old
+    // inode; the path now points at the new binary.
+    await rename(tmp, target);
+  }
+  return { ok: true, from: current, to: info.latest };
+}