@lakphy/local-router 0.3.0 → 0.3.3

package/README.md

@@ -99,6 +99,7 @@ local-router version
 - `--host <host>`：指定监听地址
 - `--port <port>`：指定监听端口
 - `--daemon`：后台运行
+- `--idle-timeout <sec>`：设置 Bun 连接空闲超时（默认 600 秒，设为 `0` 可关闭）
 
 ## 请求入口（给你的应用调用）
 
@@ -195,6 +196,25 @@ curl -X POST "http://127.0.0.1:4099/openai-completions/v1/chat/completions" \
 - `routes` 引用的 provider 是否存在
 - 配置文件是否是合法 JSON5
 
+
+### 运行较久请求出现 `[Bun.serve]: request timed out after 10 seconds` 怎么办？
+
+这是 Bun 服务端连接空闲超时触发导致的（常见于长流式响应或慢速上游）。
+
+可在启动时放宽超时：
+
+```sh
+local-router start --idle-timeout 600
+# 或彻底关闭空闲超时
+local-router start --idle-timeout 0
+```
+
+也支持环境变量：
+
+```sh
+LOCAL_ROUTER_IDLE_TIMEOUT=600 local-router start
+```
+
 ### 如何升级？
 
 ```sh

package/config.schema.json

@@ -218,8 +218,8 @@
           "type": "string",
           "enum": ["off", "masked", "full"],
           "default": "off",
-          "description": "请求体与响应体的记录策略。off：不记录 body 内容（推荐日常使用）；masked：脱敏后记录（当前版本行为同 full，后续将完善字段级脱敏）；full：完整记录所有内容（仅建议调试时临时开启，注意隐私风险）。",
-          "markdownDescription": "请求体与响应体的记录策略：\n- `off`：不记录 body 内容（推荐日常使用）\n- `masked`：脱敏后记录（当前版本行为同 `full`，后续完善）\n- `full`：完整记录所有内容（仅调试时使用）"
+          "description": "请求体与响应体的记录策略。off：不记录 body 内容（推荐日常使用）；full：完整记录所有内容（仅建议调试时临时开启，注意隐私风险）。为兼容旧配置，masked 仍被接受，但当前行为等同于 full。",
+          "markdownDescription": "请求体与响应体的记录策略：\n- `off`：不记录 body 内容（推荐日常使用）\n- `full`：完整记录所有内容（仅调试时使用）\n- `masked`：兼容旧配置，当前行为等同于 `full`"
         }
       }
     },

package/dist/cli.js

@@ -10440,7 +10440,7 @@ var DEFAULT_CONFIG = `{
   // \u65E5\u5FD7\u914D\u7F6E\uFF08\u53EF\u9009\uFF0C\u4E0D\u914D\u7F6E\u5219\u4E0D\u542F\u7528\u65E5\u5FD7\u8BB0\u5F55\uFF09
   // log: {
   //   enabled: true,
-  //   bodyPolicy: "off",       // off | masked | full
+  //   bodyPolicy: "off",       // off | full
   //   streams: {
   //     enabled: true,
   //     maxBytesPerRequest: 10485760,  // 10MB
@@ -51823,7 +51823,6 @@ var MAX_QUERY_LIMIT = 200;
 var DEFAULT_QUERY_LIMIT = 50;
 var MAX_EXPORT_ROWS = 5000;
 var MAX_Q_LENGTH = 200;
-var SENSITIVE_FIELD_PATTERN = /(authorization|token|cookie|password|passphrase|secret|api[_-]?key)/i;
 function encodeBase64Url(value) {
   return Buffer.from(value, "utf-8").toString("base64url");
 }
@@ -52039,34 +52038,6 @@ function eventToSummary(item) {
     sessionId: identity.sessionId
   };
 }
-function maskValue(value) {
-  if (value == null)
-    return value;
-  if (typeof value === "string") {
-    return value.length > 4 ? `${value.slice(0, 2)}****` : "****";
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return "****";
-  }
-  return "****";
-}
-function maskSensitiveDeep(value, parentKey = "") {
-  if (Array.isArray(value)) {
-    return value.map((item) => maskSensitiveDeep(item, parentKey));
-  }
-  if (value && typeof value === "object") {
-    const output = {};
-    for (const [key2, child] of Object.entries(value)) {
-      if (SENSITIVE_FIELD_PATTERN.test(key2) || SENSITIVE_FIELD_PATTERN.test(parentKey)) {
-        output[key2] = maskValue(child);
-      } else {
-        output[key2] = maskSensitiveDeep(child, key2);
-      }
-    }
-    return output;
-  }
-  return value;
-}
 function detectBodyPolicy(event) {
   const hasRequestBody = event.request_body !== undefined;
   const hasResponseBody = event.response_body !== undefined;
@@ -52139,53 +52110,53 @@ function readStreamContent(baseDir, streamFile) {
   }
 }
 async function buildLogEventDetail(id, parsed, location, context2) {
-  const maskedEvent = maskSensitiveDeep(parsed);
-  const level = getLevel(maskedEvent);
-  const statusClass = getStatusClass2(maskedEvent);
-  const bodyPolicy = detectBodyPolicy(maskedEvent);
-  const requestBodyAvailable = maskedEvent.request_body !== undefined;
-  const responseBodyAvailable = maskedEvent.response_body !== undefined;
-  const streamCaptured = Boolean(maskedEvent.stream_file);
-  const { content: streamContent, warning: streamWarning } = readStreamContent(resolveLogBaseDir(context2.logConfig), maskedEvent.stream_file);
+  const event = parsed;
+  const level = getLevel(event);
+  const statusClass = getStatusClass2(event);
+  const bodyPolicy = detectBodyPolicy(event);
+  const requestBodyAvailable = event.request_body !== undefined;
+  const responseBodyAvailable = event.response_body !== undefined;
+  const streamCaptured = Boolean(event.stream_file);
+  const { content: streamContent, warning: streamWarning } = readStreamContent(resolveLogBaseDir(context2.logConfig), event.stream_file);
   return {
     id,
     summary: {
       id,
-      ts: maskedEvent.ts_start,
+      ts: event.ts_start,
       level,
-      provider: maskedEvent.provider,
-      routeType: maskedEvent.route_type,
-      routeRuleKey: maskedEvent.route_rule_key,
-      requestId: maskedEvent.request_id,
-      latencyMs: Math.max(0, maskedEvent.latency_ms ?? 0),
-      upstreamStatus: maskedEvent.upstream_status ?? 0,
+      provider: event.provider,
+      routeType: event.route_type,
+      routeRuleKey: event.route_rule_key,
+      requestId: event.request_id,
+      latencyMs: Math.max(0, event.latency_ms ?? 0),
+      upstreamStatus: event.upstream_status ?? 0,
       statusClass,
       hasError: level === "error",
-      model: maskedEvent.model_out || maskedEvent.model_in,
-      modelIn: maskedEvent.model_in,
-      modelOut: maskedEvent.model_out
+      model: event.model_out || event.model_in,
+      modelIn: event.model_in,
+      modelOut: event.model_out
     },
     request: {
-      method: maskedEvent.method,
-      path: maskedEvent.path,
-      contentType: maskedEvent.content_type_req,
-      requestHeadersMasked: maskedEvent.request_headers_masked,
-      requestBody: maskedEvent.request_body ?? null
+      method: event.method,
+      path: event.path,
+      contentType: event.content_type_req,
+      requestHeaders: event.request_headers,
+      requestBody: event.request_body ?? null
     },
     response: {
-      upstreamStatus: maskedEvent.upstream_status ?? 0,
-      contentType: maskedEvent.content_type_res,
-      responseHeaders: maskedEvent.response_headers,
-      responseBody: maskedEvent.response_body ?? null
+      upstreamStatus: event.upstream_status ?? 0,
+      contentType: event.content_type_res,
+      responseHeaders: event.response_headers,
+      responseBody: event.response_body ?? null
     },
     upstream: {
-      targetUrl: maskedEvent.target_url,
-      proxyUrl: maskedEvent.proxy_url ?? null,
-      providerRequestId: maskedEvent.provider_request_id,
-      errorType: maskedEvent.error_type,
-      errorMessage: maskedEvent.error_message,
-      isStream: maskedEvent.is_stream,
-      streamFile: maskedEvent.stream_file ?? null,
+      targetUrl: event.target_url,
+      proxyUrl: event.proxy_url ?? null,
+      providerRequestId: event.provider_request_id,
+      errorType: event.error_type,
+      errorMessage: event.error_message,
+      isStream: event.is_stream,
+      streamFile: event.stream_file ?? null,
       streamContent
     },
     capture: {
@@ -52194,11 +52165,11 @@ async function buildLogEventDetail(id, parsed, location, context2) {
       responseBodyAvailable,
       streamCaptured,
       truncatedHints: [
-        ...buildTruncatedHints(maskedEvent, context2.logConfig?.bodyPolicy ?? bodyPolicy),
+        ...buildTruncatedHints(event, context2.logConfig?.bodyPolicy ?? bodyPolicy),
         ...streamWarning ? [streamWarning] : []
       ]
     },
-    rawEvent: maskedEvent,
+    rawEvent: event,
     location
   };
 }
@@ -52910,13 +52881,6 @@ function startLogStorageBackgroundTask(logConfig) {
 // src/logger.ts
 import { appendFileSync, existsSync as existsSync6, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
 import { join as join7 } from "path";
-var SENSITIVE_HEADERS = new Set([
-  "authorization",
-  "x-api-key",
-  "cookie",
-  "set-cookie",
-  "proxy-authorization"
-]);
 
 class Logger {
   baseDir;
@@ -52997,14 +52961,10 @@ function getLogger() {
 function resetLogger() {
   instance = null;
 }
-function maskHeaders(headers) {
+function collectHeaders(headers) {
   const result = {};
   headers.forEach((value, key2) => {
-    if (SENSITIVE_HEADERS.has(key2.toLowerCase())) {
-      result[key2] = value.length > 4 ? `${value.slice(0, 4)}****` : "****";
-    } else {
-      result[key2] = value;
-    }
+    result[key2] = value;
   });
   return result;
 }
@@ -53016,19 +52976,8 @@ function extractProviderRequestId(headers) {
   }
   return null;
 }
-function maskUrlCredentials(rawUrl) {
-  try {
-    const parsed = new URL(rawUrl);
-    if (!parsed.username && !parsed.password)
-      return rawUrl;
-    if (parsed.username)
-      parsed.username = "****";
-    if (parsed.password)
-      parsed.password = "****";
-    return parsed.toString();
-  } catch {
-    return rawUrl;
-  }
+function normalizeUrl(rawUrl) {
+  return rawUrl;
 }
 
 // src/openapi.ts
@@ -53475,7 +53424,7 @@ var openAPISpec = {
                         method: { type: "string" },
                         path: { type: "string" },
                         contentType: { type: ["string", "null"] },
-                        requestHeadersMasked: {
+                        requestHeaders: {
                           type: "object",
                           additionalProperties: { type: "string" }
                         },
@@ -54195,14 +54144,14 @@ function buildLogEvent(logMeta, targetUrl, proxyUrl, tsEnd, overrides) {
     provider: logMeta.provider,
     model_in: logMeta.modelIn,
     model_out: logMeta.modelOut,
-    target_url: maskUrlCredentials(targetUrl),
-    proxy_url: proxyUrl ? maskUrlCredentials(proxyUrl) : null,
+    target_url: normalizeUrl(targetUrl),
+    proxy_url: proxyUrl ? normalizeUrl(proxyUrl) : null,
     is_stream: logMeta.isStream,
     upstream_status: 0,
     content_type_req: logMeta.contentTypeReq,
     content_type_res: null,
     user_agent: logMeta.userAgent,
-    request_headers_masked: logMeta.requestHeadersMasked,
+    request_headers: logMeta.requestHeaders,
     response_headers: {},
     request_bytes: logMeta.requestBytes,
     response_bytes: null,
@@ -54382,7 +54331,7 @@ function createModelRoutingHandler(options) {
       contentTypeReq: c2.req.header("content-type") ?? null,
       userAgent: c2.req.header("user-agent") ?? null,
       requestBytes: Buffer.byteLength(body, "utf-8"),
-      requestHeadersMasked: maskHeaders(c2.req.raw.headers)
+      requestHeaders: collectHeaders(c2.req.raw.headers)
     };
     return proxyRequest(c2, {
       targetUrl,
@@ -55203,12 +55152,29 @@ function createAppRuntimeFromConfigPath(configPath) {
 }
 
 // src/server.ts
+var DEFAULT_IDLE_TIMEOUT_SECONDS = 600;
+function resolveIdleTimeoutSeconds(explicit) {
+  if (typeof explicit === "number" && Number.isFinite(explicit) && explicit >= 0) {
+    return explicit;
+  }
+  const fromEnv = process.env.LOCAL_ROUTER_IDLE_TIMEOUT;
+  if (!fromEnv) {
+    return DEFAULT_IDLE_TIMEOUT_SECONDS;
+  }
+  const parsed = Number.parseInt(fromEnv, 10);
+  if (Number.isFinite(parsed) && parsed >= 0) {
+    return parsed;
+  }
+  return DEFAULT_IDLE_TIMEOUT_SECONDS;
+}
 function startServer(options) {
   const runtime = createAppRuntimeFromConfigPath(options.configPath);
+  const idleTimeout = resolveIdleTimeoutSeconds(options.idleTimeoutSeconds);
   const server = Bun.serve({
     fetch: runtime.app.fetch,
     hostname: options.host,
-    port: options.port
+    port: options.port,
+    idleTimeout
   });
   const host = server.hostname;
   const port = server.port;
@@ -55284,7 +55250,8 @@ function parseSharedFlags(args) {
     options: {
       config: { type: "string" },
       host: { type: "string" },
-      port: { type: "string" }
+      port: { type: "string" },
+      "idle-timeout": { type: "string" }
     },
     allowPositionals: true,
     strict: false
@@ -55294,10 +55261,16 @@ function parseSharedFlags(args) {
   if (portRaw && !Number.isFinite(port)) {
     throw new Error(`\u65E0\u6548\u7AEF\u53E3: ${portRaw}`);
   }
+  const idleTimeoutRaw = parsed.values["idle-timeout"];
+  const idleTimeoutSeconds = idleTimeoutRaw ? Number.parseInt(idleTimeoutRaw, 10) : undefined;
+  if (idleTimeoutRaw && (!Number.isFinite(idleTimeoutSeconds) || idleTimeoutSeconds < 0)) {
+    throw new Error(`\u65E0\u6548 idle-timeout: ${idleTimeoutRaw}`);
+  }
   return {
     config: parsed.values.config,
     host: parsed.values.host,
-    port
+    port,
+    idleTimeoutSeconds
   };
 }
 async function checkHealth(baseUrl, timeoutMs = 1500) {
@@ -55343,12 +55316,14 @@ async function runServerProcess(opts) {
   if (!Number.isFinite(port)) {
     throw new Error(`\u65E0\u6548\u7AEF\u53E3: ${opts.port ?? process.env.PORT}`);
   }
+  const idleTimeoutSeconds = opts.idleTimeoutSeconds ?? Number.parseInt(process.env.LOCAL_ROUTER_IDLE_TIMEOUT ?? "", 10);
   let running;
   try {
     running = startServer({
       configPath: ensured.path,
       host,
-      port
+      port,
+      idleTimeoutSeconds: Number.isFinite(idleTimeoutSeconds) ? idleTimeoutSeconds : undefined
     });
   } catch (err) {
     const code = err?.code;
@@ -55422,6 +55397,9 @@ async function startDaemon(flags) {
   if (typeof flags.port === "number") {
     childArgs.push("--port", String(flags.port));
   }
+  if (typeof flags.idleTimeoutSeconds === "number") {
+    childArgs.push("--idle-timeout", String(flags.idleTimeoutSeconds));
+  }
   childArgs.push("--log-file", files.daemonLog);
   const child = Bun.spawn([process.execPath, ...childArgs], {
     stdin: "ignore",
@@ -55947,18 +55925,19 @@ Usage:
   local-router <command> [options]
 
 Commands:
-  start [--daemon] [--config <path>] [--host <host>] [--port <port>]
+  start [--daemon] [--config <path>] [--host <host>] [--port <port>] [--idle-timeout <sec>]
   stop
-  restart [--daemon] [--config <path>] [--host <host>] [--port <port>]
+  restart [--daemon] [--config <path>] [--host <host>] [--port <port>] [--idle-timeout <sec>]
   status [--json]
   logs [--follow] [--lines <n>]
   init [--config <path>] [--force]
   config <subcommand> [...args]
+  get-route --type <route-type> [--model-alias <alias>] [--config <path>]
   health
   version
 
 Hidden commands:
-  __run-server --mode <daemon|foreground> [--config] [--host] [--port] [--log-file]
+  __run-server --mode <daemon|foreground> [--config] [--host] [--port] [--idle-timeout] [--log-file]
 `);
 }
 async function printVersion() {
@@ -55988,7 +55967,8 @@ async function cmdStart(args) {
     mode: "foreground",
     config: flags.config,
     host: flags.host,
-    port: flags.port
+    port: flags.port,
+    idleTimeoutSeconds: flags.idleTimeoutSeconds
   });
 }
 async function cmdStop() {
@@ -56119,6 +56099,52 @@ async function cmdInit(args) {
   const result = ensureConfigFile(configPath);
   console.log(result.created ? `\u5DF2\u521D\u59CB\u5316\u914D\u7F6E: ${result.path}` : `\u914D\u7F6E\u5DF2\u5B58\u5728: ${result.path}`);
 }
+function formatRouteTarget(target) {
+  return `${target.provider} / ${target.model}`;
+}
+async function cmdGetRoute(args) {
+  const parsed = parseArgs3({
+    args,
+    options: {
+      type: { type: "string" },
+      "model-alias": { type: "string" },
+      model: { type: "string" },
+      config: { type: "string" }
+    },
+    allowPositionals: true,
+    strict: false
+  });
+  const routeType = parsed.values.type;
+  if (!routeType) {
+    throw new Error("\u7528\u6CD5: local-router get-route --type <route-type> [--model-alias <alias>] [--config <path>]");
+  }
+  const configPath = resolveConfigPath(parsed.values.config);
+  const config2 = loadConfig(configPath);
+  const modelMap = config2.routes[routeType];
+  if (!modelMap) {
+    throw new Error(`route type \u4E0D\u5B58\u5728: ${routeType}`);
+  }
+  const modelAlias = parsed.values["model-alias"] ?? parsed.values.model;
+  if (modelAlias) {
+    const target = modelMap[modelAlias] ?? modelMap["*"];
+    if (!target) {
+      throw new Error(`\u672A\u547D\u4E2D\u8DEF\u7531\u4E14\u7F3A\u5C11\u515C\u5E95: ${routeType}`);
+    }
+    console.log(formatRouteTarget(target));
+    return;
+  }
+  const chunks = [];
+  for (const [alias, target] of Object.entries(modelMap)) {
+    if (alias === "*")
+      continue;
+    chunks.push(`${alias} : ${formatRouteTarget(target)}`);
+  }
+  const fallback = modelMap["*"];
+  if (fallback) {
+    chunks.push(`default : ${formatRouteTarget(fallback)}`);
+  }
+  console.log(chunks.join(" | "));
+}
 async function cmdHealth() {
   await cleanupIfStale();
   const state = readRuntimeState();
@@ -56141,6 +56167,7 @@ async function cmdRunServer(args) {
       config: { type: "string" },
       host: { type: "string" },
       port: { type: "string" },
+      "idle-timeout": { type: "string" },
       "log-file": { type: "string" }
     },
     allowPositionals: true,
@@ -56149,11 +56176,14 @@ async function cmdRunServer(args) {
   const mode = parsed.values.mode === "daemon" ? "daemon" : "foreground";
   const portRaw = parsed.values.port;
   const port = portRaw ? Number.parseInt(portRaw, 10) : undefined;
+  const idleTimeoutRaw = parsed.values["idle-timeout"];
+  const idleTimeoutSeconds = idleTimeoutRaw ? Number.parseInt(idleTimeoutRaw, 10) : undefined;
   await runServerProcess({
     mode,
     config: parsed.values.config,
     host: parsed.values.host,
     port,
+    idleTimeoutSeconds: Number.isFinite(idleTimeoutSeconds) ? idleTimeoutSeconds : undefined,
     logFile: parsed.values["log-file"]
   });
 }
@@ -56184,6 +56214,9 @@ async function main() {
     case "config":
       await cmdConfig(rest);
       return;
+    case "get-route":
+      await cmdGetRoute(rest);
+      return;
     case "version":
       await printVersion();
       return;