mobygate 0.5.3 → 0.6.1

package/lib/updater.js

@@ -0,0 +1,275 @@
+/**
+ * mobygate updater
+ *
+ * Shared helpers powering the dashboard's "update available → update now"
+ * flow (and re-usable from the CLI later). Two concerns:
+ *
+ *   1. Version lookup — read local package.json + query npm registry for
+ *      the latest published version. Cached for 15 min so the dashboard
+ *      can poll `/update/check` on load + every 30 min without hammering
+ *      the registry (or getting rate-limited).
+ *
+ *   2. Apply — spawn the upgrade as a **detached** child process so the
+ *      restart-the-service step can kill the running mobygate server
+ *      without orphaning the update or losing log lines. Progress is
+ *      streamed to `~/.mobygate/logs/update.log`, which the dashboard
+ *      polls via `/update/status`.
+ *
+ * Install-mode routing matches `bin/mobygate.js cmdUpdate`:
+ *   - `npm` → `npm install -g mobygate@latest` → restart service
+ *   - `git` → `git pull && npm install`        → restart service
+ *   - `unknown` → refuse, surface a readable message
+ */
+
+import { spawn, spawnSync } from 'child_process';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, openSync } from 'fs';
+import { join, sep, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { LOGS_DIR } from './config.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const REPO_ROOT = dirname(dirname(__filename)); // lib/updater.js → repo root
+
+const IS_WIN = process.platform === 'win32';
+const IS_MAC = process.platform === 'darwin';
+const IS_LINUX = process.platform === 'linux';
+
+const SERVER_LABEL = 'ai.mobygate.server';
+const WIN_SERVER_TASK = 'ai.mobygate.server';
+const LINUX_SERVER_UNIT = 'mobygate-server.service';
+
+const UPDATE_LOG = join(LOGS_DIR, 'update.log');
+const UPDATE_MARKER = join(LOGS_DIR, 'update.state.json');
+
+// ---------------------------------------------------------------------------
+// Version lookup
+// ---------------------------------------------------------------------------
+
+export function getCurrentVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(join(REPO_ROOT, 'package.json'), 'utf8'));
+    return pkg.version;
+  } catch {
+    return 'unknown';
+  }
+}
+
+export function detectInstallMode() {
+  if (existsSync(join(REPO_ROOT, '.git'))) return 'git';
+  if (REPO_ROOT.includes(`${sep}node_modules${sep}mobygate`)) return 'npm';
+  return 'unknown';
+}
+
+// 15-min in-memory cache so `/update/check` on dashboard load + 30-min
+// repolls don't hit the npm registry every time. Bust with { force: true }.
+const NPM_CACHE_MS = 15 * 60 * 1000;
+let _npmCache = { version: null, fetchedAt: 0, error: null };
+
+/**
+ * Resolve the latest published version on npm. Returns `{ version, cached, error }`.
+ * Never throws — on failure returns an error string so the endpoint can
+ * report "check failed" without 500'ing the dashboard.
+ */
+export async function getLatestVersion({ force = false } = {}) {
+  const now = Date.now();
+  if (!force && _npmCache.version && (now - _npmCache.fetchedAt) < NPM_CACHE_MS) {
+    return { version: _npmCache.version, cached: true, error: null };
+  }
+  // `npm view` is a network call; cap at 10s so a bad connection doesn't
+  // wedge the dashboard.
+  const r = spawnSync('npm', ['view', 'mobygate', 'version'], {
+    encoding: 'utf8',
+    timeout: 10_000,
+    shell: IS_WIN, // on Windows, npm is a .cmd — needs shell resolution
+  });
+  if (r.status !== 0) {
+    const err = r.stderr?.trim() || r.error?.message || `npm exited ${r.status}`;
+    _npmCache = { version: null, fetchedAt: now, error: err };
+    return { version: null, cached: false, error: err };
+  }
+  const version = r.stdout.trim();
+  _npmCache = { version, fetchedAt: now, error: null };
+  return { version, cached: false, error: null };
+}
+
+/**
+ * Compare two semver-ish strings (x.y.z). Returns -1/0/1.
+ * Non-numeric suffixes (`-beta.1`) are ignored for simplicity — this
+ * matches what the registry returns for mobygate's release channel.
+ */
+export function compareVersions(a, b) {
+  const pa = String(a).split('-')[0].split('.').map((n) => parseInt(n, 10) || 0);
+  const pb = String(b).split('-')[0].split('.').map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+  }
+  return 0;
+}
+
+export async function getUpdateCheck({ force = false } = {}) {
+  const current = getCurrentVersion();
+  const mode = detectInstallMode();
+  const { version: latest, cached, error } = await getLatestVersion({ force });
+  const updateAvailable = !!latest && compareVersions(latest, current) > 0;
+  return {
+    current,
+    latest: latest || null,
+    updateAvailable,
+    installMode: mode,
+    checkedAt: new Date().toISOString(),
+    cached,
+    error,
+    // If the install layout can't self-update, surface it so the UI can
+    // show "run manually" instead of a live-updating button.
+    canApply: updateAvailable && (mode === 'npm' || mode === 'git'),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Apply
+// ---------------------------------------------------------------------------
+
+function ensureLogsDir() {
+  if (!existsSync(LOGS_DIR)) mkdirSync(LOGS_DIR, { recursive: true });
+}
+
+export function readUpdateState() {
+  if (!existsSync(UPDATE_MARKER)) return { running: false, startedAt: null, finishedAt: null, exitCode: null, pid: null };
+  try { return JSON.parse(readFileSync(UPDATE_MARKER, 'utf8')); } catch { return { running: false, error: 'marker-unreadable' }; }
+}
+
+export function readUpdateLogTail({ lines = 500 } = {}) {
+  if (!existsSync(UPDATE_LOG)) return [];
+  try {
+    const raw = readFileSync(UPDATE_LOG, 'utf8');
+    const split = raw.split(/\r?\n/);
+    return split.slice(-lines - 1, -1);
+  } catch { return []; }
+}
+
+function writeUpdateState(patch) {
+  ensureLogsDir();
+  const prev = readUpdateState();
+  const merged = { ...prev, ...patch, updatedAt: new Date().toISOString() };
+  writeFileSync(UPDATE_MARKER, JSON.stringify(merged, null, 2));
+  return merged;
+}
+
+/**
+ * Build the shell command that performs update + restart. Returned as a
+ * single string we can hand to `sh -c` / `cmd /c`. Written as a string
+ * (not an array) because we want shell redirection for log capture.
+ */
+function buildUpdateCommand({ mode, repoRoot, logPath }) {
+  if (IS_WIN) {
+    // cmd.exe — `>>` for append, `2>&1` to merge. Each step on its own
+    // line so failures short-circuit via `||`.
+    const steps = [];
+    steps.push(`echo [mobygate-update] start at %DATE% %TIME%`);
+    if (mode === 'npm') {
+      steps.push(`npm install -g mobygate@latest`);
+    } else if (mode === 'git') {
+      steps.push(`cd /d "${repoRoot}"`);
+      steps.push(`git pull --ff-only`);
+      steps.push(`npm install`);
+    }
+    steps.push(`echo [mobygate-update] restarting service`);
+    steps.push(`schtasks /End   /TN "${WIN_SERVER_TASK}"`);
+    steps.push(`schtasks /Run   /TN "${WIN_SERVER_TASK}"`);
+    steps.push(`echo [mobygate-update] done`);
+    // Join with && so any failure stops the chain. Final redirect to log.
+    const inner = steps.map((s) => `(${s})`).join(' && ');
+    return { shell: 'cmd', cmd: `${inner} >> "${logPath}" 2>&1` };
+  }
+  // POSIX: sh -c, bail-on-first-failure via set -e
+  const parts = [`set -e`, `echo "[mobygate-update] start $(date)"`];
+  if (mode === 'npm') {
+    parts.push(`npm install -g mobygate@latest`);
+  } else if (mode === 'git') {
+    parts.push(`cd "${repoRoot}"`);
+    parts.push(`git pull --ff-only`);
+    parts.push(`npm install`);
+  }
+  parts.push(`echo "[mobygate-update] restarting service"`);
+  if (IS_MAC) {
+    const plist = join(process.env.HOME || '~', 'Library', 'LaunchAgents', `${SERVER_LABEL}.plist`);
+    // unload may fail if not loaded — tolerate that specific case
+    parts.push(`launchctl unload "${plist}" 2>/dev/null || true`);
+    parts.push(`launchctl load   "${plist}"`);
+  } else if (IS_LINUX) {
+    parts.push(`systemctl --user restart ${LINUX_SERVER_UNIT}`);
+  }
+  parts.push(`echo "[mobygate-update] done"`);
+  const script = parts.join('\n');
+  return { shell: 'sh', cmd: script };
+}
+
+/**
+ * Kick off the update in a **detached** child process. The running
+ * mobygate server returns immediately and is then killed by the restart
+ * step. The dashboard polls `/update/status` to see progress, and the
+ * new server comes up with the upgraded code.
+ *
+ * Returns `{ started, pid, error }` — never throws. If another update
+ * is already running, returns `{ started: false, error: 'in-progress' }`.
+ */
+export function applyUpdate({ mode, repoRoot = REPO_ROOT } = {}) {
+  const resolvedMode = mode || detectInstallMode();
+  if (resolvedMode !== 'npm' && resolvedMode !== 'git') {
+    return { started: false, error: `install-mode ${resolvedMode} can't auto-update` };
+  }
+
+  ensureLogsDir();
+  const prev = readUpdateState();
+  if (prev.running && prev.pid) {
+    // Treat unknown-alive PIDs as in-progress. Dead PIDs fall through.
+    let alive = false;
+    try { process.kill(prev.pid, 0); alive = true; } catch {}
+    if (alive) return { started: false, error: 'update-already-running', pid: prev.pid };
+  }
+
+  // Truncate the log so each update starts fresh (the old content is
+  // still available via `mobygate logs` up to the boundary).
+  writeFileSync(UPDATE_LOG, '');
+
+  const { shell, cmd } = buildUpdateCommand({ mode: resolvedMode, repoRoot, logPath: UPDATE_LOG });
+
+  let child;
+  try {
+    if (shell === 'cmd') {
+      // Windows: use cmd.exe /c; redirection is inside cmd string.
+      child = spawn('cmd.exe', ['/c', cmd], {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+      });
+    } else {
+      // POSIX: use sh -c; redirect stdout/stderr into the log file via Node
+      // (simpler than embedding `>>` into the script, and avoids quoting
+      // headaches across macOS sh versions).
+      const fd = openSync(UPDATE_LOG, 'a');
+      child = spawn('sh', ['-c', cmd], {
+        detached: true,
+        stdio: ['ignore', fd, fd],
+      });
+    }
+    child.unref();
+  } catch (e) {
+    return { started: false, error: `spawn failed: ${e.message}` };
+  }
+
+  writeUpdateState({
+    running: true,
+    startedAt: new Date().toISOString(),
+    finishedAt: null,
+    exitCode: null,
+    pid: child.pid,
+    mode: resolvedMode,
+  });
+
+  // We don't await the child — it's detached and will outlive us. The
+  // dashboard determines completion by polling /update/status, which
+  // checks `process.kill(pid, 0)` to test liveness.
+  return { started: true, pid: child.pid, mode: resolvedMode };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobygate",
-  "version": "0.5.3",
+  "version": "0.6.1",
   "description": "OpenAI-compatible local proxy for Claude Max. The Möbius-strip gateway: OpenAI shape in, Claude Max out.",
   "type": "module",
   "main": "server.js",