@khanglvm/llm-router 2.3.6 → 2.3.7

package/src/node/upgrade-command.js

@@ -2,14 +2,10 @@ import { execSync } from "node:child_process";
 import { readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import {
-  getActiveRuntimeState,
-  stopProcessByPid,
-  clearRuntimeState,
-  spawnDetachedStart
-} from "./instance-state.js";
+import { getActiveRuntimeState } from "./instance-state.js";
 
 const PKG_NAME = "@khanglvm/llm-router";
+const GRACEFUL_RESTART_SIGNAL = "SIGUSR2";
 
 function readInstalledVersion() {
   try {
@@ -21,41 +17,77 @@ function readInstalledVersion() {
   }
 }
 
-function fetchLatestVersion() {
+function fetchLatestVersion(exec = execSync) {
   try {
-    return execSync(`npm view ${PKG_NAME} version`, { encoding: "utf8" }).trim();
+    return exec(`npm view ${PKG_NAME} version`, { encoding: "utf8" }).trim();
   } catch {
     return null;
   }
 }
 
-function detectPackageManager() {
+function detectPackageManager(exec = execSync) {
   try {
-    const npmGlobalRoot = execSync("npm root -g", { encoding: "utf8" }).trim();
+    const npmGlobalRoot = exec("npm root -g", { encoding: "utf8" }).trim();
     const entryReal = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
     if (entryReal.startsWith(npmGlobalRoot)) return "npm";
-  } catch { /* ignore */ }
+  } catch {
+    // ignore
+  }
 
   try {
-    const out = execSync("pnpm list -g --json 2>/dev/null", { encoding: "utf8" });
+    const out = exec("pnpm list -g --json 2>/dev/null", { encoding: "utf8" });
     if (out.includes(PKG_NAME)) return "pnpm";
-  } catch { /* ignore */ }
+  } catch {
+    // ignore
+  }
 
   return "npm";
 }
 
-export async function runUpgradeCommand({ onLine, onError } = {}) {
+function requestGracefulRuntimeRestart(runtime, signalProcess = process.kill) {
+  const pid = Number(runtime?.pid);
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return { ok: false, reason: "Invalid runtime pid." };
+  }
+
+  try {
+    signalProcess(pid, GRACEFUL_RESTART_SIGNAL);
+    return { ok: true, signal: GRACEFUL_RESTART_SIGNAL };
+  } catch (restartError) {
+    return {
+      ok: false,
+      reason: restartError instanceof Error ? restartError.message : String(restartError)
+    };
+  }
+}
+
+export async function runUpgradeCommand({ onLine, onError } = {}, deps = {}) {
   const line = typeof onLine === "function" ? onLine : (msg) => console.log(msg);
   const error = typeof onError === "function" ? onError : (msg) => console.error(msg);
-
-  const currentVersion = readInstalledVersion();
+  const exec = typeof deps.exec === "function" ? deps.exec : execSync;
+  const readInstalledVersionFn = typeof deps.readInstalledVersion === "function"
+    ? deps.readInstalledVersion
+    : readInstalledVersion;
+  const fetchLatestVersionFn = typeof deps.fetchLatestVersion === "function"
+    ? deps.fetchLatestVersion
+    : () => fetchLatestVersion(exec);
+  const detectPackageManagerFn = typeof deps.detectPackageManager === "function"
+    ? deps.detectPackageManager
+    : () => detectPackageManager(exec);
+  const getActiveRuntimeStateFn = typeof deps.getActiveRuntimeState === "function"
+    ? deps.getActiveRuntimeState
+    : getActiveRuntimeState;
+  const signalProcess = typeof deps.signalProcess === "function"
+    ? deps.signalProcess
+    : process.kill;
+
+  const currentVersion = readInstalledVersionFn();
   line(`Current version: ${currentVersion}`);
 
-  // Check latest
   line("Checking for updates...");
-  const latestVersion = fetchLatestVersion();
+  const latestVersion = fetchLatestVersionFn();
   if (!latestVersion) {
-    error("Could not fetch latest version from npm registry.");
+    error("Could not fetch the latest version from the npm registry.");
     return { ok: false, exitCode: 1 };
   }
 
@@ -64,65 +96,61 @@ export async function runUpgradeCommand({ onLine, onError } = {}) {
     return { ok: true, exitCode: 0 };
   }
 
-  line(`New version available: ${currentVersion} → ${latestVersion}`);
+  line(`New version available: ${currentVersion} -> ${latestVersion}`);
 
-  // Stop running instance
-  let wasRunning = false;
-  let savedState = null;
+  let runtime = null;
   try {
-    const runtime = await getActiveRuntimeState();
-    if (runtime) {
-      wasRunning = true;
-      savedState = { ...runtime };
-      line(`Stopping running server (pid ${runtime.pid})...`);
-      const stopResult = await stopProcessByPid(runtime.pid);
-      if (stopResult.ok) {
-        await clearRuntimeState({ pid: runtime.pid });
-        line("Server stopped.");
-      } else {
-        error(`Warning: could not stop server cleanly — ${stopResult.reason || "unknown"}`);
-      }
-    }
+    runtime = await getActiveRuntimeStateFn();
   } catch {
-    // instance-state not available, skip
+    runtime = null;
   }
 
-  // Install latest
-  const pm = detectPackageManager();
+  if (runtime) {
+    line(`Running router detected (pid ${runtime.pid}) at http://${runtime.host}:${runtime.port}.`);
+    line("The router will keep serving current requests while the package upgrade runs.");
+  } else {
+    line("No running local router detected. The new version will be used on the next start.");
+  }
+
+  const pm = detectPackageManagerFn();
   const installCmd = pm === "pnpm"
     ? `pnpm add -g ${PKG_NAME}@latest`
     : `npm install -g ${PKG_NAME}@latest`;
 
   line(`Upgrading via: ${installCmd}`);
   try {
-    execSync(installCmd, { stdio: "inherit" });
+    exec(installCmd, { stdio: "inherit" });
   } catch {
-    error("Upgrade failed. You may need to run with sudo or fix npm permissions.");
+    error("Upgrade failed. The running router was left untouched. You may need sudo or corrected npm permissions.");
     return { ok: false, exitCode: 1 };
   }
 
-  const newVersion = fetchLatestVersion() || latestVersion;
-  line(`Upgraded to ${newVersion}.`);
-
-  // Restart server if it was running
-  if (wasRunning && savedState) {
-    line("Restarting server...");
-    try {
-      spawnDetachedStart({
-        cliPath: savedState.cliPath || "",
-        configPath: savedState.configPath || "",
-        host: savedState.host || "127.0.0.1",
-        port: savedState.port || 18080,
-        watchConfig: savedState.watchConfig ?? true,
-        watchBinary: savedState.watchBinary ?? true,
-        requireAuth: savedState.requireAuth ?? false,
-      });
-      line("Server restarted.");
-    } catch (err) {
-      error(`Could not restart server: ${err instanceof Error ? err.message : String(err)}`);
-      line("Start manually with: llr start");
-    }
+  line(`Upgraded package to ${latestVersion}.`);
+
+  if (!runtime) {
+    return { ok: true, exitCode: 0 };
+  }
+
+  const restartResult = requestGracefulRuntimeRestart(runtime, signalProcess);
+  if (restartResult.ok) {
+    line(`Requested a graceful router reload (pid ${runtime.pid}).`);
+    line("Existing requests will drain before the new version takes over.");
+    return { ok: true, exitCode: 0 };
+  }
+
+  error(`Could not trigger an immediate graceful router reload: ${restartResult.reason || "unknown error"}`);
+  if (runtime.watchBinary) {
+    line("The running router is still serving traffic and should self-reload when its binary watcher detects the new version.");
+  } else {
+    line("Binary update watch is disabled for the running router. Restart it manually with `llr start` to activate the new version.");
   }
 
   return { ok: true, exitCode: 0 };
 }
+
+export {
+  detectPackageManager,
+  fetchLatestVersion,
+  readInstalledVersion,
+  requestGracefulRuntimeRestart
+};