@khanglvm/llm-router 2.2.3 → 2.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@khanglvm/llm-router",
-  "version": "2.2.3",
+  "version": "2.2.5",
   "description": "LLM Router: single gateway endpoint for multi-provider LLMs with unified OpenAI+Anthropic format and seamless fallback",
   "keywords": [
     "llm-router",

package/src/cli/router-module.js

@@ -8481,6 +8481,11 @@ async function runWebAction(context) {
     routerRequireAuth: toBoolean(readArg(args, ["router-require-auth", "routerRequireAuth"], false), false),
     allowRemoteClients: toBoolean(readArg(args, ["allow-remote-clients", "allowRemoteClients"], false), false),
     cliPathForRouter: process.argv[1],
+    onPortConflict: canPrompt() && typeof context?.prompts?.confirm === "function"
+      ? ({ port }) => context.prompts.confirm({
+        message: `Port ${port} is already in use. Kill the existing listener and reclaim the port?`
+      })
+      : undefined,
     onLine: (line) => context.terminal.line(line),
     onError: (line) => context.terminal.error(line)
   });

package/src/cli-entry.js

@@ -9,6 +9,7 @@ import { FIXED_LOCAL_ROUTER_HOST, FIXED_LOCAL_ROUTER_PORT } from "./node/local-s
 import { resolveListenPort } from "./node/listen-port.js";
 import { runStartCommand } from "./node/start-command.js";
 import { runWebCommand } from "./node/web-command.js";
+import { runUpgradeCommand } from "./node/upgrade-command.js";
 
 function parseSimpleArgs(argv) {
   const positional = [];
@@ -198,6 +199,14 @@ export async function runCli(argv = process.argv.slice(2), isTTY = undefined, ov
     return runWebFastPath(configArgs.args, runWebCommandImpl);
   }
 
+  if ((first === "upgrade" || first === "update") && !parsed.wantsHelp) {
+    const result = await runUpgradeCommand({
+      onLine: (msg) => console.log(msg),
+      onError: (msg) => console.error(msg)
+    });
+    return result.exitCode ?? (result.ok ? 0 : 1);
+  }
+
   if (firstIsSetup && !parsed.wantsHelp) {
     const setupArgs = argv.slice(1);
     const parsedSetup = parseSimpleArgs(setupArgs);

package/src/node/upgrade-command.js

@@ -0,0 +1,128 @@
+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";
+
+const PKG_NAME = "@khanglvm/llm-router";
+
+function readInstalledVersion() {
+  try {
+    const dir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+    const pkg = JSON.parse(readFileSync(path.join(dir, "package.json"), "utf8"));
+    return pkg.version || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+function fetchLatestVersion() {
+  try {
+    return execSync(`npm view ${PKG_NAME} version`, { encoding: "utf8" }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function detectPackageManager() {
+  try {
+    const npmGlobalRoot = execSync("npm root -g", { encoding: "utf8" }).trim();
+    const entryReal = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+    if (entryReal.startsWith(npmGlobalRoot)) return "npm";
+  } catch { /* ignore */ }
+
+  try {
+    const out = execSync("pnpm list -g --json 2>/dev/null", { encoding: "utf8" });
+    if (out.includes(PKG_NAME)) return "pnpm";
+  } catch { /* ignore */ }
+
+  return "npm";
+}
+
+export async function runUpgradeCommand({ onLine, onError } = {}) {
+  const line = typeof onLine === "function" ? onLine : (msg) => console.log(msg);
+  const error = typeof onError === "function" ? onError : (msg) => console.error(msg);
+
+  const currentVersion = readInstalledVersion();
+  line(`Current version: ${currentVersion}`);
+
+  // Check latest
+  line("Checking for updates...");
+  const latestVersion = fetchLatestVersion();
+  if (!latestVersion) {
+    error("Could not fetch latest version from npm registry.");
+    return { ok: false, exitCode: 1 };
+  }
+
+  if (latestVersion === currentVersion) {
+    line(`Already on the latest version (${currentVersion}).`);
+    return { ok: true, exitCode: 0 };
+  }
+
+  line(`New version available: ${currentVersion} → ${latestVersion}`);
+
+  // Stop running instance
+  let wasRunning = false;
+  let savedState = 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"}`);
+      }
+    }
+  } catch {
+    // instance-state not available, skip
+  }
+
+  // Install latest
+  const pm = detectPackageManager();
+  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" });
+  } catch {
+    error("Upgrade failed. You may need to run with sudo or fix 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");
+    }
+  }
+
+  return { ok: true, exitCode: 0 };
+}

package/src/node/web-command.js

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { getDefaultConfigPath } from "./config-store.js";
 import { FIXED_LOCAL_ROUTER_HOST, FIXED_LOCAL_ROUTER_PORT } from "./local-server-settings.js";
+import { reclaimPort } from "./port-reclaim.js";
 import { startWebConsoleServer } from "./web-console-server.js";
 
 function toBoolean(value, fallback) {
@@ -49,26 +50,76 @@ export async function runWebCommand(options = {}) {
   const line = typeof options.onLine === "function" ? options.onLine : console.log;
   const error = typeof options.onError === "function" ? options.onError : console.error;
 
+  const onPortConflict = typeof options.onPortConflict === "function" ? options.onPortConflict : null;
+  const reclaimPortFn = typeof options.reclaimPort === "function" ? options.reclaimPort : (args) => reclaimPort(args, options);
+
+  const buildServerOptions = () => ({
+    host,
+    port,
+    configPath,
+    routerHost: FIXED_LOCAL_ROUTER_HOST,
+    routerPort: FIXED_LOCAL_ROUTER_PORT,
+    routerWatchConfig: toBoolean(options.routerWatchConfig ?? options["router-watch-config"], true),
+    routerWatchBinary: toBoolean(options.routerWatchBinary ?? options["router-watch-binary"], true),
+    routerRequireAuth: toBoolean(options.routerRequireAuth ?? options["router-require-auth"], false),
+    allowRemoteClients: toBoolean(options.allowRemoteClients ?? options["allow-remote-clients"], false),
+    cliPathForRouter: String(options.cliPathForRouter || process.env.LLM_ROUTER_CLI_PATH || process.argv[1] || "").trim()
+  });
+
   let server;
   try {
-    server = await startWebConsoleServer({
-      host,
-      port,
-      configPath,
-      routerHost: FIXED_LOCAL_ROUTER_HOST,
-      routerPort: FIXED_LOCAL_ROUTER_PORT,
-      routerWatchConfig: toBoolean(options.routerWatchConfig ?? options["router-watch-config"], true),
-      routerWatchBinary: toBoolean(options.routerWatchBinary ?? options["router-watch-binary"], true),
-      routerRequireAuth: toBoolean(options.routerRequireAuth ?? options["router-require-auth"], false),
-      allowRemoteClients: toBoolean(options.allowRemoteClients ?? options["allow-remote-clients"], false),
-      cliPathForRouter: String(options.cliPathForRouter || process.env.LLM_ROUTER_CLI_PATH || process.argv[1] || "").trim()
-    });
+    server = await startWebConsoleServer(buildServerOptions());
   } catch (startError) {
-    return {
-      ok: false,
-      exitCode: 1,
-      errorMessage: `Failed to start the LLM Router web console: ${startError instanceof Error ? startError.message : String(startError)}`
-    };
+    if (startError?.code !== "EADDRINUSE") {
+      return {
+        ok: false,
+        exitCode: 1,
+        errorMessage: `Failed to start the LLM Router web console: ${startError instanceof Error ? startError.message : String(startError)}`
+      };
+    }
+
+    if (!onPortConflict) {
+      return {
+        ok: false,
+        exitCode: 1,
+        errorMessage: `Port ${port} is already in use. Stop the existing listener or use a different port (--port=<number> or LLM_ROUTER_WEB_PORT env).`
+      };
+    }
+
+    let userChoice;
+    try {
+      userChoice = await onPortConflict({ port, host });
+    } catch {
+      userChoice = false;
+    }
+
+    if (!userChoice) {
+      return {
+        ok: true,
+        exitCode: 0,
+        data: `Port ${port} is in use. Web console launch cancelled.`
+      };
+    }
+
+    const reclaimed = await reclaimPortFn({ port, line, error });
+    if (!reclaimed.ok) {
+      return {
+        ok: false,
+        exitCode: 1,
+        errorMessage: reclaimed.errorMessage
+      };
+    }
+
+    try {
+      server = await startWebConsoleServer(buildServerOptions());
+      line(`Port ${port} reclaimed successfully.`);
+    } catch (retryError) {
+      return {
+        ok: false,
+        exitCode: 1,
+        errorMessage: `Failed to start the LLM Router web console after reclaiming port ${port}: ${retryError instanceof Error ? retryError.message : String(retryError)}`
+      };
+    }
   }
 
   line(`LLM Router web console started on ${server.url}`);