@khanglvm/llm-router 1.0.8 → 1.0.9

package/src/cli/wrangler-toml.js

@@ -0,0 +1,324 @@
+export function hasNoDeployTargets(outputText = "") {
+  return /no deploy targets/i.test(String(outputText || ""));
+}
+
+export function parseTomlStringField(text, key) {
+  const pattern = new RegExp(`^\\s*${key}\\s*=\\s*["']([^"']+)["']\\s*$`, "m");
+  const match = String(text || "").match(pattern);
+  return match?.[1] ? String(match[1]).trim() : "";
+}
+
+function topLevelTomlLineInfo(text = "") {
+  const lines = String(text || "").split(/\r?\n/g);
+  const info = [];
+  let currentSection = "";
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    const trimmed = line.trim();
+    if (/^\s*\[.*\]\s*$/.test(line)) {
+      currentSection = trimmed;
+    }
+    info.push({
+      index,
+      line,
+      trimmed,
+      section: currentSection
+    });
+  }
+
+  return info;
+}
+
+export function hasWranglerDeployTargetConfigured(tomlText = "") {
+  const info = topLevelTomlLineInfo(tomlText);
+
+  const hasTopLevelWorkersDev = info.some((entry) =>
+    entry.section === "" && /^\s*workers_dev\s*=\s*true\s*$/i.test(entry.line)
+  );
+  if (hasTopLevelWorkersDev) return true;
+
+  const hasTopLevelRoute = info.some((entry) =>
+    entry.section === "" && /^\s*route\s*=\s*["'][^"']+["']\s*$/i.test(entry.line)
+  );
+  if (hasTopLevelRoute) return true;
+
+  const hasTopLevelRoutes = info.some((entry) =>
+    entry.section === "" && /^\s*routes\s*=\s*\[/i.test(entry.line)
+  );
+  if (hasTopLevelRoutes) return true;
+
+  return false;
+}
+
+function stripNonTopLevelRouteDeclarations(text = "") {
+  const lines = String(text || "").split(/\r?\n/g);
+  const output = [];
+  let currentSection = "";
+  let skippingRoutesArray = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    if (/^\s*\[.*\]\s*$/.test(line)) {
+      currentSection = trimmed;
+      skippingRoutesArray = false;
+      output.push(line);
+      continue;
+    }
+
+    if (currentSection && /^\s*route\s*=/.test(line)) {
+      continue;
+    }
+
+    if (currentSection && /^\s*routes\s*=\s*\[/.test(line)) {
+      skippingRoutesArray = true;
+      if (line.includes("]")) {
+        skippingRoutesArray = false;
+      }
+      continue;
+    }
+
+    if (skippingRoutesArray) {
+      if (trimmed.includes("]")) {
+        skippingRoutesArray = false;
+      }
+      continue;
+    }
+
+    output.push(line);
+  }
+
+  return output.join("\n");
+}
+
+function insertTopLevelBlockBeforeFirstSection(text = "", block = "") {
+  const source = String(text || "");
+  const blockText = String(block || "").trim();
+  if (!blockText) return source;
+
+  const lines = source.split(/\r?\n/g);
+  const firstSectionIndex = lines.findIndex((line) => /^\s*\[.*\]\s*$/.test(line));
+  if (firstSectionIndex < 0) {
+    const prefix = source.trimEnd();
+    return `${prefix}${prefix ? "\n" : ""}${blockText}\n`;
+  }
+
+  const before = lines.slice(0, firstSectionIndex).join("\n").trimEnd();
+  const after = lines.slice(firstSectionIndex).join("\n").trimStart();
+  return `${before}${before ? "\n" : ""}${blockText}\n\n${after}\n`;
+}
+
+function upsertTomlBooleanField(text, key, value) {
+  const normalized = String(text || "");
+  const replacement = `${key} = ${value ? "true" : "false"}`;
+  if (new RegExp(`^\\s*${key}\\s*=`, "m").test(normalized)) {
+    return normalized.replace(new RegExp(`^\\s*${key}\\s*=.*$`, "m"), replacement);
+  }
+  return `${normalized.trimEnd()}\n${replacement}\n`;
+}
+
+function stripTopLevelRouteDeclarations(text = "") {
+  const lines = String(text || "").split(/\r?\n/g);
+  const output = [];
+  let currentSection = "";
+  let skippingRoutesArray = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    if (/^\s*\[.*\]\s*$/.test(line)) {
+      currentSection = trimmed;
+      skippingRoutesArray = false;
+      output.push(line);
+      continue;
+    }
+
+    if (!currentSection && /^\s*route\s*=/.test(line)) {
+      continue;
+    }
+
+    if (!currentSection && /^\s*routes\s*=\s*\[/.test(line)) {
+      skippingRoutesArray = true;
+      if (line.includes("]")) {
+        skippingRoutesArray = false;
+      }
+      continue;
+    }
+
+    if (skippingRoutesArray) {
+      if (trimmed.includes("]")) {
+        skippingRoutesArray = false;
+      }
+      continue;
+    }
+
+    output.push(line);
+  }
+
+  return output.join("\n");
+}
+
+export function normalizeWranglerRoutePattern(value) {
+  const raw = String(value || "").trim();
+  if (!raw) return "";
+
+  let candidate = raw;
+  if (/^https?:\/\//i.test(candidate)) {
+    try {
+      const parsed = new URL(candidate);
+      candidate = `${parsed.hostname}${parsed.pathname || "/"}`;
+    } catch {
+      return "";
+    }
+  }
+
+  if (candidate.startsWith("/")) return "";
+  if (!candidate.includes("*")) {
+    if (candidate.endsWith("/")) candidate = `${candidate}*`;
+    else if (!candidate.includes("/")) candidate = `${candidate}/*`;
+  }
+
+  return candidate;
+}
+
+export function buildDefaultWranglerTomlForDeploy({
+  name = "llm-router-route",
+  main = "src/index.js",
+  compatibilityDate = "2024-01-01",
+  useWorkersDev = false,
+  routePattern = "",
+  zoneName = ""
+} = {}) {
+  const lines = [
+    `name = "${String(name || "llm-router-route")}"`,
+    `main = "${String(main || "src/index.js")}"`,
+    `compatibility_date = "${String(compatibilityDate || "2024-01-01")}"`,
+    `workers_dev = ${useWorkersDev ? "true" : "false"}`
+  ];
+
+  const normalizedPattern = normalizeWranglerRoutePattern(routePattern);
+  const normalizedZone = String(zoneName || "").trim();
+  if (!useWorkersDev && normalizedPattern && normalizedZone) {
+    lines.push("routes = [");
+    lines.push(`  { pattern = "${normalizedPattern}", zone_name = "${normalizedZone}" }`);
+    lines.push("]");
+  }
+
+  lines.push("preview_urls = false");
+  lines.push("");
+  lines.push("[vars]");
+  lines.push('ENVIRONMENT = "production"');
+  lines.push("");
+  return `${lines.join("\n")}`;
+}
+
+export function applyWranglerDeployTargetToToml(existingToml, {
+  useWorkersDev = false,
+  routePattern = "",
+  zoneName = "",
+  replaceExistingTarget = false
+} = {}) {
+  let next = String(existingToml || "");
+  next = stripNonTopLevelRouteDeclarations(next);
+  if (replaceExistingTarget) {
+    next = stripTopLevelRouteDeclarations(next);
+  }
+  next = upsertTomlBooleanField(next, "workers_dev", useWorkersDev);
+
+  if (!useWorkersDev) {
+    const normalizedPattern = normalizeWranglerRoutePattern(routePattern);
+    const normalizedZone = String(zoneName || "").trim();
+    if (normalizedPattern && normalizedZone && (replaceExistingTarget || !hasWranglerDeployTargetConfigured(next))) {
+      const routeBlock = `routes = [\n  { pattern = "${normalizedPattern}", zone_name = "${normalizedZone}" }\n]`;
+      next = insertTopLevelBlockBeforeFirstSection(next, routeBlock);
+    }
+  }
+
+  if (!/^\s*preview_urls\s*=/mi.test(next)) {
+    next = `${next.trimEnd()}\npreview_urls = false\n`;
+  }
+
+  return `${next.trimEnd()}\n`;
+}
+
+function normalizeHostname(value) {
+  return String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/^https?:\/\//, "")
+    .replace(/\/.*$/, "")
+    .replace(/:\d+$/, "")
+    .replace(/\.$/, "");
+}
+
+export function extractHostnameFromRoutePattern(value) {
+  const route = String(value || "").trim();
+  if (!route) return "";
+
+  if (/^https?:\/\//i.test(route)) {
+    try {
+      return normalizeHostname(new URL(route).hostname);
+    } catch {
+      return "";
+    }
+  }
+
+  const left = route.split("/")[0] || "";
+  return normalizeHostname(left.replace(/\*+$/g, ""));
+}
+
+export function inferZoneNameFromHostname(hostname) {
+  const host = normalizeHostname(hostname);
+  if (!host || !host.includes(".")) return "";
+  const labels = host.split(".").filter(Boolean);
+  if (labels.length <= 2) return host;
+  return labels.slice(-2).join(".");
+}
+
+export function isHostnameUnderZone(hostname, zoneName) {
+  const host = normalizeHostname(hostname);
+  const zone = normalizeHostname(zoneName);
+  if (!host || !zone) return false;
+  return host === zone || host.endsWith(`.${zone}`);
+}
+
+export function suggestZoneNameForHostname(hostname, zones = []) {
+  const host = normalizeHostname(hostname);
+  if (!host) return "";
+
+  let best = "";
+  for (const zone of zones || []) {
+    const candidate = normalizeHostname(zone?.name || zone);
+    if (!candidate) continue;
+    if (host === candidate || host.endsWith(`.${candidate}`)) {
+      if (!best || candidate.length > best.length) {
+        best = candidate;
+      }
+    }
+  }
+  return best;
+}
+
+export function buildCloudflareDnsManualGuide({
+  hostname = "",
+  zoneName = "",
+  routePattern = ""
+} = {}) {
+  const host = normalizeHostname(hostname || extractHostnameFromRoutePattern(routePattern));
+  const zone = normalizeHostname(zoneName || inferZoneNameFromHostname(host));
+  const subdomain = host && zone && host.endsWith(`.${zone}`)
+    ? host.slice(0, -(`.${zone}`).length)
+    : "";
+  const label = subdomain || "<subdomain>";
+
+  return [
+    "Custom domain checklist:",
+    `- Route target: ${routePattern || `${host || "<host>"}/*`} (zone: ${zone || "<zone>"})`,
+    `- DNS: create/update CNAME \`${label}\` -> \`@\` in zone \`${zone || "<zone>"}\``,
+    "- Proxy status must be ON (orange cloud / proxied)",
+    host ? `- Verify DNS: dig +short ${host} @1.1.1.1` : "- Verify DNS: dig +short <host> @1.1.1.1",
+    host ? `- Verify HTTP: curl -I https://${host}/anthropic` : "- Verify HTTP: curl -I https://<host>/anthropic",
+    "- Claude base URL must NOT include :8787 for Cloudflare Worker deployments"
+  ].join("\n");
+}

package/src/index.js

@@ -8,7 +8,9 @@ import { runtimeConfigFromEnv } from "./runtime/config.js";
 
 const workerFetch = createFetchHandler({
   getConfig: async (env) => runtimeConfigFromEnv(env),
-  defaultStateStoreBackend: "memory"
+  defaultStateStoreBackend: "memory",
+  runtime: "worker",
+  workerSafeMode: true
 });
 
 export default {

package/src/node/port-reclaim.js

@@ -0,0 +1,224 @@
+import { spawnSync } from "node:child_process";
+import { clearRuntimeState, getActiveRuntimeState } from "./instance-state.js";
+import { startupStatus, stopStartup } from "./startup-manager.js";
+
+export function parsePidList(text) {
+  const tokens = String(text || "")
+    .split(/[\s\r\n]+/)
+    .map((token) => token.trim())
+    .filter(Boolean);
+  return [...new Set(tokens
+    .filter((token) => /^\d+$/.test(token))
+    .map((token) => Number(token))
+    .filter((pid) => Number.isInteger(pid) && pid > 0))];
+}
+
+export function parseFuserPidList(text) {
+  const normalized = String(text || "")
+    .replace(/\b\d+\/tcp:\s*/gi, " ")
+    .trim();
+  if (!normalized) return [];
+  return parsePidList(normalized);
+}
+
+function listListeningPidsWithLsof(port, spawnSyncImpl) {
+  const result = spawnSyncImpl("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"], {
+    encoding: "utf8"
+  });
+  if (result.error) {
+    return { ok: false, pids: [], tool: "lsof", error: result.error };
+  }
+
+  return {
+    ok: true,
+    pids: parsePidList(result.stdout),
+    tool: "lsof"
+  };
+}
+
+function listListeningPidsWithFuser(port, spawnSyncImpl) {
+  const result = spawnSyncImpl("fuser", ["-n", "tcp", String(port)], {
+    encoding: "utf8"
+  });
+  if (result.error) {
+    return { ok: false, pids: [], tool: "fuser", error: result.error };
+  }
+
+  return {
+    ok: true,
+    pids: parseFuserPidList(result.stdout),
+    tool: "fuser"
+  };
+}
+
+export function listListeningPids(port, deps = {}) {
+  const spawnSyncImpl = typeof deps.spawnSync === "function" ? deps.spawnSync : spawnSync;
+  const lsof = listListeningPidsWithLsof(port, spawnSyncImpl);
+  if (lsof.ok) return lsof;
+
+  const fuser = listListeningPidsWithFuser(port, spawnSyncImpl);
+  if (fuser.ok) return fuser;
+
+  return {
+    ok: false,
+    pids: [],
+    tool: "none",
+    error: lsof.error || fuser.error
+  };
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function waitForPortToRelease(port, timeoutMs = 4000, deps = {}) {
+  const listListeningPidsFn = typeof deps.listListeningPids === "function"
+    ? deps.listListeningPids
+    : (targetPort) => listListeningPids(targetPort, deps);
+  const sleepFn = typeof deps.sleep === "function" ? deps.sleep : sleep;
+
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    const probe = listListeningPidsFn(port);
+    if (!probe.ok) {
+      await sleepFn(150);
+      continue;
+    }
+    if (probe.pids.length === 0) {
+      return true;
+    }
+    await sleepFn(150);
+  }
+
+  const finalProbe = listListeningPidsFn(port);
+  if (!finalProbe.ok) return false;
+  return finalProbe.pids.length === 0;
+}
+
+export async function stopStartupManagedListener({ port, line, error }, deps = {}) {
+  const getActiveRuntimeStateFn = typeof deps.getActiveRuntimeState === "function"
+    ? deps.getActiveRuntimeState
+    : getActiveRuntimeState;
+  const startupStatusFn = typeof deps.startupStatus === "function"
+    ? deps.startupStatus
+    : startupStatus;
+  const stopStartupFn = typeof deps.stopStartup === "function"
+    ? deps.stopStartup
+    : stopStartup;
+  const clearRuntimeStateFn = typeof deps.clearRuntimeState === "function"
+    ? deps.clearRuntimeState
+    : clearRuntimeState;
+
+  let activeRuntimeState = null;
+  try {
+    activeRuntimeState = await getActiveRuntimeStateFn();
+  } catch {
+    activeRuntimeState = null;
+  }
+
+  let shouldStopStartup = false;
+  if (activeRuntimeState?.managedByStartup) {
+    shouldStopStartup = Number(activeRuntimeState.port) === Number(port);
+  } else if (!activeRuntimeState) {
+    try {
+      const status = await startupStatusFn();
+      shouldStopStartup = Boolean(status?.running);
+    } catch {
+      shouldStopStartup = false;
+    }
+  }
+
+  if (!shouldStopStartup) return { ok: true, attempted: false };
+
+  line(`Detected startup-managed llm-router on port ${port}. Stopping startup service before reclaim.`);
+  try {
+    await stopStartupFn();
+    await clearRuntimeStateFn();
+    return { ok: true, attempted: true };
+  } catch (startupError) {
+    error(`Failed stopping startup-managed service: ${startupError instanceof Error ? startupError.message : String(startupError)}`);
+    return {
+      ok: false,
+      attempted: true,
+      errorMessage: `Port ${port} is occupied by a startup-managed llm-router service and could not be stopped automatically. Stop it with 'llm-router stop' or 'llm-router config --operation=startup-uninstall' and retry.`
+    };
+  }
+}
+
+export async function reclaimPort({ port, line, error }, deps = {}) {
+  const selfPid = Number.isInteger(deps.selfPid) ? deps.selfPid : process.pid;
+  const stopStartupManagedListenerFn = typeof deps.stopStartupManagedListener === "function"
+    ? deps.stopStartupManagedListener
+    : (args) => stopStartupManagedListener(args, deps);
+  const listListeningPidsFn = typeof deps.listListeningPids === "function"
+    ? deps.listListeningPids
+    : (targetPort) => listListeningPids(targetPort, deps);
+  const waitForPortToReleaseFn = typeof deps.waitForPortToRelease === "function"
+    ? deps.waitForPortToRelease
+    : (targetPort, timeoutMs) => waitForPortToRelease(targetPort, timeoutMs, deps);
+  const killFn = typeof deps.kill === "function" ? deps.kill : process.kill.bind(process);
+
+  const startupStop = await stopStartupManagedListenerFn({ port, line, error });
+  if (!startupStop.ok) {
+    return {
+      ok: false,
+      errorMessage: startupStop.errorMessage
+    };
+  }
+
+  const probe = listListeningPidsFn(port);
+  if (!probe.ok) {
+    return {
+      ok: false,
+      errorMessage: `Port ${port} is in use but process lookup failed (${probe.error instanceof Error ? probe.error.message : String(probe.error || "unknown error")}).`
+    };
+  }
+
+  const targets = probe.pids.filter((pid) => pid !== selfPid);
+  if (targets.length === 0) {
+    return {
+      ok: false,
+      errorMessage: `Port ${port} is in use but no external listener PID was detected.`
+    };
+  }
+
+  line(`Port ${port} is already in use. Stopping existing listener(s): ${targets.join(", ")}.`);
+
+  for (const pid of targets) {
+    try {
+      killFn(pid, "SIGTERM");
+    } catch (killError) {
+      error(`Failed sending SIGTERM to pid ${pid}: ${killError instanceof Error ? killError.message : String(killError)}`);
+    }
+  }
+
+  let released = await waitForPortToReleaseFn(port, 3000);
+  if (!released) {
+    const remaining = listListeningPidsFn(port);
+    const remainingTargets = (remaining.pids || []).filter((pid) => pid !== selfPid);
+
+    if (remainingTargets.length > 0) {
+      line(`Port ${port} still busy. Force killing listener(s): ${remainingTargets.join(", ")}.`);
+      for (const pid of remainingTargets) {
+        try {
+          killFn(pid, "SIGKILL");
+        } catch (killError) {
+          error(`Failed sending SIGKILL to pid ${pid}: ${killError instanceof Error ? killError.message : String(killError)}`);
+        }
+      }
+      released = await waitForPortToReleaseFn(port, 2000);
+    }
+  }
+
+  if (!released) {
+    return {
+      ok: false,
+      errorMessage: `Failed to reclaim port ${port}; listener process is still running.`
+    };
+  }
+
+  return {
+    ok: true
+  };
+}
+

package/src/node/start-command.js

@@ -1,9 +1,10 @@
 import path from "node:path";
 import { existsSync, readFileSync, realpathSync } from "node:fs";
-import { spawn, spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import { configFileExists, getDefaultConfigPath, readConfigFile } from "./config-store.js";
 import { clearRuntimeState, writeRuntimeState } from "./instance-state.js";
 import { startLocalRouteServer } from "./local-server.js";
+import { reclaimPort } from "./port-reclaim.js";
 import { configHasProvider, sanitizeConfigForDisplay } from "../runtime/config.js";
 
 function summarizeConfig(config, configPath) {
@@ -132,133 +133,6 @@ function spawnReplacementCli({ cliPath, startArgs }) {
   });
 }
 
-function parsePidList(text) {
-  const matches = String(text || "").match(/\d+/g) || [];
-  return [...new Set(matches
-    .map((token) => Number(token))
-    .filter((pid) => Number.isInteger(pid) && pid > 0))];
-}
-
-function listListeningPidsWithLsof(port) {
-  const result = spawnSync("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"], {
-    encoding: "utf8"
-  });
-  if (result.error) {
-    return { ok: false, pids: [], tool: "lsof", error: result.error };
-  }
-
-  return {
-    ok: true,
-    pids: parsePidList(result.stdout),
-    tool: "lsof"
-  };
-}
-
-function listListeningPidsWithFuser(port) {
-  const result = spawnSync("fuser", ["-n", "tcp", String(port)], {
-    encoding: "utf8"
-  });
-  if (result.error) {
-    return { ok: false, pids: [], tool: "fuser", error: result.error };
-  }
-
-  return {
-    ok: true,
-    pids: parsePidList(`${result.stdout || ""}\n${result.stderr || ""}`),
-    tool: "fuser"
-  };
-}
-
-function listListeningPids(port) {
-  const lsof = listListeningPidsWithLsof(port);
-  if (lsof.ok) return lsof;
-
-  const fuser = listListeningPidsWithFuser(port);
-  if (fuser.ok) return fuser;
-
-  return {
-    ok: false,
-    pids: [],
-    tool: "none",
-    error: lsof.error || fuser.error
-  };
-}
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-async function waitForPortToRelease(port, timeoutMs = 4000) {
-  const startedAt = Date.now();
-  while (Date.now() - startedAt < timeoutMs) {
-    const probe = listListeningPids(port);
-    if (!probe.ok || probe.pids.length === 0) {
-      return true;
-    }
-    await sleep(150);
-  }
-
-  const finalProbe = listListeningPids(port);
-  return !finalProbe.ok || finalProbe.pids.length === 0;
-}
-
-async function reclaimPort({ port, line, error }) {
-  const probe = listListeningPids(port);
-  if (!probe.ok) {
-    return {
-      ok: false,
-      errorMessage: `Port ${port} is in use but process lookup failed (${probe.error instanceof Error ? probe.error.message : String(probe.error || "unknown error")}).`
-    };
-  }
-
-  const targets = probe.pids.filter((pid) => pid !== process.pid);
-  if (targets.length === 0) {
-    return {
-      ok: false,
-      errorMessage: `Port ${port} is in use but no external listener PID was detected.`
-    };
-  }
-
-  line(`Port ${port} is already in use. Stopping existing listener(s): ${targets.join(", ")}.`);
-
-  for (const pid of targets) {
-    try {
-      process.kill(pid, "SIGTERM");
-    } catch (killError) {
-      error(`Failed sending SIGTERM to pid ${pid}: ${killError instanceof Error ? killError.message : String(killError)}`);
-    }
-  }
-
-  let released = await waitForPortToRelease(port, 3000);
-  if (!released) {
-    const remaining = listListeningPids(port);
-    const remainingTargets = (remaining.pids || []).filter((pid) => pid !== process.pid);
-
-    if (remainingTargets.length > 0) {
-      line(`Port ${port} still busy. Force killing listener(s): ${remainingTargets.join(", ")}.`);
-      for (const pid of remainingTargets) {
-        try {
-          process.kill(pid, "SIGKILL");
-        } catch (killError) {
-          error(`Failed sending SIGKILL to pid ${pid}: ${killError instanceof Error ? killError.message : String(killError)}`);
-        }
-      }
-      released = await waitForPortToRelease(port, 2000);
-    }
-  }
-
-  if (!released) {
-    return {
-      ok: false,
-      errorMessage: `Failed to reclaim port ${port}; listener process is still running.`
-    };
-  }
-
-  return {
-    ok: true
-  };
-}
-
 export async function runStartCommand(options = {}) {
   const configPath = options.configPath || getDefaultConfigPath();
   const host = options.host || "127.0.0.1";