@khanglvm/ai-router 1.0.1 → 1.0.2

package/README.md

@@ -10,6 +10,7 @@ Generic API proxy for AI providers with:
   - `/openai` (OpenAI-compatible responses)
 - OS startup install/uninstall/status (macOS/Linux)
 - Auto-restart local server when config file changes
+- Auto-handle ai-router upgrades for running instances
 
 ## Install / Run
 
@@ -64,6 +65,7 @@ ai-router start --port=8787
 - prints proxy URLs and provider/model summary
 - exits with guidance if config/providers are missing
 - watches `~/.ai-router.json` and auto-restarts on changes (default enabled)
+- watches ai-router binary updates and relaunches latest version automatically (default enabled)
 
 ```bash
 ai-router start --port=8787 --watch-config=true
@@ -105,6 +107,7 @@ ai-router setup --operation=startup-uninstall
 ```
 
 On macOS this installs a LaunchAgent, on Linux a `systemd --user` service. The startup service runs `ai-router start` with config-watch enabled.
+With `--watch-binary=true` (default), startup-managed instances also self-exit on binary updates so launchd/systemd relaunches the new version.
 
 ## Provider Smoke Test Suite (Real-Usage Simulation)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@khanglvm/ai-router",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Generic AI Router Proxy (local + Cloudflare Worker)",
   "type": "module",
   "main": "src/index.js",

package/src/cli/router-module.js

@@ -68,6 +68,24 @@ function parseJsonObjectArg(value, fieldName) {
   }
 }
 
+async function promptProviderFormat(context, {
+  message = "Primary provider format",
+  initialFormat = ""
+} = {}) {
+  const preferred = initialFormat === "claude" ? "claude" : (initialFormat === "openai" ? "openai" : "");
+  const options = preferred === "claude"
+    ? [
+        { value: "claude", label: "Anthropic-compatible" },
+        { value: "openai", label: "OpenAI-compatible" }
+      ]
+    : [
+        { value: "openai", label: "OpenAI-compatible" },
+        { value: "claude", label: "Anthropic-compatible" }
+      ];
+
+  return context.prompts.select({ message, options });
+}
+
 function slugifyId(value, fallback = "provider") {
   const slug = String(value || fallback)
     .trim()
@@ -95,6 +113,12 @@ function summarizeConfig(config, configPath, { includeSecrets = false } = {}) {
   for (const provider of target.providers) {
     lines.push(`- ${provider.id} (${provider.name})`);
     lines.push(`  baseUrl=${provider.baseUrl}`);
+    if (provider.baseUrlByFormat?.openai) {
+      lines.push(`  openaiBaseUrl=${provider.baseUrlByFormat.openai}`);
+    }
+    if (provider.baseUrlByFormat?.claude) {
+      lines.push(`  claudeBaseUrl=${provider.baseUrlByFormat.claude}`);
+    }
     lines.push(`  formats=${(provider.formats || []).join(", ") || provider.format || "unknown"}`);
     lines.push(`  apiKey=${provider.apiKey || "(from env/hidden)"}`);
     lines.push(`  models=${(provider.models || []).map((m) => m.id).join(", ") || "(none)"}`);
@@ -191,6 +215,16 @@ async function resolveUpsertInput(context, existingConfig) {
   const baseProviderId = argProviderId || selectedExisting?.id || "";
   const baseName = String(readArg(args, ["name"], selectedExisting?.name || "") || "");
   const baseUrl = String(readArg(args, ["base-url", "baseUrl"], selectedExisting?.baseUrl || "") || "");
+  const baseOpenAIBaseUrl = String(readArg(
+    args,
+    ["openai-base-url", "openaiBaseUrl"],
+    selectedExisting?.baseUrlByFormat?.openai || ""
+  ) || "");
+  const baseClaudeBaseUrl = String(readArg(
+    args,
+    ["claude-base-url", "claudeBaseUrl", "anthropic-base-url", "anthropicBaseUrl"],
+    selectedExisting?.baseUrlByFormat?.claude || ""
+  ) || "");
   const baseApiKey = String(readArg(args, ["api-key", "apiKey"], "") || "");
   const baseModels = String(readArg(args, ["models"], (selectedExisting?.models || []).map((m) => m.id).join(",")) || "");
   const baseFormat = String(readArg(args, ["format"], selectedExisting?.format || "") || "");
@@ -207,6 +241,8 @@ async function resolveUpsertInput(context, existingConfig) {
       providerId: baseProviderId || slugifyId(baseName || "provider"),
       name: baseName,
       baseUrl,
+      openaiBaseUrl: baseOpenAIBaseUrl,
+      claudeBaseUrl: baseClaudeBaseUrl,
       apiKey: baseApiKey || selectedExisting?.apiKey || "",
       models: parseModelListInput(baseModels),
       format: baseFormat,
@@ -231,11 +267,21 @@ async function resolveUpsertInput(context, existingConfig) {
   });
 
   const url = baseUrl || await context.prompts.text({
-    message: "Provider base URL",
-    required: true,
+    message: "Provider base URL (shared fallback, optional)",
+    required: false,
     placeholder: "https://api.example.com/v1"
   });
 
+  const openaiBaseUrl = String(await context.prompts.text({
+    message: "OpenAI base URL override (optional)",
+    initialValue: baseOpenAIBaseUrl
+  }) || "");
+
+  const claudeBaseUrl = String(await context.prompts.text({
+    message: "Anthropic/Claude base URL override (optional)",
+    initialValue: baseClaudeBaseUrl
+  }) || "");
+
   const askReplaceKey = selectedExisting?.apiKey ? await context.prompts.confirm({
     message: "Replace saved API key?",
     initialValue: false
@@ -246,19 +292,22 @@ async function resolveUpsertInput(context, existingConfig) {
     required: true
   });
 
+  const headersInput = await context.prompts.text({
+    message: "Custom headers JSON (optional)",
+    initialValue: String(baseHeaders || "")
+  });
+  const interactiveHeaders = parseJsonObjectArg(headersInput, "Custom headers");
+
   const probe = await context.prompts.confirm({
     message: "Auto-detect format and models via live probe?",
     initialValue: shouldProbe
   });
 
   let manualFormat = baseFormat;
-  if (!probe && !manualFormat) {
-    manualFormat = await context.prompts.select({
+  if (!probe) {
+    manualFormat = await promptProviderFormat(context, {
       message: "Primary provider format",
-      options: [
-        { value: "openai", label: "OpenAI-compatible" },
-        { value: "claude", label: "Anthropic-compatible" }
-      ]
+      initialFormat: manualFormat
     });
   }
 
@@ -267,12 +316,6 @@ async function resolveUpsertInput(context, existingConfig) {
     initialValue: baseModels
   });
 
-  const headersInput = await context.prompts.text({
-    message: "Custom headers JSON (optional)",
-    initialValue: String(baseHeaders || "")
-  });
-  const interactiveHeaders = parseJsonObjectArg(headersInput, "Custom headers");
-
   const setMasterKey = setMasterKeyFlag || await context.prompts.confirm({
     message: "Set/update worker master key?",
     initialValue: false
@@ -290,9 +333,11 @@ async function resolveUpsertInput(context, existingConfig) {
     providerId,
     name,
     baseUrl: url,
+    openaiBaseUrl,
+    claudeBaseUrl,
     apiKey,
     models: parseModelListInput(modelsInput),
-    format: manualFormat,
+    format: probe ? "" : manualFormat,
     formats: baseFormats,
     headers: interactiveHeaders,
     shouldProbe: probe,
@@ -306,14 +351,16 @@ async function doUpsertProvider(context) {
   const existingConfig = await readConfigFile(configPath);
   const input = await resolveUpsertInput(context, existingConfig);
 
-  if (!input.name || !input.baseUrl || !input.apiKey) {
+  const hasAnyEndpoint = Boolean(input.baseUrl || input.openaiBaseUrl || input.claudeBaseUrl);
+  if (!input.name || !hasAnyEndpoint || !input.apiKey) {
     return {
       ok: false,
       mode: context.mode,
       exitCode: EXIT_VALIDATION,
-      errorMessage: "Missing provider inputs: provider-id, name, base-url, api-key."
+      errorMessage: "Missing provider inputs: provider-id, name, api-key, and at least one endpoint (base-url/openai-base-url/claude-base-url)."
     };
   }
+
   if (!PROVIDER_ID_PATTERN.test(input.providerId)) {
     return {
       ok: false,
@@ -324,8 +371,18 @@ async function doUpsertProvider(context) {
   }
 
   let probe = null;
+  let selectedFormat = String(input.format || "").trim();
   if (input.shouldProbe) {
-    probe = await probeProvider({ baseUrl: input.baseUrl, apiKey: input.apiKey });
+    const probeBaseUrlByFormat = {};
+    if (input.openaiBaseUrl) probeBaseUrlByFormat.openai = input.openaiBaseUrl;
+    if (input.claudeBaseUrl) probeBaseUrlByFormat.claude = input.claudeBaseUrl;
+
+    probe = await probeProvider({
+      baseUrl: input.baseUrl,
+      baseUrlByFormat: Object.keys(probeBaseUrlByFormat).length > 0 ? probeBaseUrlByFormat : undefined,
+      apiKey: input.apiKey,
+      headers: input.headers
+    });
     if (!probe.ok) {
       if (canPrompt()) {
         const continueWithoutProbe = await context.prompts.confirm({
@@ -340,6 +397,11 @@ async function doUpsertProvider(context) {
             errorMessage: "Setup cancelled because provider probe failed."
           };
         }
+
+        selectedFormat = await promptProviderFormat(context, {
+          message: "Probe could not confirm a working format. Choose primary provider format",
+          initialFormat: selectedFormat
+        });
       } else {
         return {
           ok: false,
@@ -348,16 +410,22 @@ async function doUpsertProvider(context) {
           errorMessage: "Provider probe failed. Use --skip-probe=true to force save."
         };
       }
+    } else {
+      selectedFormat = probe.preferredFormat || selectedFormat;
     }
   }
 
+  const effectiveFormat = selectedFormat || (input.shouldProbe ? "" : "openai");
+
   const provider = buildProviderFromSetupInput({
     providerId: input.providerId,
     name: input.name,
     baseUrl: input.baseUrl,
+    openaiBaseUrl: input.openaiBaseUrl,
+    claudeBaseUrl: input.claudeBaseUrl,
     apiKey: input.apiKey,
     models: input.models,
-    format: input.format || "openai",
+    format: effectiveFormat,
     formats: input.formats,
     headers: input.headers,
     probe
@@ -385,6 +453,9 @@ async function doUpsertProvider(context) {
     exitCode: EXIT_SUCCESS,
     data: [
       `Saved provider '${provider.id}' to ${input.configPath}`,
+      probe
+        ? `probe preferred=${probe.preferredFormat || "(none)"} working=${(probe.workingFormats || []).join(",") || "(none)"}`
+        : "probe=skipped",
       `formats=${(provider.formats || []).join(", ") || provider.format || "unknown"}`,
       `models=${provider.models.map((m) => m.id).join(", ")}`,
       `masterKey=${nextConfig.masterKey ? maskSecret(nextConfig.masterKey) : "(not set)"}`
@@ -544,6 +615,7 @@ async function doStartupInstall(context) {
   const host = String(readArg(context.args, ["host"], "127.0.0.1"));
   const port = toNumber(readArg(context.args, ["port"]), 8787);
   const watchConfig = toBoolean(readArg(context.args, ["watch-config", "watchConfig"], true), true);
+  const watchBinary = toBoolean(readArg(context.args, ["watch-binary", "watchBinary"], true), true);
   const requireAuth = toBoolean(readArg(context.args, ["require-auth", "requireAuth"], false), false);
 
   if (!(await configFileExists(configPath))) {
@@ -583,7 +655,7 @@ async function doStartupInstall(context) {
     }
   }
 
-  const result = await installStartup({ configPath, host, port, watchConfig, requireAuth });
+  const result = await installStartup({ configPath, host, port, watchConfig, watchBinary, requireAuth });
   return {
     ok: true,
     mode: context.mode,
@@ -593,6 +665,7 @@ async function doStartupInstall(context) {
       `service=${result.serviceId}`,
       `file=${result.filePath}`,
       `start target=http://${host}:${port}`,
+      `binary watch=${watchBinary ? "enabled" : "disabled"}`,
       `local auth=${requireAuth ? "required (masterKey)" : "disabled"}`
     ].join("\n")
   };
@@ -701,7 +774,9 @@ async function runStartAction(context) {
     host: String(readArg(args, ["host"], "127.0.0.1")),
     port: toNumber(readArg(args, ["port"]), 8787),
     watchConfig: toBoolean(readArg(args, ["watch-config", "watchConfig"], true), true),
+    watchBinary: toBoolean(readArg(args, ["watch-binary", "watchBinary"], true), true),
     requireAuth: toBoolean(readArg(args, ["require-auth", "requireAuth"], false), false),
+    cliPathForWatch: process.argv[1],
     onLine: (line) => context.terminal.line(line),
     onError: (line) => context.terminal.error(line)
   });
@@ -966,14 +1041,15 @@ const routerModule = {
       actionId: "start",
       description: "Start local ai-router proxy.",
       tui: { steps: ["start-server"] },
-      commandline: { requiredArgs: [], optionalArgs: ["host", "port", "config", "watch-config", "require-auth"] },
+      commandline: { requiredArgs: [], optionalArgs: ["host", "port", "config", "watch-config", "watch-binary", "require-auth"] },
       help: {
-        summary: "Start local ai-router on localhost. Auto-restarts when config file changes.",
+        summary: "Start local ai-router on localhost. Auto-restarts on config changes and auto-relaunches after ai-router upgrades.",
         args: [
           { name: "host", required: false, description: "Listen host.", example: "--host=127.0.0.1" },
           { name: "port", required: false, description: "Listen port.", example: "--port=8787" },
           { name: "config", required: false, description: "Path to config file.", example: "--config=~/.ai-router.json" },
           { name: "watch-config", required: false, description: "Auto-restart on config changes.", example: "--watch-config=true" },
+          { name: "watch-binary", required: false, description: "Watch for ai-router upgrades and relaunch the latest version.", example: "--watch-binary=true" },
           { name: "require-auth", required: false, description: "Require local API auth using config.masterKey.", example: "--require-auth=true" }
         ],
         examples: ["ai-router", "ai-router start --port=8787", "ai-router start --require-auth=true"],
@@ -1001,6 +1077,9 @@ const routerModule = {
           "provider-id",
           "name",
           "base-url",
+          "openai-base-url",
+          "claude-base-url",
+          "anthropic-base-url",
           "api-key",
           "models",
           "format",
@@ -1013,6 +1092,7 @@ const routerModule = {
           "host",
           "port",
           "watch-config",
+          "watch-binary",
           "require-auth"
         ]
       },
@@ -1023,6 +1103,8 @@ const routerModule = {
           { name: "provider-id", required: false, description: "Provider id (slug/camelCase).", example: "--provider-id=openrouter" },
           { name: "name", required: false, description: "Provider display name.", example: "--name=OpenRouter" },
           { name: "base-url", required: false, description: "Provider base URL.", example: "--base-url=https://openrouter.ai/api/v1" },
+          { name: "openai-base-url", required: false, description: "OpenAI endpoint base URL (format-specific override).", example: "--openai-base-url=https://ramclouds.me/v1" },
+          { name: "claude-base-url", required: false, description: "Anthropic endpoint base URL (format-specific override).", example: "--claude-base-url=https://ramclouds.me" },
           { name: "api-key", required: false, description: "Provider API key.", example: "--api-key=sk-..." },
           { name: "models", required: false, description: "Comma-separated model list.", example: "--models=gpt-4o,claude-3-5-sonnet-latest" },
           { name: "model", required: false, description: "Single model id (used by remove-model).", example: "--model=gpt-4o" },
@@ -1030,6 +1112,7 @@ const routerModule = {
           { name: "headers", required: false, description: "Custom provider headers as JSON object.", example: "--headers={\"User-Agent\":\"Mozilla/5.0\"}" },
           { name: "skip-probe", required: false, description: "Skip live provider probe.", example: "--skip-probe=true" },
           { name: "master-key", required: false, description: "Worker auth token.", example: "--master-key=my-token" },
+          { name: "watch-binary", required: false, description: "For startup-install: detect ai-router upgrades and auto-relaunch under OS startup.", example: "--watch-binary=true" },
           { name: "require-auth", required: false, description: "Require masterKey auth for local start/startup-install.", example: "--require-auth=true" },
           { name: "config", required: false, description: "Path to config file.", example: "--config=~/.ai-router.json" }
         ],

package/src/cli-entry.js

@@ -63,7 +63,9 @@ async function runStartFastPath(args) {
     host: args.host || "127.0.0.1",
     port: parseNumber(args.port, 8787),
     watchConfig: parseBoolean(args["watch-config"] ?? args.watchConfig, true),
+    watchBinary: parseBoolean(args["watch-binary"] ?? args.watchBinary, true),
     requireAuth: parseBoolean(args["require-auth"] ?? args.requireAuth, false),
+    cliPathForWatch: process.argv[1],
     onLine: (line) => console.log(line),
     onError: (line) => console.error(line)
   });

package/src/node/config-workflows.js

@@ -8,6 +8,32 @@ function dedupe(values) {
   return [...new Set((values || []).filter(Boolean).map((value) => String(value).trim()).filter(Boolean))];
 }
 
+function normalizeBaseUrlByFormatInput(input) {
+  const source = input?.baseUrlByFormat && typeof input.baseUrlByFormat === "object"
+    ? input.baseUrlByFormat
+    : {};
+  const openai = String(
+    source.openai ||
+    input?.openaiBaseUrl ||
+    input?.["openai-base-url"] ||
+    ""
+  ).trim();
+  const claude = String(
+    source.claude ||
+    source.anthropic ||
+    input?.claudeBaseUrl ||
+    input?.anthropicBaseUrl ||
+    input?.["claude-base-url"] ||
+    input?.["anthropic-base-url"] ||
+    ""
+  ).trim();
+
+  const out = {};
+  if (openai) out.openai = openai;
+  if (claude) out.claude = claude;
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+
 export function parseModelListInput(raw) {
   if (!raw) return [];
   if (Array.isArray(raw)) return dedupe(raw);
@@ -20,22 +46,31 @@ function normalizeModelArray(models) {
 
 export function buildProviderFromSetupInput(input) {
   const providerId = input.providerId || input.id || input.name;
+  const baseUrlByFormat = normalizeBaseUrlByFormatInput(input);
   const explicitModels = normalizeModelArray(parseModelListInput(input.models));
   const probeModels = normalizeModelArray(input.probe?.models || []);
   const mergedModels = explicitModels.length > 0 ? explicitModels : probeModels;
+  const endpointFormats = baseUrlByFormat ? Object.keys(baseUrlByFormat) : [];
 
   const preferredFormat = input.probe?.preferredFormat || input.format;
   const supportedFormats = dedupe([
     ...(input.probe?.formats || []),
+    ...endpointFormats,
     ...(input.formats || []),
     ...(preferredFormat ? [preferredFormat] : [])
   ]);
+  const baseUrl = String(input.baseUrl || "").trim()
+    || (preferredFormat ? baseUrlByFormat?.[preferredFormat] : "")
+    || baseUrlByFormat?.openai
+    || baseUrlByFormat?.claude
+    || "";
 
   return normalizeRuntimeConfig({
     providers: [{
       id: providerId,
       name: input.name || providerId,
-      baseUrl: input.baseUrl,
+      baseUrl,
+      baseUrlByFormat,
       apiKey: input.apiKey,
       format: preferredFormat,
       formats: supportedFormats,
@@ -136,4 +171,3 @@ export function buildWorkerConfigPayload(config, { masterKey } = {}) {
 
   return payload;
 }
-

package/src/node/provider-probe.js

@@ -16,6 +16,18 @@ function makeProviderShell(baseUrl) {
   };
 }
 
+function normalizeProbeBaseUrlByFormat(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const openai = typeof value.openai === "string" ? value.openai.trim() : "";
+  const claude = typeof value.claude === "string"
+    ? value.claude.trim()
+    : (typeof value.anthropic === "string" ? value.anthropic.trim() : "");
+  const out = {};
+  if (openai) out[FORMATS.OPENAI] = openai;
+  if (claude) out[FORMATS.CLAUDE] = claude;
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+
 function cloneHeaders(headers) {
   return { ...(headers || {}) };
 }
@@ -159,7 +171,7 @@ function extractModelIds(result) {
   return [...new Set(ids)];
 }
 
-async function probeOpenAI(baseUrl, apiKey, timeoutMs) {
+async function probeOpenAI(baseUrl, apiKey, timeoutMs, extraHeaders = {}) {
   const authVariants = makeAuthVariants(FORMATS.OPENAI, apiKey);
   const modelsUrl = resolveModelsUrl(baseUrl, FORMATS.OPENAI);
   const messagesUrl = resolveProviderUrl(makeProviderShell(baseUrl), FORMATS.OPENAI);
@@ -174,7 +186,7 @@ async function probeOpenAI(baseUrl, apiKey, timeoutMs) {
   };
 
   for (const variant of authVariants) {
-    const commonHeaders = { "Content-Type": "application/json", ...variant.headers };
+    const commonHeaders = { "Content-Type": "application/json", ...extraHeaders, ...variant.headers };
 
     const modelsResult = await safeFetchJson(modelsUrl, {
       method: "GET",
@@ -210,7 +222,7 @@ async function probeOpenAI(baseUrl, apiKey, timeoutMs) {
   return details;
 }
 
-async function probeClaude(baseUrl, apiKey, timeoutMs) {
+async function probeClaude(baseUrl, apiKey, timeoutMs, extraHeaders = {}) {
   const authVariants = makeAuthVariants(FORMATS.CLAUDE, apiKey);
   const modelsUrl = resolveModelsUrl(baseUrl, FORMATS.CLAUDE);
   const messagesUrl = resolveProviderUrl(makeProviderShell(baseUrl), FORMATS.CLAUDE);
@@ -228,6 +240,7 @@ async function probeClaude(baseUrl, apiKey, timeoutMs) {
     const commonHeaders = {
       "Content-Type": "application/json",
       "anthropic-version": "2023-06-01",
+      ...extraHeaders,
       ...variant.headers
     };
 
@@ -266,10 +279,16 @@ async function probeClaude(baseUrl, apiKey, timeoutMs) {
 
 export async function probeProvider(options) {
   const baseUrl = String(options?.baseUrl || "").trim();
+  const baseUrlByFormat = normalizeProbeBaseUrlByFormat(options?.baseUrlByFormat);
   const apiKey = String(options?.apiKey || "").trim();
   const timeoutMs = Number.isFinite(options?.timeoutMs) ? Number(options.timeoutMs) : DEFAULT_TIMEOUT_MS;
+  const extraHeaders = options?.headers && typeof options.headers === "object" && !Array.isArray(options.headers)
+    ? options.headers
+    : {};
+  const openaiProbeBaseUrl = String(baseUrlByFormat?.[FORMATS.OPENAI] || baseUrl || "").trim();
+  const claudeProbeBaseUrl = String(baseUrlByFormat?.[FORMATS.CLAUDE] || baseUrl || "").trim();
 
-  if (!baseUrl) {
+  if (!openaiProbeBaseUrl && !claudeProbeBaseUrl) {
     throw new Error("Provider baseUrl is required for probing.");
   }
   if (!apiKey) {
@@ -277,8 +296,12 @@ export async function probeProvider(options) {
   }
 
   const [openai, claude] = await Promise.all([
-    probeOpenAI(baseUrl, apiKey, timeoutMs),
-    probeClaude(baseUrl, apiKey, timeoutMs)
+    openaiProbeBaseUrl
+      ? probeOpenAI(openaiProbeBaseUrl, apiKey, timeoutMs, extraHeaders)
+      : Promise.resolve({ format: FORMATS.OPENAI, supported: false, working: false, models: [], auth: null, checks: [] }),
+    claudeProbeBaseUrl
+      ? probeClaude(claudeProbeBaseUrl, apiKey, timeoutMs, extraHeaders)
+      : Promise.resolve({ format: FORMATS.CLAUDE, supported: false, working: false, models: [], auth: null, checks: [] })
   ]);
 
   const supportedFormats = [claude, openai]
@@ -304,7 +327,8 @@ export async function probeProvider(options) {
 
   return {
     ok: workingFormats.length > 0,
-    baseUrl,
+    baseUrl: baseUrl || openaiProbeBaseUrl || claudeProbeBaseUrl,
+    baseUrlByFormat,
     formats: supportedFormats,
     workingFormats,
     preferredFormat,

package/src/node/start-command.js

@@ -1,5 +1,6 @@
 import path from "node:path";
-import { watch as fsWatch } from "node:fs";
+import { watch as fsWatch, existsSync, readFileSync, realpathSync } from "node:fs";
+import { spawn } from "node:child_process";
 import { configFileExists, getDefaultConfigPath, readConfigFile } from "./config-store.js";
 import { startLocalProxyServer } from "./local-server.js";
 import { configHasProvider, sanitizeConfigForDisplay } from "../runtime/config.js";
@@ -20,6 +21,12 @@ function summarizeConfig(config, configPath) {
   for (const provider of target.providers) {
     lines.push(`- ${provider.id} (${provider.name})`);
     lines.push(`  baseUrl=${provider.baseUrl}`);
+    if (provider.baseUrlByFormat?.openai) {
+      lines.push(`  openaiBaseUrl=${provider.baseUrlByFormat.openai}`);
+    }
+    if (provider.baseUrlByFormat?.claude) {
+      lines.push(`  claudeBaseUrl=${provider.baseUrlByFormat.claude}`);
+    }
     lines.push(`  formats=${(provider.formats || []).join(", ") || provider.format || "unknown"}`);
     lines.push(`  apiKey=${provider.apiKey || "(from env/hidden)"}`);
     lines.push(`  models=${(provider.models || []).map((m) => m.id).join(", ") || "(none)"}`);
@@ -43,12 +50,97 @@ function toNumber(value, fallback) {
   return Number.isFinite(parsed) ? parsed : fallback;
 }
 
+function safeRealpath(filePath) {
+  if (!filePath) return "";
+  try {
+    return realpathSync(filePath);
+  } catch {
+    return path.resolve(filePath);
+  }
+}
+
+function resolvePackageJsonPathFromCliPath(cliPath) {
+  if (!cliPath) return "";
+  let dir = path.dirname(cliPath);
+  for (let i = 0; i < 8; i += 1) {
+    const candidate = path.join(dir, "package.json");
+    if (existsSync(candidate)) return candidate;
+    const next = path.dirname(dir);
+    if (next === dir) break;
+    dir = next;
+  }
+  return "";
+}
+
+function readPackageVersion(packageJsonPath) {
+  if (!packageJsonPath || !existsSync(packageJsonPath)) return "";
+  try {
+    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    return typeof parsed?.version === "string" ? parsed.version : "";
+  } catch {
+    return "";
+  }
+}
+
+function snapshotCliVersionState(cliPath) {
+  const realpath = safeRealpath(cliPath);
+  const packageJsonPath = resolvePackageJsonPathFromCliPath(realpath);
+  const version = readPackageVersion(packageJsonPath);
+  return { cliPath, realpath, packageJsonPath, version };
+}
+
+function buildStartArgs({ configPath, host, port, watchConfig, watchBinary, requireAuth }) {
+  return [
+    "start",
+    `--config=${configPath}`,
+    `--host=${host}`,
+    `--port=${port}`,
+    `--watch-config=${watchConfig ? "true" : "false"}`,
+    `--watch-binary=${watchBinary ? "true" : "false"}`,
+    `--require-auth=${requireAuth ? "true" : "false"}`
+  ];
+}
+
+function spawnReplacementCli({ cliPath, startArgs }) {
+  return new Promise((resolve) => {
+    try {
+      const env = { ...process.env };
+      env.AI_ROUTER_CLI_PATH = cliPath;
+      delete env.AI_ROUTER_MANAGED_BY_STARTUP;
+
+      const child = spawn(process.execPath, [cliPath, ...startArgs], {
+        stdio: "inherit",
+        env
+      });
+
+      let settled = false;
+      const finish = (result) => {
+        if (settled) return;
+        settled = true;
+        resolve(result);
+      };
+
+      child.once("spawn", () => finish({ ok: true, pid: child.pid }));
+      child.once("error", (error) => finish({ ok: false, error }));
+    } catch (error) {
+      resolve({ ok: false, error });
+    }
+  });
+}
+
 export async function runStartCommand(options = {}) {
   const configPath = options.configPath || getDefaultConfigPath();
   const host = options.host || "127.0.0.1";
   const port = toNumber(options.port, 8787);
   const watchConfig = toBoolean(options.watchConfig, true);
+  const watchBinary = toBoolean(options.watchBinary, true);
+  const binaryWatchIntervalMs = Math.max(
+    1000,
+    toNumber(options.binaryWatchIntervalMs ?? process.env.AI_ROUTER_BINARY_WATCH_INTERVAL_MS, 15000)
+  );
   const requireAuth = toBoolean(options.requireAuth, false);
+  const managedByStartup = options.managedByStartup === true || process.env.AI_ROUTER_MANAGED_BY_STARTUP === "1";
+  const cliPathForWatch = String(options.cliPathForWatch || process.env.AI_ROUTER_CLI_PATH || process.argv[1] || "");
   const line = typeof options.onLine === "function" ? options.onLine : console.log;
   const error = typeof options.onError === "function" ? options.onError : console.error;
 
@@ -95,12 +187,17 @@ export async function runStartCommand(options = {}) {
   }
   line(`Local auth: ${requireAuth ? "required (masterKey)" : "disabled"}`);
   line(`Config watch auto-restart: ${watchConfig ? "enabled" : "disabled"}`);
+  line(`Binary update watch: ${watchBinary ? "enabled" : "disabled"}${managedByStartup ? " (startup-managed auto-restart)" : ""}`);
   line("Press Ctrl+C to stop.");
 
   let shuttingDown = false;
   let restarting = false;
   let debounceTimer = null;
   let watcher = null;
+  let binaryWatchTimer = null;
+  let binaryState = watchBinary && cliPathForWatch ? snapshotCliVersionState(cliPathForWatch) : null;
+  let binaryNoticeSent = false;
+  let binaryRelaunching = false;
 
   const closeServer = async () => {
     if (!server) return;
@@ -153,23 +250,85 @@ export async function runStartCommand(options = {}) {
     }
   }
 
-  await new Promise((resolve) => {
-    const shutdown = async () => {
+  let resolveDone;
+  const donePromise = new Promise((resolve) => {
+    resolveDone = resolve;
+  });
+
+  const shutdown = async () => {
       if (shuttingDown) return;
       shuttingDown = true;
       try {
         if (debounceTimer) clearTimeout(debounceTimer);
         watcher?.close?.();
+        if (binaryWatchTimer) clearInterval(binaryWatchTimer);
       } catch {
         // ignore
       }
       await closeServer();
-      resolve();
+      resolveDone();
     };
 
-    process.once("SIGINT", () => { void shutdown(); });
-    process.once("SIGTERM", () => { void shutdown(); });
-  });
+  if (watchBinary && binaryState) {
+    binaryWatchTimer = setInterval(() => {
+      if (shuttingDown || restarting || binaryRelaunching) return;
+      const nextState = snapshotCliVersionState(binaryState.cliPath);
+      const changed =
+        nextState.realpath !== binaryState.realpath ||
+        (nextState.version && binaryState.version && nextState.version !== binaryState.version);
+
+      if (!changed) return;
+
+      const from = binaryState.version || binaryState.realpath || "(unknown)";
+      const to = nextState.version || nextState.realpath || "(unknown)";
+      binaryState = nextState;
+
+      if (managedByStartup) {
+        line(`Detected ai-router update (${from} -> ${to}). Exiting for startup manager to relaunch latest version.`);
+        void shutdown().then(() => {
+          process.exit(0);
+        });
+        return;
+      }
+
+      const cliPath = nextState.cliPath || cliPathForWatch || process.argv[1];
+      if (!cliPath) {
+        if (!binaryNoticeSent) {
+          binaryNoticeSent = true;
+          line(`Detected ai-router update (${from} -> ${to}). Restart this process to run the new version.`);
+        }
+        return;
+      }
+
+      binaryRelaunching = true;
+      void (async () => {
+        try {
+          line(`Detected ai-router update (${from} -> ${to}). Relaunching latest version...`);
+          await shutdown();
+          const launch = await spawnReplacementCli({
+            cliPath,
+            startArgs: buildStartArgs({ configPath, host, port, watchConfig, watchBinary, requireAuth })
+          });
+          if (!launch.ok) {
+            error(`Failed to relaunch updated ai-router: ${launch.error instanceof Error ? launch.error.message : String(launch.error)}`);
+            process.exit(1);
+            return;
+          }
+
+          line(`Started updated ai-router process (pid ${launch.pid || "unknown"}).`);
+          process.exit(0);
+        } catch (relaunchError) {
+          error(`Failed during ai-router auto-relaunch: ${relaunchError instanceof Error ? relaunchError.message : String(relaunchError)}`);
+          process.exit(1);
+        }
+      })();
+    }, binaryWatchIntervalMs);
+  }
+
+  process.once("SIGINT", () => { void shutdown(); });
+  process.once("SIGTERM", () => { void shutdown(); });
+
+  await donePromise;
 
   return {
     ok: true,

package/src/node/startup-manager.js

@@ -5,7 +5,7 @@
 
 import os from "node:os";
 import path from "node:path";
-import { promises as fs } from "node:fs";
+import { promises as fs, existsSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 
 const SERVICE_NAME = "ai-router";
@@ -37,26 +37,32 @@ function runCommand(command, args, { cwd } = {}) {
 
 function resolveCliEntryPath() {
   if (process.env.AI_ROUTER_CLI_PATH) return process.env.AI_ROUTER_CLI_PATH;
+  const nodeBinDir = path.dirname(process.execPath);
+  for (const binName of ["ai-router", "ai-router-proxy"]) {
+    const candidate = path.join(nodeBinDir, binName);
+    if (existsSync(candidate)) return candidate;
+  }
   if (process.argv[1]) return path.resolve(process.argv[1]);
   throw new Error("Unable to resolve ai-router CLI entry path.");
 }
 
-function makeExecArgs({ configPath, host, port, watchConfig, requireAuth }) {
+function makeExecArgs({ configPath, host, port, watchConfig, watchBinary, requireAuth }) {
   return [
     "start",
     `--config=${configPath}`,
     `--host=${host}`,
     `--port=${port}`,
     `--watch-config=${watchConfig ? "true" : "false"}`,
+    `--watch-binary=${watchBinary ? "true" : "false"}`,
     `--require-auth=${requireAuth ? "true" : "false"}`
   ];
 }
 
-function buildLaunchAgentPlist({ nodePath, cliPath, configPath, host, port, watchConfig, requireAuth }) {
+function buildLaunchAgentPlist({ nodePath, cliPath, configPath, host, port, watchConfig, watchBinary, requireAuth }) {
   const logDir = path.join(os.homedir(), "Library", "Logs");
   const stdoutPath = path.join(logDir, "ai-router.out.log");
   const stderrPath = path.join(logDir, "ai-router.err.log");
-  const args = [nodePath, cliPath, ...makeExecArgs({ configPath, host, port, watchConfig, requireAuth })];
+  const args = [nodePath, cliPath, ...makeExecArgs({ configPath, host, port, watchConfig, watchBinary, requireAuth })];
 
   const xmlArgs = args.map((arg) => `    <string>${arg}</string>`).join("\n");
 
@@ -74,6 +80,13 @@ ${xmlArgs}
     <true/>
     <key>KeepAlive</key>
     <true/>
+    <key>EnvironmentVariables</key>
+    <dict>
+      <key>AI_ROUTER_MANAGED_BY_STARTUP</key>
+      <string>1</string>
+      <key>AI_ROUTER_CLI_PATH</key>
+      <string>${cliPath}</string>
+    </dict>
     <key>StandardOutPath</key>
     <string>${stdoutPath}</string>
     <key>StandardErrorPath</key>
@@ -85,8 +98,8 @@ ${xmlArgs}
 `;
 }
 
-function buildSystemdService({ nodePath, cliPath, configPath, host, port, watchConfig, requireAuth }) {
-  const execArgs = makeExecArgs({ configPath, host, port, watchConfig, requireAuth }).map(quoteArg).join(" ");
+function buildSystemdService({ nodePath, cliPath, configPath, host, port, watchConfig, watchBinary, requireAuth }) {
+  const execArgs = makeExecArgs({ configPath, host, port, watchConfig, watchBinary, requireAuth }).map(quoteArg).join(" ");
   const execStart = `${quoteArg(nodePath)} ${quoteArg(cliPath)} ${execArgs}`;
 
   return `[Unit]
@@ -99,6 +112,8 @@ ExecStart=${execStart}
 Restart=always
 RestartSec=2
 Environment=NODE_ENV=production
+Environment=AI_ROUTER_MANAGED_BY_STARTUP=1
+Environment=AI_ROUTER_CLI_PATH=${cliPath}
 WorkingDirectory=${process.cwd()}
 
 [Install]
@@ -106,7 +121,7 @@ WantedBy=default.target
 `;
 }
 
-async function installDarwin({ configPath, host, port, watchConfig, requireAuth }) {
+async function installDarwin({ configPath, host, port, watchConfig, watchBinary, requireAuth }) {
   const launchAgentsDir = path.join(os.homedir(), "Library", "LaunchAgents");
   const plistPath = path.join(launchAgentsDir, `${LAUNCH_AGENT_ID}.plist`);
   const nodePath = process.execPath;
@@ -122,6 +137,7 @@ async function installDarwin({ configPath, host, port, watchConfig, requireAuth
     host,
     port,
     watchConfig,
+    watchBinary,
     requireAuth
   });
 
@@ -191,7 +207,7 @@ async function statusDarwin() {
   };
 }
 
-async function installLinux({ configPath, host, port, watchConfig, requireAuth }) {
+async function installLinux({ configPath, host, port, watchConfig, watchBinary, requireAuth }) {
   const systemdDir = path.join(os.homedir(), ".config", "systemd", "user");
   const servicePath = path.join(systemdDir, `${SERVICE_NAME}.service`);
   const nodePath = process.execPath;
@@ -205,6 +221,7 @@ async function installLinux({ configPath, host, port, watchConfig, requireAuth }
     host,
     port,
     watchConfig,
+    watchBinary,
     requireAuth
   });
   await fs.writeFile(servicePath, content, "utf8");
@@ -271,6 +288,7 @@ export async function installStartup(options) {
     host: options.host || "127.0.0.1",
     port: options.port || 8787,
     watchConfig: options.watchConfig !== false,
+    watchBinary: options.watchBinary !== false,
     requireAuth: options.requireAuth === true
   };
 

package/src/runtime/config.js

@@ -68,17 +68,49 @@ function normalizeModelEntry(model) {
   };
 }
 
+function normalizeBaseUrlByFormat(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const out = {};
+  const openai = typeof value.openai === "string" ? value.openai.trim() : "";
+  const claude =
+    typeof value.claude === "string" ? value.claude.trim()
+      : (typeof value.anthropic === "string" ? value.anthropic.trim() : "");
+
+  if (openai) out[FORMATS.OPENAI] = openai;
+  if (claude) out[FORMATS.CLAUDE] = claude;
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+
 function normalizeProvider(provider, index = 0) {
   if (!provider || typeof provider !== "object") return null;
 
   const name = provider.name || provider.id || `provider-${index + 1}`;
   const id = slugifyId(provider.id || provider.name || `provider-${index + 1}`);
-  const baseUrl = String(provider.baseUrl || provider["base-url"] || provider.endpoint || "").trim();
+  const baseUrlByFormat = normalizeBaseUrlByFormat(
+    provider.baseUrlByFormat ||
+    provider["base-url-by-format"] ||
+    provider.endpointByFormat ||
+    provider["endpoint-by-format"] ||
+    provider.endpoints
+  );
+  const explicitBaseUrl = String(provider.baseUrl || provider["base-url"] || provider.endpoint || "").trim();
   const rawFormat = provider.format || provider.responseFormat || provider["response-format"];
+  const preferredFormat = [FORMATS.OPENAI, FORMATS.CLAUDE].includes(rawFormat) ? rawFormat : undefined;
+  const endpointFormats = baseUrlByFormat ? Object.keys(baseUrlByFormat) : [];
   const formats = dedupeStrings([
     ...toArray(provider.formats),
-    ...(rawFormat ? [rawFormat] : [])
+    ...endpointFormats,
+    ...(preferredFormat ? [preferredFormat] : [])
   ]).filter((value) => value === FORMATS.OPENAI || value === FORMATS.CLAUDE);
+  const orderedFormats = preferredFormat
+    ? dedupeStrings([preferredFormat, ...formats])
+    : formats;
+  const baseUrl = explicitBaseUrl
+    || (preferredFormat && baseUrlByFormat?.[preferredFormat])
+    || (baseUrlByFormat?.[orderedFormats[0]])
+    || baseUrlByFormat?.[FORMATS.OPENAI]
+    || baseUrlByFormat?.[FORMATS.CLAUDE]
+    || "";
 
   const normalizedModels = toArray(provider.models)
     .map(normalizeModelEntry)
@@ -99,10 +131,11 @@ function normalizeProvider(provider, index = 0) {
     name,
     enabled: provider.enabled !== false,
     baseUrl,
+    baseUrlByFormat,
     apiKey: typeof provider.apiKey === "string" ? provider.apiKey : (typeof provider.credential === "string" ? provider.credential : undefined),
     apiKeyEnv: typeof provider.apiKeyEnv === "string" ? provider.apiKeyEnv : undefined,
-    format: formats[0],
-    formats,
+    format: preferredFormat || orderedFormats[0],
+    formats: orderedFormats,
     auth,
     authByFormat,
     headers: provider.headers && typeof provider.headers === "object" ? provider.headers : {},
@@ -200,7 +233,7 @@ export function resolveProviderFormat(provider, sourceFormat = undefined) {
 }
 
 export function resolveProviderUrl(provider, targetFormat) {
-  const baseUrl = String(provider?.baseUrl || "").trim().replace(/\/+$/, "");
+  const baseUrl = String(provider?.baseUrlByFormat?.[targetFormat] || provider?.baseUrl || "").trim().replace(/\/+$/, "");
   if (!baseUrl) return "";
   const isVersionedApiRoot = /\/v\d+(?:\.\d+)?$/i.test(baseUrl);