@lakphy/local-router 0.5.7 → 0.5.8

package/dist/cli.js

@@ -8708,6 +8708,8 @@ var init_errors = __esm(() => {
     APPLY_FAILED: 8,
     UPSTREAM_UNREACHABLE: 9,
     INTERACTIVE_REQUIRED: 10,
+    TARGET_NOT_FOUND: 3,
+    TARGET_UNREACHABLE: 9,
     UNKNOWN_ERROR: 1
   };
   CliError = class CliError extends Error {
@@ -8750,6 +8752,9 @@ function extractGlobalFlags(args) {
   let yes = false;
   let jsonAlias = false;
   let explain = false;
+  let targetUrl;
+  let targetHost;
+  let targetPortRaw;
   for (let i = 0;i < args.length; i++) {
     const a = args[i];
     if (!a)
@@ -8796,6 +8801,21 @@ function extractGlobalFlags(args) {
       explain = true;
       continue;
     }
+    if (a === "--url" || a.startsWith("--url=")) {
+      targetUrl = a.startsWith("--url=") ? a.slice("--url=".length) : args[i + 1];
+      rest.push(a);
+      continue;
+    }
+    if (a === "--host" || a.startsWith("--host=")) {
+      targetHost = a.startsWith("--host=") ? a.slice("--host=".length) : args[i + 1];
+      rest.push(a);
+      continue;
+    }
+    if (a === "--port" || a.startsWith("--port=")) {
+      targetPortRaw = a.startsWith("--port=") ? a.slice("--port=".length) : args[i + 1];
+      rest.push(a);
+      continue;
+    }
     rest.push(a);
   }
   const envFormat = pickOutput(process.env.LOCAL_ROUTER_FORMAT);
@@ -8813,6 +8833,16 @@ function extractGlobalFlags(args) {
   } else {
     output = envFormat ?? "markdown";
   }
+  let targetPort;
+  if (targetPortRaw !== undefined) {
+    targetPort = Number.parseInt(targetPortRaw, 10);
+    if (!Number.isFinite(targetPort) || targetPort <= 0 || targetPort > 65535) {
+      throw new CliError("USAGE_ERROR", `\u65E0\u6548\u7AEF\u53E3: ${targetPortRaw}`, {
+        hint: "\u7AEF\u53E3\u8303\u56F4 1-65535"
+      });
+    }
+  }
+  const target = targetUrl !== undefined || targetHost !== undefined || targetPort !== undefined ? { url: targetUrl, host: targetHost, port: targetPort } : undefined;
   return {
     flags: {
       output,
@@ -8821,7 +8851,8 @@ function extractGlobalFlags(args) {
       noColor: noColor || !!process.env.NO_COLOR,
       noInteractive: noInteractive || process.env.LOCAL_ROUTER_NO_INTERACTIVE === "1",
       yes,
-      explain: explain || process.env.LOCAL_ROUTER_EXPLAIN === "1"
+      explain: explain || process.env.LOCAL_ROUTER_EXPLAIN === "1",
+      target
     },
     rest
   };
@@ -52575,6 +52606,35 @@ var init_bun = __esm(() => {
   init_server();
 });
 
+// src/cli/asset-paths.ts
+async function findExisting(...candidates) {
+  for (const url2 of candidates) {
+    try {
+      const exists = await Bun.file(url2).exists();
+      if (exists)
+        return url2;
+    } catch {}
+  }
+  return null;
+}
+async function readPackageJson() {
+  const url2 = await findExisting(new URL("../../package.json", import.meta.url), new URL("../package.json", import.meta.url), new URL("../../../package.json", import.meta.url));
+  if (!url2)
+    return null;
+  try {
+    return await Bun.file(url2).json();
+  } catch {
+    return null;
+  }
+}
+async function findConfigSchemaUrl() {
+  return findExisting(new URL("../../config.schema.json", import.meta.url), new URL("../config.schema.json", import.meta.url), new URL("../../../config.schema.json", import.meta.url));
+}
+async function readVersionString() {
+  const pkg = await readPackageJson();
+  return typeof pkg?.version === "string" ? pkg.version : "unknown";
+}
+
 // src/cli/runtime.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir2 } from "os";
@@ -59325,6 +59385,13 @@ function createServerAddressInfo(listenHost, port) {
 // src/index.ts
 import { readFileSync as readFileSync8 } from "fs";
 import { dirname as dirname4, resolve as resolve8 } from "path";
+function readRestartCriticalServerFields(config2) {
+  return {
+    host: config2.server?.host ?? "0.0.0.0",
+    port: config2.server?.port ?? 4099,
+    idleTimeout: config2.server?.idleTimeout ?? 0
+  };
+}
 function printIntegrationGuide(config2, listen = {}) {
   const host = listen.host ?? process.env.HOST ?? "0.0.0.0";
   const parsedPort = listen.port ?? Number.parseInt(process.env.PORT ?? "4099", 10);
@@ -59404,7 +59471,7 @@ function createChatProxyModel(providerName, providerConfig, model) {
       throw new Error(`\u6682\u4E0D\u652F\u6301\u7684 provider \u7C7B\u578B: ${providerConfig.type}`);
   }
 }
-function createAdminApiRoutes(store, pluginManager, registerCleanup) {
+function createAdminApiRoutes(store, pluginManager, registerCleanup, serverControl, restartLogStorageTask, serviceVersion) {
   const api2 = new Hono2;
   const cryptoSessions = new Map;
   const CRYPTO_SESSION_TTL_MS = 2 * 60 * 1000;
@@ -59444,7 +59511,16 @@ function createAdminApiRoutes(store, pluginManager, registerCleanup) {
     }
     cryptoSessions.clear();
   });
-  api2.get("/health", (c) => c.json({ status: "ok", service: "local-router" }));
+  api2.get("/health", (c) => {
+    const addr = serverControl?.current ?? readRestartCriticalServerFields(store.get());
+    return c.json({
+      status: "ok",
+      service: "local-router",
+      version: serviceVersion ?? "unknown",
+      host: addr.host,
+      port: addr.port
+    });
+  });
   api2.post("/crypto/handshake", async (c) => {
     pruneExpiredCryptoSessions();
     if (cryptoSessions.size >= CRYPTO_SESSION_MAX) {
@@ -59517,18 +59593,30 @@ function createAdminApiRoutes(store, pluginManager, registerCleanup) {
   });
   api2.post("/config/apply", async (_c) => {
     try {
+      const fallbackBefore = readRestartCriticalServerFields(store.get());
+      const before = serverControl?.current ?? fallbackBefore;
       const config2 = store.reload();
+      const after = readRestartCriticalServerFields(config2);
       if (config2.log) {
         const logBaseDir = resolveLogBaseDir(config2.log);
         initLogger(logBaseDir, config2.log);
+      } else {
+        resetLogger();
       }
+      restartLogStorageTask?.(config2.log);
       const pluginResult = await pluginManager.reloadAll(config2.providers);
+      const restartRequired = before.host !== after.host || before.port !== after.port || before.idleTimeout !== after.idleTimeout;
       return _c.json({
         ok: true,
         summary: {
           providers: Object.keys(config2.providers).length,
           routes: Object.keys(config2.routes).length
         },
+        restartRequired,
+        ...restartRequired && {
+          listen: { host: after.host, port: after.port },
+          canRestart: Boolean(serverControl)
+        },
         ...pluginResult.failures.length > 0 && {
           pluginWarnings: pluginResult.failures
         }
@@ -59537,6 +59625,14 @@ function createAdminApiRoutes(store, pluginManager, registerCleanup) {
       return _c.json({ error: `\u5E94\u7528\u914D\u7F6E\u5931\u8D25: ${err instanceof Error ? err.message : err}` }, 500);
     }
   });
+  api2.post("/restart", (c) => {
+    if (!serverControl) {
+      return c.json({ error: "\u5F53\u524D\u8FD0\u884C\u65B9\u5F0F\u4E0D\u652F\u6301\u81EA\u52A8\u91CD\u542F\uFF0C\u8BF7\u624B\u52A8\u6267\u884C local-router restart" }, 501);
+    }
+    const { host, port } = readRestartCriticalServerFields(store.get());
+    serverControl.requestRestart();
+    return c.json({ ok: true, listen: { host, port } });
+  });
   api2.get("/config/meta", (c) => {
     return c.json({
       configPath: store.getPath(),
@@ -60082,6 +60178,7 @@ async function proxyAdminToDevServer(c, origin) {
 }
 async function createApp(store, options) {
   const config2 = store.get();
+  const serviceVersion = await readVersionString();
   console.log(`\u5DF2\u52A0\u8F7D\u914D\u7F6E: ${store.getPath()}`);
   if (config2.log) {
     const logBaseDir = resolveLogBaseDir(config2.log);
@@ -60089,8 +60186,14 @@ async function createApp(store, options) {
   } else {
     resetLogger();
   }
-  const stopLogStorageTask = startLogStorageBackgroundTask(config2.log);
-  options?.registerCleanup?.(stopLogStorageTask);
+  let stopLogStorageTask = startLogStorageBackgroundTask(config2.log);
+  const restartLogStorageTask = (logConfig) => {
+    try {
+      stopLogStorageTask();
+    } catch {}
+    stopLogStorageTask = startLogStorageBackgroundTask(logConfig);
+  };
+  options?.registerCleanup?.(() => stopLogStorageTask());
   const configDir = dirname4(resolve8(store.getPath()));
   const pluginManager = new PluginManager(configDir);
   const reloadResult = await pluginManager.reloadAll(config2.providers);
@@ -60109,7 +60212,7 @@ async function createApp(store, options) {
     app.route(entry.mountPrefix, subApp);
     console.log(`\u5DF2\u6CE8\u518C\u8DEF\u7531: ${routeType} -> ${entry.mountPrefix}`);
   }
-  app.route("/api", createAdminApiRoutes(store, pluginManager, options?.registerCleanup));
+  app.route("/api", createAdminApiRoutes(store, pluginManager, options?.registerCleanup, options?.serverControl, restartLogStorageTask, serviceVersion));
   console.log("\u5DF2\u6CE8\u518C\u7BA1\u7406 API: /api");
   app.get("/api/docs", middleware({ url: "/api/openapi.json" }));
   app.get("/api/openapi.json", (c) => c.json(openAPISpec));
@@ -60138,11 +60241,12 @@ async function createApp(store, options) {
   }
   return app;
 }
-async function createAppRuntimeFromConfigPath(configPath, listen) {
+async function createAppRuntimeFromConfigPath(configPath, listen, serverControl) {
   const store = new ConfigStore(configPath);
   const cleanups = [];
   const app = await createApp(store, {
     listen,
+    serverControl,
     registerCleanup: (cleanup) => {
       cleanups.push(cleanup);
     }
@@ -60244,11 +60348,15 @@ function resolveIdleTimeoutSeconds(explicit) {
   return DEFAULT_IDLE_TIMEOUT_SECONDS;
 }
 async function startServer(options) {
+  const idleTimeout = resolveIdleTimeoutSeconds(options.idleTimeoutSeconds);
+  const requestRestart = options.requestRestart;
   const runtime = await createAppRuntimeFromConfigPath(options.configPath, {
     host: options.host,
     port: options.port
-  });
-  const idleTimeout = resolveIdleTimeoutSeconds(options.idleTimeoutSeconds);
+  }, requestRestart ? {
+    requestRestart,
+    current: { host: options.host, port: options.port, idleTimeout }
+  } : undefined);
   const server = Bun.serve({
     fetch: (request, server2) => {
       const remoteAddress = server2.requestIP(request)?.address ?? null;
@@ -60291,6 +60399,7 @@ var exports_process = {};
 __export(exports_process, {
   stopProcess: () => stopProcess,
   startDaemon: () => startDaemon,
+  spawnDetachedRestart: () => spawnDetachedRestart,
   runServerProcess: () => runServerProcess,
   readLogDelta: () => readLogDelta,
   parseSharedFlags: () => parseSharedFlags,
@@ -60448,7 +60557,8 @@ async function runServerProcess(opts) {
       configPath: ensured.path,
       host,
       port,
-      idleTimeoutSeconds: Number.isFinite(idleTimeoutSeconds) ? idleTimeoutSeconds : undefined
+      idleTimeoutSeconds: Number.isFinite(idleTimeoutSeconds) ? idleTimeoutSeconds : undefined,
+      requestRestart: () => spawnDetachedRestart({ configPath: ensured.path })
     });
   } catch (err) {
     const code = err?.code;
@@ -60552,6 +60662,32 @@ async function startDaemon(flags) {
   throw new Error(`\u540E\u53F0\u542F\u52A8\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u65E5\u5FD7: ${files.daemonLog}
 ${tail}`);
 }
+function spawnDetachedRestart(opts = {}) {
+  const trigger = () => {
+    try {
+      ensureRuntimeDirs();
+      const files = getRuntimeFiles();
+      const fd = openSync3(files.daemonLog, "a");
+      const cliScript = process.argv[1] ?? "src/cli.ts";
+      const childArgs = [cliScript, "restart"];
+      if (opts.configPath) {
+        childArgs.push("--config", opts.configPath);
+      }
+      const child = Bun.spawn([process.execPath, ...childArgs], {
+        stdin: "ignore",
+        stdout: fd,
+        stderr: fd,
+        detached: true
+      });
+      closeSync3(fd);
+      child.unref();
+    } catch (err) {
+      console.error(`[restart] \u81EA\u91CD\u542F\u89E6\u53D1\u5931\u8D25: ${err instanceof Error ? err.message : err}`);
+    }
+  };
+  const timer = setTimeout(trigger, 400);
+  timer.unref?.();
+}
 async function stopProcess(graceMs = 8000) {
   await cleanupIfStale();
   const state = readRuntimeState();
@@ -61194,6 +61330,10 @@ function normalizeOne(flag, raw2) {
 }
 function parseCommandArgs(def, args) {
   const options = toParseArgsOptions(def.flags);
+  for (const g of GLOBAL_TARGET_FLAG_NAMES) {
+    if (!(g in options))
+      options[g] = { type: "string" };
+  }
   let parsed;
   try {
     parsed = nodeParseArgs({
@@ -61205,7 +61345,7 @@ function parseCommandArgs(def, args) {
   } catch (err) {
     throw new CliError("USAGE_ERROR", err instanceof Error ? err.message : String(err));
   }
-  const known = new Set(def.flags?.map((f) => f.name) ?? []);
+  const known = new Set([...def.flags?.map((f) => f.name) ?? [], ...GLOBAL_TARGET_FLAG_NAMES]);
   for (const a of args) {
     if (!a.startsWith("--"))
       continue;
@@ -61273,8 +61413,10 @@ function levenshtein(a, b) {
   }
   return dp[b.length];
 }
+var GLOBAL_TARGET_FLAG_NAMES;
 var init_parse_args = __esm(() => {
   init_errors();
+  GLOBAL_TARGET_FLAG_NAMES = ["url", "host", "port"];
 });
 
 // src/cli/registry.ts
@@ -61570,9 +61712,298 @@ init_config_apply();
 init_errors();
 init_output();
 init_process();
+import { createInterface as createInterface5 } from "readline/promises";
+import { parseArgs as parseArgs3 } from "util";
+
+// src/cli/target.ts
+init_errors();
+init_output();
+init_process();
 init_runtime();
 import { createInterface as createInterface4 } from "readline/promises";
-import { parseArgs as parseArgs3 } from "util";
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_PORT = 4099;
+function normalizeHostForUrl(host) {
+  const h = host.trim();
+  if (h === "" || h === "0.0.0.0")
+    return "127.0.0.1";
+  if (h === "::" || h === "::1")
+    return "[::1]";
+  if (h.includes(":") && !h.startsWith("["))
+    return `[${h}]`;
+  return h;
+}
+function buildBaseUrl(host, port) {
+  return `http://${normalizeHostForUrl(host)}:${port}`;
+}
+async function fingerprint(baseUrl, timeoutMs = 800) {
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(`${baseUrl}/api/health`, { method: "GET", signal: controller.signal });
+    if (!res.ok)
+      return { ok: false };
+    const body = await res.json();
+    if (body?.service !== "local-router")
+      return { ok: false };
+    return { ok: true, version: body.version, host: body.host, port: body.port };
+  } catch {
+    return { ok: false };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function parseLsofPorts(output) {
+  const ports = new Set;
+  for (const line of output.split(`
+`)) {
+    if (!line.includes("LISTEN"))
+      continue;
+    const m = line.match(/(?:\*|\[[^\]]+\]|[\d.]+):(\d{2,5})\s*\(LISTEN\)/);
+    if (!m)
+      continue;
+    const port = Number.parseInt(m[1], 10);
+    if (Number.isFinite(port))
+      ports.add(port);
+  }
+  return [...ports];
+}
+function parseNetstatPorts(output) {
+  const ports = new Set;
+  for (const line of output.split(`
+`)) {
+    if (!/LISTEN/i.test(line))
+      continue;
+    const m = line.match(/[.:](\d{2,5})\s+\S+\s+LISTEN/i) ?? line.match(/[.:](\d{2,5})\s+LISTEN/i);
+    if (!m)
+      continue;
+    const port = Number.parseInt(m[1], 10);
+    if (Number.isFinite(port))
+      ports.add(port);
+  }
+  return [...ports];
+}
+async function runShellCommand(cmd) {
+  try {
+    const proc = Bun.spawn(cmd, { stdout: "pipe", stderr: "ignore", stdin: "ignore" });
+    const out = await new Response(proc.stdout).text();
+    await proc.exited;
+    return out;
+  } catch {
+    return null;
+  }
+}
+async function listListeningPorts() {
+  const ports = new Set;
+  const lsof = await runShellCommand(["lsof", "-nP", "-iTCP", "-sTCP:LISTEN"]);
+  if (lsof) {
+    for (const p of parseLsofPorts(lsof))
+      ports.add(p);
+  }
+  if (ports.size === 0) {
+    const netstat = await runShellCommand(["netstat", "-an"]);
+    if (netstat) {
+      for (const p of parseNetstatPorts(netstat))
+        ports.add(p);
+    }
+  }
+  return [...ports].sort((a, b) => a - b);
+}
+async function discoverLocalRouters(timeoutMs = 300) {
+  const ports = await listListeningPorts();
+  const hits = [];
+  const concurrency = 8;
+  let idx = 0;
+  const worker = async () => {
+    while (idx < ports.length) {
+      const port = ports[idx++];
+      const fp = await fingerprint(buildBaseUrl(DEFAULT_HOST, port), timeoutMs);
+      if (fp.ok)
+        hits.push({ port, version: fp.version });
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(concurrency, ports.length) }, () => worker()));
+  return hits.sort((a, b) => a.port - b.port);
+}
+async function fromExplicit(url2, host, port, source) {
+  if (url2) {
+    let u;
+    try {
+      u = new URL(url2);
+    } catch {
+      throw new CliError("USAGE_ERROR", `\u65E0\u6548 URL: ${url2}`, { hint: "\u5F62\u5982 http://127.0.0.1:4099" });
+    }
+    const baseUrl = u.origin;
+    const fp = await fingerprint(baseUrl);
+    if (!fp.ok) {
+      throw new CliError("TARGET_UNREACHABLE", `\u76EE\u6807\u65E0\u6CD5\u8FDE\u901A: ${baseUrl}`, {
+        hint: "\u786E\u8BA4\u5730\u5740\u6B63\u786E\u4E14 local-router \u6B63\u5728\u8BE5\u5730\u5740\u76D1\u542C"
+      });
+    }
+    const portNum = u.port ? Number.parseInt(u.port, 10) : u.protocol === "https:" ? 443 : 80;
+    return { baseUrl, host: u.hostname, port: portNum, version: fp.version, source };
+  }
+  if (port !== undefined || host !== undefined) {
+    const h = host ?? DEFAULT_HOST;
+    const p = port ?? DEFAULT_PORT;
+    const baseUrl = buildBaseUrl(h, p);
+    const fp = await fingerprint(baseUrl);
+    if (!fp.ok) {
+      throw new CliError("TARGET_UNREACHABLE", `\u76EE\u6807\u65E0\u6CD5\u8FDE\u901A: ${baseUrl}`, {
+        hint: "\u786E\u8BA4\u7AEF\u53E3\u6B63\u786E\u4E14 local-router \u6B63\u5728\u76D1\u542C"
+      });
+    }
+    return { baseUrl, host: h, port: p, version: fp.version, source };
+  }
+  return null;
+}
+async function promptPort() {
+  const rl = createInterface4({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question(`\u672A\u53D1\u73B0 local-router\uFF0C\u8BF7\u8F93\u5165\u7AEF\u53E3 [${DEFAULT_PORT}]: `)).trim();
+    const port = answer === "" ? DEFAULT_PORT : Number.parseInt(answer, 10);
+    if (!Number.isFinite(port) || port <= 0 || port > 65535) {
+      throw new CliError("USAGE_ERROR", `\u65E0\u6548\u7AEF\u53E3: ${answer}`, { hint: "\u7AEF\u53E3\u8303\u56F4 1-65535" });
+    }
+    return port;
+  } finally {
+    rl.close();
+  }
+}
+async function promptSelectPort(found) {
+  const rl = createInterface4({ input: process.stdin, output: process.stdout });
+  try {
+    console.log("\u53D1\u73B0\u591A\u4E2A local-router\uFF1A");
+    found.forEach((f, i) => {
+      console.log(`  ${i + 1}) 127.0.0.1:${f.port}${f.version ? ` (v${f.version})` : ""}`);
+    });
+    const answer = (await rl.question("\u8BF7\u8F93\u5165\u5E8F\u53F7: ")).trim();
+    const idx = Number.parseInt(answer, 10) - 1;
+    if (!Number.isFinite(idx) || idx < 0 || idx >= found.length) {
+      throw new CliError("USAGE_ERROR", `\u65E0\u6548\u5E8F\u53F7: ${answer}`);
+    }
+    return found[idx].port;
+  } finally {
+    rl.close();
+  }
+}
+function discoveredTarget(found) {
+  return {
+    baseUrl: buildBaseUrl(DEFAULT_HOST, found.port),
+    host: DEFAULT_HOST,
+    port: found.port,
+    version: found.version,
+    source: "discovered"
+  };
+}
+async function resolveTarget(flags) {
+  const explicit = await fromExplicit(flags.target?.url, flags.target?.host, flags.target?.port, "flag");
+  if (explicit)
+    return explicit;
+  const envUrl = process.env.LOCAL_ROUTER_URL?.trim() || undefined;
+  const envPortRaw = process.env.LOCAL_ROUTER_PORT?.trim();
+  let envPort;
+  if (envPortRaw) {
+    envPort = Number.parseInt(envPortRaw, 10);
+    if (!Number.isFinite(envPort)) {
+      throw new CliError("USAGE_ERROR", `\u65E0\u6548 LOCAL_ROUTER_PORT: ${envPortRaw}`);
+    }
+  }
+  const env = await fromExplicit(envUrl, undefined, envPort, "env");
+  if (env)
+    return env;
+  const state = readRuntimeState();
+  if (state && isProcessAlive(state.pid)) {
+    const fp = await fingerprint(state.baseUrl);
+    if (fp.ok) {
+      return {
+        baseUrl: state.baseUrl,
+        host: resolveLocalAccessHost(state.host),
+        port: state.port,
+        version: fp.version,
+        source: "runtime"
+      };
+    }
+  }
+  const defaultUrl = buildBaseUrl(DEFAULT_HOST, DEFAULT_PORT);
+  const defFp = await fingerprint(defaultUrl);
+  if (defFp.ok) {
+    return {
+      baseUrl: defaultUrl,
+      host: DEFAULT_HOST,
+      port: DEFAULT_PORT,
+      version: defFp.version,
+      source: "default"
+    };
+  }
+  const found = await discoverLocalRouters();
+  if (found.length === 1) {
+    return discoveredTarget(found[0]);
+  }
+  if (found.length > 1) {
+    if (flags.yes)
+      return discoveredTarget(found[0]);
+    if (flags.noInteractive || !process.stdin.isTTY) {
+      throw new CliError("TARGET_NOT_FOUND", "\u53D1\u73B0\u591A\u4E2A local-router\uFF0C\u8BF7\u7528 --port \u6307\u5B9A", {
+        hint: `\u5019\u9009\u7AEF\u53E3: ${found.map((f) => f.port).join(", ")}`,
+        details: { candidates: found }
+      });
+    }
+    const picked = await promptSelectPort(found);
+    return discoveredTarget(found.find((f) => f.port === picked) ?? { port: picked });
+  }
+  if (!flags.noInteractive && process.stdin.isTTY) {
+    const port = await promptPort();
+    const baseUrl = buildBaseUrl(DEFAULT_HOST, port);
+    const fp = await fingerprint(baseUrl);
+    if (!fp.ok) {
+      throw new CliError("TARGET_UNREACHABLE", `\u7AEF\u53E3 ${port} \u4E0A\u6CA1\u6709 local-router`);
+    }
+    return { baseUrl, host: DEFAULT_HOST, port, version: fp.version, source: "prompt" };
+  }
+  throw new CliError("TARGET_NOT_FOUND", "\u627E\u4E0D\u5230\u53EF\u8FDE\u63A5\u7684 local-router", {
+    hint: "`local-router start` \u542F\u52A8\uFF1B\u6216\u7528 --port <port> / --url <url> \u6307\u5B9A\u76EE\u6807"
+  });
+}
+function guessTargetUrl(flags) {
+  if (flags.target?.url) {
+    try {
+      const u = new URL(flags.target.url);
+      const port = u.port ? Number.parseInt(u.port, 10) : u.protocol === "https:" ? 443 : 80;
+      return { baseUrl: u.origin, host: u.hostname, port, running: false };
+    } catch {}
+  }
+  if (flags.target?.port !== undefined || flags.target?.host !== undefined) {
+    const host = flags.target.host ?? DEFAULT_HOST;
+    const port = flags.target.port ?? DEFAULT_PORT;
+    return { baseUrl: buildBaseUrl(host, port), host, port, running: false };
+  }
+  const state = readRuntimeState();
+  if (state && isProcessAlive(state.pid)) {
+    return {
+      baseUrl: state.baseUrl,
+      host: resolveLocalAccessHost(state.host),
+      port: state.port,
+      running: true
+    };
+  }
+  return {
+    baseUrl: buildBaseUrl(DEFAULT_HOST, DEFAULT_PORT),
+    host: DEFAULT_HOST,
+    port: DEFAULT_PORT,
+    running: false
+  };
+}
+function targetMetaLine(t) {
+  return `\u2192 ${t.host}:${t.port}${t.version ? ` (v${t.version})` : ""} \xB7 ${t.source}`;
+}
+async function requireTarget(ctx) {
+  const t = await resolveTarget(ctx.flags);
+  emitDiagnostic(ctx, targetMetaLine(t));
+  return t;
+}
+
+// src/cli/config-command.ts
 function readConfig(configArg) {
   const path = resolveConfigPath(configArg);
   return { path, config: loadConfig(path) };
@@ -61640,7 +62071,7 @@ async function selectFromList(title, items) {
   items.forEach((item, i) => {
     console.log(`  ${i + 1}) ${item}`);
   });
-  const rl = createInterface4({ input: process.stdin, output: process.stdout });
+  const rl = createInterface5({ input: process.stdin, output: process.stdout });
   try {
     const answer = await rl.question("\u8BF7\u8F93\u5165\u5E8F\u53F7: ");
     const idx = Number.parseInt(answer, 10) - 1;
@@ -62511,32 +62942,26 @@ async function handleApply(args, flags) {
     command: "config.apply",
     flags,
     fn: async (ctx) => {
-      await cleanupIfStale();
-      const state = readRuntimeState();
-      if (!state) {
-        throw new CliError("SERVICE_NOT_RUNNING", "\u670D\u52A1\u672A\u8FD0\u884C\uFF0C\u65E0\u6CD5 apply", {
-          hint: "\u542F\u52A8: `local-router start --daemon`"
-        });
-      }
-      const res = await fetch(`${state.baseUrl}/api/config/apply`, { method: "POST" });
+      const target = await requireTarget(ctx);
+      const res = await fetch(`${target.baseUrl}/api/config/apply`, { method: "POST" });
       if (!res.ok) {
         const text2 = await res.text();
         throw new CliError("APPLY_FAILED", `apply \u5931\u8D25: ${res.status} ${text2}`, {
-          details: { status: res.status, baseUrl: state.baseUrl }
+          details: { status: res.status, baseUrl: target.baseUrl }
         });
       }
-      const healthy = await checkHealth(state.baseUrl);
+      const healthy = await checkHealth(target.baseUrl);
       if (!healthy) {
-        throw new CliError("HEALTH_FAILED", `apply \u540E\u5065\u5EB7\u68C0\u67E5\u5931\u8D25: ${state.baseUrl}`);
+        throw new CliError("HEALTH_FAILED", `apply \u540E\u5065\u5EB7\u68C0\u67E5\u5931\u8D25: ${target.baseUrl}`);
       }
       emitResult(ctx, {
         command: "config.apply",
-        data: { ok: true, baseUrl: state.baseUrl },
+        data: { ok: true, baseUrl: target.baseUrl },
         md: {
           heading: "config.apply \xB7 \u2713",
-          data: `\u5DF2\u5E94\u7528: \`${state.baseUrl}\``
+          data: `\u5DF2\u5E94\u7528: \`${target.baseUrl}\``
         },
-        text: `\u914D\u7F6E\u5DF2\u5E94\u7528: ${state.baseUrl}`
+        text: `\u914D\u7F6E\u5DF2\u5E94\u7528: ${target.baseUrl}`
       });
     }
   });
@@ -63109,10 +63534,8 @@ defineSchemaCommand({
 // src/cli/handlers/chat.ts
 init_errors();
 init_output();
-init_process();
 init_registry();
-init_runtime();
-import { createInterface as createInterface5 } from "readline/promises";
+import { createInterface as createInterface6 } from "readline/promises";
 defineSchemaCommand({
   name: "chat",
   summary: "\u4EA4\u4E92\u5F0F REPL\uFF08\u9ED8\u8BA4\u8D70 openai-completions\uFF0C\u6D41\u5F0F\uFF09",
@@ -63131,25 +63554,19 @@ defineSchemaCommand({
     { name: "no-stream", type: "boolean", description: "\u7981\u7528\u6D41\u5F0F\uFF08\u4E00\u6B21\u8FD4\u56DE\uFF09" }
   ],
   fn: async ({ values, ctx }) => {
-    await cleanupIfStale();
-    const state = readRuntimeState();
-    if (!state)
-      throw new CliError("SERVICE_NOT_RUNNING", "\u670D\u52A1\u672A\u8FD0\u884C");
-    if (!await checkHealth(state.baseUrl)) {
-      throw new CliError("HEALTH_FAILED", `\u670D\u52A1\u5065\u5EB7\u68C0\u67E5\u5931\u8D25: ${state.baseUrl}`);
-    }
     if (!process.stdin.isTTY) {
       throw new CliError("INTERACTIVE_REQUIRED", "chat \u9700\u8981 TTY", {
         hint: "\u7BA1\u9053\u573A\u666F\u8BF7\u7528 `local-router try`"
       });
     }
-    const baseUrl = state.baseUrl.replace(/\/+$/, "");
+    const target = await requireTarget(ctx);
+    const baseUrl = target.baseUrl.replace(/\/+$/, "");
     const url2 = `${baseUrl}/openai-completions/v1/chat/completions`;
     const messages = [];
     if (values.system)
       messages.push({ role: "system", content: values.system });
     emitDiagnostic(ctx, `chat \u2192 ${values.entry}/${values.model} \xB7 \u8F93\u5165 \`/exit\` \u6216 Ctrl+C \u9000\u51FA \xB7 /reset \u6E05\u7A7A\u4E0A\u4E0B\u6587`);
-    const rl = createInterface5({ input: process.stdin, output: process.stdout });
+    const rl = createInterface6({ input: process.stdin, output: process.stdout });
     try {
       while (true) {
         const input = (await rl.question("\u203A ")).trim();
@@ -63599,7 +64016,6 @@ init_config_apply();
 init_errors();
 init_output();
 init_registry();
-init_runtime();
 import { spawnSync } from "child_process";
 import { copyFileSync, existsSync as existsSync13, mkdtempSync, rmSync as rmSync4 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
@@ -63679,7 +64095,10 @@ function platformOpen(target) {
     args = [target];
   }
   const r = spawnSync(cmd, args, { stdio: "ignore" });
-  return { ok: !r.error && (typeof r.status !== "number" || r.status === 0), cmd: `${cmd} ${args.join(" ")}` };
+  return {
+    ok: !r.error && (typeof r.status !== "number" || r.status === 0),
+    cmd: `${cmd} ${args.join(" ")}`
+  };
 }
 defineSchemaCommand({
   name: "open",
@@ -63693,7 +64112,7 @@ defineSchemaCommand({
     }
   ],
   flags: [{ name: "config", type: "string", description: "\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84" }],
-  fn: ({ positionals, values, ctx }) => {
+  fn: async ({ positionals, values, ctx }) => {
     const target = positionals[0];
     if (!target) {
       throw new CliError("USAGE_ERROR", "\u7528\u6CD5: open <admin|docs|logs-dir|config>");
@@ -63701,13 +64120,8 @@ defineSchemaCommand({
     let url2;
     let label;
     if (target === "admin") {
-      const state = readRuntimeState();
-      if (!state) {
-        throw new CliError("SERVICE_NOT_RUNNING", "\u670D\u52A1\u672A\u8FD0\u884C\uFF0C\u65E0\u6CD5\u6253\u5F00 admin", {
-          hint: "`local-router start --daemon`"
-        });
-      }
-      url2 = `${state.baseUrl}/admin/`;
+      const resolved = await resolveTarget(ctx.flags);
+      url2 = `${resolved.baseUrl}/admin/`;
       label = "Web Admin";
     } else if (target === "docs") {
       url2 = "https://github.com/lakphy/local-router#readme";
@@ -63759,8 +64173,9 @@ defineSchemaCommand({
     { name: "config", type: "string", description: "\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84" }
   ],
   fn: ({ values, ctx }) => {
-    const state = readRuntimeState();
-    const baseUrl = state?.baseUrl ?? "http://127.0.0.1:4099";
+    const guess = guessTargetUrl(ctx.flags);
+    const baseUrl = guess.baseUrl;
+    const running = guess.running;
     const entries = [
       {
         key: "OPENAI_BASE_URL",
@@ -63804,12 +64219,12 @@ defineSchemaCommand({
       data: {
         baseUrl,
         shell: values.shell,
-        running: !!state,
+        running,
         entries,
         script
       },
       md: {
-        heading: `env \xB7 ${state ? "\u2713 \u8FD0\u884C\u4E2D" : "\u2717 \u672A\u8FD0\u884C\uFF08\u4F7F\u7528\u9ED8\u8BA4 4099\uFF09"}`,
+        heading: `env \xB7 ${running ? "\u2713 \u8FD0\u884C\u4E2D" : "\u2717 \u672A\u8FD0\u884C\uFF08\u4F7F\u7528\u9ED8\u8BA4 4099\uFF09"}`,
         meta: [`baseUrl: \`${baseUrl}\``],
         data: [
           renderKv(entries.map((e) => ({ key: e.key, value: e.value }))),
@@ -64109,14 +64524,8 @@ defineSchemaCommand({
   ],
   fn: async ({ values, ctx }) => {
     const { entry, model, prompt, stream: streamMode, timeout: timeoutSec } = values;
-    await cleanupIfStale();
-    const state = readRuntimeState();
-    if (!state) {
-      throw new CliError("SERVICE_NOT_RUNNING", "\u670D\u52A1\u672A\u8FD0\u884C", {
-        hint: "`local-router start --daemon`"
-      });
-    }
-    const payload = buildTryPayload(entry, model, prompt, state.baseUrl);
+    const target = await requireTarget(ctx);
+    const payload = buildTryPayload(entry, model, prompt, target.baseUrl);
     const controller = new AbortController;
     const timer = setTimeout(() => controller.abort(), timeoutSec * 1000);
     const startedAt = Date.now();
@@ -64254,35 +64663,6 @@ defineSchemaCommand({
 import { readFileSync as readFileSync11 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
-// src/cli/asset-paths.ts
-async function findExisting(...candidates) {
-  for (const url2 of candidates) {
-    try {
-      const exists = await Bun.file(url2).exists();
-      if (exists)
-        return url2;
-    } catch {}
-  }
-  return null;
-}
-async function readPackageJson() {
-  const url2 = await findExisting(new URL("../../package.json", import.meta.url), new URL("../package.json", import.meta.url), new URL("../../../package.json", import.meta.url));
-  if (!url2)
-    return null;
-  try {
-    return await Bun.file(url2).json();
-  } catch {
-    return null;
-  }
-}
-async function findConfigSchemaUrl() {
-  return findExisting(new URL("../../config.schema.json", import.meta.url), new URL("../config.schema.json", import.meta.url), new URL("../../../config.schema.json", import.meta.url));
-}
-async function readVersionString() {
-  const pkg = await readPackageJson();
-  return typeof pkg?.version === "string" ? pkg.version : "unknown";
-}
-
 // src/cli/error-docs.ts
 var ERROR_DOCS = {
   USAGE_ERROR: {
@@ -64375,6 +64755,16 @@ var ERROR_DOCS = {
     cause: "\u547D\u4EE4\u7F3A\u5C11\u5FC5\u586B flag\uFF0C\u672C\u5E94\u5F39\u51FA\u9009\u62E9\u5668\u4F46\u5F53\u524D stdin \u4E0D\u662F TTY \u6216\u663E\u5F0F `--no-interactive`\u3002",
     fix: "\u5728\u9519\u8BEF\u7684 `details` \u91CC\u67E5\u770B\u5019\u9009\u9879\uFF0C\u663E\u5F0F\u8865 `--provider/--model` \u7B49\u3002"
   },
+  TARGET_NOT_FOUND: {
+    summary: "\u627E\u4E0D\u5230\u53EF\u8FDE\u63A5\u7684 local-router",
+    cause: "\u9ED8\u8BA4\u7AEF\u53E3 4099 \u4E0A\u6CA1\u6709 local-router\uFF0COS \u8FDB\u7A0B\u679A\u4E3E\u4E5F\u672A\u53D1\u73B0\u5176\u5B83\u5B9E\u4F8B\u3002",
+    fix: "`local-router start` \u542F\u52A8\uFF1B\u6216\u7528 `--port <port>` / `--url <url>` \u6307\u5B9A\u76EE\u6807\u3002"
+  },
+  TARGET_UNREACHABLE: {
+    summary: "\u6307\u5B9A\u7684\u76EE\u6807\u65E0\u6CD5\u8FDE\u901A",
+    cause: "`--port` / `--url`\uFF08\u6216\u73AF\u5883\u53D8\u91CF\uFF09\u6307\u5411\u7684\u5730\u5740\u6CA1\u6709\u54CD\u5E94 `/api/health` \u6216\u4E0D\u662F local-router\u3002",
+    fix: "\u786E\u8BA4\u76EE\u6807\u7AEF\u53E3/\u5730\u5740\u6B63\u786E\u4E14 local-router \u6B63\u5728\u8BE5\u5730\u5740\u76D1\u542C\u3002"
+  },
   UNKNOWN_ERROR: {
     summary: "\u672A\u77E5\u9519\u8BEF",
     cause: "\u6CA1\u6709\u5339\u914D\u5230\u4EFB\u4F55 CliError \u7C7B\u578B\u3002",
@@ -64821,13 +65211,13 @@ defineSchemaCommand({
 
 // src/cli/handlers/lifecycle.ts
 init_config();
-import { existsSync as existsSync15, readFileSync as readFileSync12 } from "fs";
-import { setTimeout as sleep3 } from "timers/promises";
 init_errors();
 init_output();
 init_process();
 init_registry();
 init_runtime();
+import { existsSync as existsSync15, readFileSync as readFileSync12 } from "fs";
+import { setTimeout as sleep3 } from "timers/promises";
 
 // src/cli/wait.ts
 init_errors();
@@ -65046,34 +65436,34 @@ defineSchemaCommand({
   fn: async ({ values, ctx }) => {
     const retry = Math.max(1, values.retry || 1);
     const interval = Math.max(0, values["retry-interval"] || 1);
-    await cleanupIfStale();
-    const state = readRuntimeState();
-    if (!state) {
-      throw new CliError("SERVICE_NOT_RUNNING", "\u670D\u52A1\u672A\u8FD0\u884C", {
-        hint: "\u542F\u52A8: `local-router start --daemon`"
-      });
-    }
+    const target = guessTargetUrl(ctx.flags);
+    const baseUrl = target.baseUrl;
     let ok = false;
     for (let i = 0;i < retry; i++) {
-      ok = await checkHealth(state.baseUrl);
+      ok = await checkHealth(baseUrl);
       if (ok)
         break;
       if (i < retry - 1)
         await sleep3(interval * 1000);
     }
     if (!ok) {
-      throw new CliError("HEALTH_FAILED", `\u5065\u5EB7\u68C0\u67E5\u5931\u8D25: ${state.baseUrl}/api/health`, {
-        details: { baseUrl: state.baseUrl, retries: retry }
+      if (!target.running && !ctx.flags.target) {
+        throw new CliError("SERVICE_NOT_RUNNING", "\u670D\u52A1\u672A\u8FD0\u884C", {
+          hint: "\u542F\u52A8: `local-router start --daemon`"
+        });
+      }
+      throw new CliError("HEALTH_FAILED", `\u5065\u5EB7\u68C0\u67E5\u5931\u8D25: ${baseUrl}/api/health`, {
+        details: { baseUrl, retries: retry }
       });
     }
     emitResult(ctx, {
       command: "health",
-      data: { ok: true, baseUrl: state.baseUrl },
+      data: { ok: true, baseUrl },
       md: {
         heading: "health \xB7 \u2713 ok",
-        meta: [`\u5730\u5740 ${state.baseUrl}`]
+        meta: [`\u5730\u5740 ${baseUrl}`]
       },
-      text: `\u5065\u5EB7\u68C0\u67E5\u901A\u8FC7: ${state.baseUrl}`
+      text: `\u5065\u5EB7\u68C0\u67E5\u901A\u8FC7: ${baseUrl}`
     });
   }
 });
@@ -65187,22 +65577,10 @@ defineSchemaCommand({
 // src/cli/handlers/logs.ts
 init_errors();
 init_output();
-init_process();
 init_registry();
-init_runtime();
-async function requireRunning() {
-  await cleanupIfStale();
-  const state = readRuntimeState();
-  if (!state) {
-    throw new CliError("SERVICE_NOT_RUNNING", "\u65E5\u5FD7\u67E5\u8BE2\u9700\u8981\u670D\u52A1\u8FD0\u884C", {
-      hint: "`local-router start --daemon`"
-    });
-  }
-  const ok = await checkHealth(state.baseUrl);
-  if (!ok) {
-    throw new CliError("HEALTH_FAILED", `\u670D\u52A1\u5065\u5EB7\u68C0\u67E5\u5931\u8D25: ${state.baseUrl}`);
-  }
-  return { baseUrl: state.baseUrl };
+async function requireRunning(ctx) {
+  const t = await requireTarget(ctx);
+  return { baseUrl: t.baseUrl };
 }
 async function fetchJson(url2, init) {
   const res = await fetch(url2, init);
@@ -65250,7 +65628,7 @@ defineSchemaCommand({
     { name: "cursor", type: "string", description: "\u5206\u9875\u6E38\u6807" }
   ],
   fn: async ({ values, ctx }) => {
-    const { baseUrl } = await requireRunning();
+    const { baseUrl } = await requireRunning(ctx);
     const params = new URLSearchParams;
     const set2 = (k, v) => {
       if (v !== undefined && v !== null && v !== "" && v !== false) {
@@ -65315,7 +65693,7 @@ defineSchemaCommand({
     const id = positionals[0];
     if (!id)
       throw new CliError("USAGE_ERROR", "\u7528\u6CD5: logs event <id>");
-    const { baseUrl } = await requireRunning();
+    const { baseUrl } = await requireRunning(ctx);
     const params = new URLSearchParams;
     if (values["include-stream"])
       params.set("includeStream", "true");
@@ -65361,7 +65739,7 @@ defineSchemaCommand({
     }
   ],
   fn: async ({ values, ctx }) => {
-    const { baseUrl } = await requireRunning();
+    const { baseUrl } = await requireRunning(ctx);
     const w = values.window ?? "24h";
     const { status, json: json3 } = await fetchJson(`${baseUrl}/api/logs/events?window=${w}&hasError=true&limit=1&sort=time_desc`);
     if (status !== 200)
@@ -65413,7 +65791,7 @@ defineSchemaCommand({
     }
   ],
   fn: async ({ values, ctx }) => {
-    const { baseUrl } = await requireRunning();
+    const { baseUrl } = await requireRunning(ctx);
     const w = values.window ?? "24h";
     const { status, json: json3 } = await fetchJson(`${baseUrl}/api/metrics/logs?window=${w}`);
     if (status !== 200) {
@@ -65458,7 +65836,7 @@ defineSchemaCommand({
   supportsJson: true,
   requiresRunning: true,
   fn: async ({ ctx }) => {
-    const { baseUrl } = await requireRunning();
+    const { baseUrl } = await requireRunning(ctx);
     const { status, json: json3 } = await fetchJson(`${baseUrl}/api/logs/storage`);
     if (status !== 200) {
       throw new CliError("UNKNOWN_ERROR", `\u83B7\u53D6 storage \u5931\u8D25: ${status}`, { details: json3 });
@@ -65487,7 +65865,7 @@ defineSchemaCommand({
     { name: "limit", type: "number", default: 50, description: "\u6700\u5927 session \u6570" }
   ],
   fn: async ({ values, ctx }) => {
-    const { baseUrl } = await requireRunning();
+    const { baseUrl } = await requireRunning(ctx);
     const params = new URLSearchParams;
     params.set("window", values.window ?? "24h");
     if (values.user)
@@ -65501,7 +65879,10 @@ defineSchemaCommand({
     emitResult(ctx, {
       command: "logs.sessions",
       data: json3,
-      md: { heading: "logs.sessions", data: renderCodeBlock(JSON.stringify(json3, null, 2), "json") }
+      md: {
+        heading: "logs.sessions",
+        data: renderCodeBlock(JSON.stringify(json3, null, 2), "json")
+      }
     });
   }
 });
@@ -65511,7 +65892,7 @@ defineSchemaCommand({
   supportsJson: true,
   requiresRunning: true,
   fn: async ({ ctx }) => {
-    const { baseUrl } = await requireRunning();
+    const { baseUrl } = await requireRunning(ctx);
     const stream = startStream(ctx, "logs.tail");
     const res = await fetch(`${baseUrl}/api/logs/tail`, {
       headers: { accept: "text/event-stream" }
@@ -65573,8 +65954,8 @@ defineSchemaCommand({
     { name: "from", type: "string", description: "ISO \u8D77\u70B9" },
     { name: "to", type: "string", description: "ISO \u7EC8\u70B9" }
   ],
-  fn: async ({ values }) => {
-    const { baseUrl } = await requireRunning();
+  fn: async ({ values, ctx }) => {
+    const { baseUrl } = await requireRunning(ctx);
     const params = new URLSearchParams;
     params.set("format", values.format ?? "jsonl");
     params.set("window", values.window ?? "24h");
@@ -65605,7 +65986,7 @@ defineSchemaCommand({
     const id = positionals[0];
     if (!id)
       throw new CliError("USAGE_ERROR", "\u7528\u6CD5: logs replay <event-id>");
-    const { baseUrl } = await requireRunning();
+    const { baseUrl } = await requireRunning(ctx);
     const detailRes = await fetchJson(`${baseUrl}/api/logs/events/${encodeURIComponent(id)}`);
     if (detailRes.status === 404)
       throw new CliError("ROUTE_NOT_FOUND", `\u4E8B\u4EF6\u4E0D\u5B58\u5728: ${id}`);
@@ -65658,7 +66039,6 @@ defineSchemaCommand({
 init_config();
 init_errors();
 init_output();
-init_process();
 init_registry();
 init_runtime();
 import { existsSync as existsSync16, rmSync as rmSync5 } from "fs";
@@ -65673,15 +66053,9 @@ async function fetchJson2(url2) {
   } catch {}
   return { status: res.status, json: json3 };
 }
-async function requireBaseUrl() {
-  await cleanupIfStale();
-  const state = readRuntimeState();
-  if (!state)
-    throw new CliError("SERVICE_NOT_RUNNING", "\u670D\u52A1\u672A\u8FD0\u884C");
-  if (!await checkHealth(state.baseUrl)) {
-    throw new CliError("HEALTH_FAILED", `\u670D\u52A1\u5065\u5EB7\u68C0\u67E5\u5931\u8D25: ${state.baseUrl}`);
-  }
-  return state.baseUrl;
+async function requireBaseUrl(ctx) {
+  const t = await requireTarget(ctx);
+  return t.baseUrl;
 }
 defineSchemaCommand({
   name: "logs tokens",
@@ -65698,7 +66072,7 @@ defineSchemaCommand({
     }
   ],
   fn: async ({ values, ctx }) => {
-    const baseUrl = await requireBaseUrl();
+    const baseUrl = await requireBaseUrl(ctx);
     const { status, json: json3 } = await fetchJson2(`${baseUrl}/api/logs/events?window=${values.window}&limit=1`);
     if (status !== 200) {
       throw new CliError("UNKNOWN_ERROR", `\u67E5\u8BE2\u5931\u8D25: ${status}`, { details: json3 });
@@ -65763,7 +66137,7 @@ defineSchemaCommand({
     }
   ],
   fn: async ({ values, ctx }) => {
-    const baseUrl = await requireBaseUrl();
+    const baseUrl = await requireBaseUrl(ctx);
     let rateTable = {};
     if (values["rate-table"]) {
       try {
@@ -66253,6 +66627,59 @@ defineSchemaCommand({
   }
 });
 
+// src/cli/handlers/target.ts
+init_output();
+init_registry();
+var SOURCE_LABEL = {
+  flag: "\u547D\u4EE4\u884C --port/--url/--host",
+  env: "\u73AF\u5883\u53D8\u91CF LOCAL_ROUTER_URL/PORT",
+  runtime: "\u672C\u673A daemon (status.json)",
+  default: "\u9ED8\u8BA4\u7AEF\u53E3 4099",
+  discovered: "OS \u8FDB\u7A0B\u679A\u4E3E\u53D1\u73B0",
+  prompt: "\u4EA4\u4E92\u8F93\u5165"
+};
+defineSchemaCommand({
+  name: "target",
+  summary: "\u663E\u793A\u5F53\u524D\u89E3\u6790\u5230\u7684 local-router \u76EE\u6807\uFF08\u7AEF\u53E3/\u6765\u6E90/\u7248\u672C\uFF09",
+  supportsJson: true,
+  requiresRunning: false,
+  flags: [],
+  fn: async ({ ctx }) => {
+    const t = await resolveTarget(ctx.flags);
+    const candidates = ctx.flags.verbose ? await discoverLocalRouters() : [];
+    emitResult(ctx, {
+      command: "target",
+      data: {
+        baseUrl: t.baseUrl,
+        host: t.host,
+        port: t.port,
+        version: t.version ?? null,
+        source: t.source,
+        candidates: ctx.flags.verbose ? candidates.map((c) => ({ port: c.port, version: c.version ?? null })) : undefined
+      },
+      md: {
+        heading: `target \xB7 ${t.host}:${t.port}${t.version ? ` (v${t.version})` : ""}`,
+        meta: [`\u6765\u6E90: ${SOURCE_LABEL[t.source] ?? t.source}`],
+        data: [
+          renderKv([
+            { key: "baseUrl", value: t.baseUrl },
+            { key: "host", value: t.host },
+            { key: "port", value: t.port },
+            { key: "version", value: t.version ?? "unknown" },
+            { key: "source", value: t.source }
+          ]),
+          ctx.flags.verbose ? `**\u53D1\u73B0\u7684\u5B9E\u4F8B**
+
+${candidates.length > 0 ? renderTable(["port", "version"], candidates.map((c) => [String(c.port), c.version ?? "?"])) : "\uFF08\u672A\u53D1\u73B0\u5176\u5B83\u5B9E\u4F8B\uFF09"}` : ""
+        ].filter(Boolean).join(`
+
+`)
+      },
+      text: t.baseUrl
+    });
+  }
+});
+
 // src/cli.ts
 init_output();
 init_parse_args();