cabletidy 0.1.0 → 0.2.0

package/src/server.mjs

@@ -6,11 +6,14 @@ import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { StringDecoder } from "node:string_decoder";
 import { randomBytes } from "node:crypto";
+import { acquireInstanceLock } from "./instance-lock.mjs";
 
 import {
   applySecretPayload,
   backupFile,
   computeConfigDiff,
+  defaultConfig,
+  ensureStore,
   getPaths,
   loadConfig,
   loadSecrets,
@@ -26,8 +29,6 @@ import {
 } from "./config.mjs";
 import {
   applyCodexArtifacts,
-  prepareCodexArtifacts,
-  publicArtifacts,
   CODEX_NATIVE_PROVIDER_INTEGRATION,
   CODEX_NATIVE_REQUIRED_ENDPOINTS,
   CODEX_TARGET_FORMAT,
@@ -35,7 +36,10 @@ import {
 import {
   publicTargetArtifacts,
   prepareTargetArtifacts,
+  CLAUDE_ENDPOINTS,
+  CLAUDE_TARGET_FORMAT,
 } from "./target-artifacts.mjs";
+import { applyClaudeSettings, restoreClaudeSettings } from "./claude-config-file.mjs";
 import {
   listClientModels,
   resolveModelProfile,
@@ -64,8 +68,28 @@ const CODEX_NATIVE_RESPONSES_PATH = CODEX_NATIVE_REQUIRED_ENDPOINTS.find(
 export async function createApplication(options = {}) {
   const paths = options.paths || getPaths();
   await fs.mkdir(paths.home, { recursive: true, mode: 0o700 });
+  const { release, identity } = await acquireInstanceLock(paths);
+  try {
+    const app = await createLockedApplication(options, paths, identity);
+    let closing;
+    return {
+      ...app,
+      close() {
+        return closing ||= app.close().finally(release);
+      },
+    };
+  } catch (error) {
+    await release();
+    throw error;
+  }
+}
+
+async function createLockedApplication(options, paths, identity) {
+  await ensureStore(paths);
   let config = await loadConfig(paths);
-  let secrets = await loadSecrets(paths);
+  const allocatePort = config === null;
+  config ||= defaultConfig();
+  const secrets = await loadSecrets(paths);
   const startupValidation = validateConfig(config);
   if (!startupValidation.ok) {
     const details = startupValidation.errors
@@ -76,6 +100,7 @@ export async function createApplication(options = {}) {
 
   const state = {
     paths,
+    identity,
     config,
     secrets,
     events: [],
@@ -85,12 +110,13 @@ export async function createApplication(options = {}) {
     configOperation: Promise.resolve(),
     loadCodexCatalog: options.loadCodexCatalog || loadCodexCatalog,
     codexHome: options.codexHome,
+    claudeHome: options.claudeHome,
   };
 
   let webServer = null;
   const requests = new Set();
   const host = config.web.listenHost || "127.0.0.1";
-  const port = Number(config.web.port || 43100);
+  let port = Number(config.web.port);
   try {
     webServer = http.createServer((request, response) => {
       const task = handleWebRequest(state, request, response).catch((error) => {
@@ -103,9 +129,24 @@ export async function createApplication(options = {}) {
       requests.add(task);
     });
     state.webServer = webServer;
-    await listen(webServer, host, port);
+    try {
+      await listen(webServer, host, port);
+    } catch (error) {
+      if (error.code !== "EADDRINUSE") throw error;
+      if (!allocatePort) {
+        throw Object.assign(new Error(
+          `端口 ${host}:${port} 已被占用 (EADDRINUSE)。请停止占用端口的服务，或修改 ${paths.config} 中的 web.port 后重启，并重新应用客户端配置。`,
+          { cause: error },
+        ), { code: error.code });
+      }
+      // Keep the OS-assigned listener open so nobody can claim the chosen port.
+      await listen(webServer, host, 0);
+    }
+    port = webServer.address().port;
+    config.web.port = port;
 
     await saveSecrets(secrets, paths);
+    if (allocatePort) await saveConfig(config, paths);
     await persistRuntimeInfo(state, host, port);
   } catch (error) {
     if (webServer) await closeServer(webServer).catch(() => {});
@@ -113,10 +154,8 @@ export async function createApplication(options = {}) {
   }
 
   function updateConfig(nextConfig, nextSecrets) {
-    config = nextConfig;
-    secrets = nextSecrets;
-    state.config = config;
-    state.secrets = secrets;
+    state.config = nextConfig;
+    state.secrets = nextSecrets;
   }
 
   state.updateConfig = updateConfig;
@@ -236,8 +275,9 @@ async function handleApiRequest(state, request, response, url) {
       integrations: [CODEX_NATIVE_PROVIDER_INTEGRATION],
       requiredEndpoints: {
         [CODEX_NATIVE_PROVIDER_INTEGRATION]: CODEX_NATIVE_REQUIRED_ENDPOINTS,
+        "claude-code": CLAUDE_ENDPOINTS,
       },
-      targetFormats: [CODEX_TARGET_FORMAT, "claude.env.v1", "generic.env.v1"],
+      targetFormats: [CODEX_TARGET_FORMAT, CLAUDE_TARGET_FORMAT, "claude.env.v1", "generic.env.v1"],
       targets: ["codex", "claude-code", "generic-env"],
       capabilities: [
         "streaming",
@@ -339,7 +379,7 @@ async function handleApiRequest(state, request, response, url) {
         upstreamModelId: result.upstreamModelId,
         routeId: result.routeId,
         capabilities: result.capabilities,
-        rejectedBackends: result.rejected,
+        rejectedBackends: [],
       });
     } catch (error) {
       sendJson(response, 422, {
@@ -359,29 +399,26 @@ async function handleApiRequest(state, request, response, url) {
     return;
   }
 
-  if (
-    (url.pathname === "/api/v1/config/preview-target-artifacts" ||
-      url.pathname === "/api/v1/config/preview-codex-config") &&
-    method === "POST"
-  ) {
+  if (method === "POST" && url.pathname === "/api/v1/config/preview-target-artifacts") {
     await previewTargetArtifacts(state, body, response);
     return;
   }
 
-  // Compatibility alias for clients built against the first prototype. It
-  // previews target artifacts and does not inspect or import reference files.
-  if (url.pathname === "/api/v1/config/preview-provider-artifacts" && method === "POST") {
-    await previewTargetArtifacts(state, body, response);
-    return;
-  }
-
-  if (url.pathname === "/api/v1/targets/codex/apply" && method === "POST") {
-    await applyCodexTarget(state, body, response);
+  if (method === "POST" && url.pathname === "/api/v1/targets/apply") {
+    await applyTarget(state, body, response);
     return;
   }
 
-  if (url.pathname === "/api/v1/targets/apply" && method === "POST") {
-    await applyTarget(state, body, response);
+  if (method === "POST" && url.pathname === "/api/v1/targets/restore") {
+    try {
+      const binding = state.config.bindings[body.bindingId];
+      if (binding?.target !== "claude-code") throw new Error("请选择 Claude Code 配置");
+      const report = await restoreClaudeSettings(body.bindingId, { paths: state.paths, claudeHome: state.claudeHome });
+      recordEvent(state, "target.restore", { bindingId: body.bindingId, target: "claude-code" });
+      sendJson(response, 200, { ok: true, target: "claude-code", report });
+    } catch (error) {
+      sendJson(response, 422, { error: { code: "target_restore_failed", message: error.message } });
+    }
     return;
   }
 
@@ -592,6 +629,7 @@ async function previewTargetArtifacts(state, body, response) {
       bindingId: body.bindingId,
       loadCatalog: state.loadCodexCatalog,
       codexHome: state.codexHome,
+      claudeHome: state.claudeHome,
     }, secrets);
     sendJson(response, 200, {
       ok: true,
@@ -604,35 +642,15 @@ async function previewTargetArtifacts(state, body, response) {
   }
 }
 
-async function applyCodexTarget(state, body, response) {
-  try {
-    const artifacts = await prepareCodexArtifacts(state.config, {
-      bindingId: body.bindingId,
-      loadCatalog: state.loadCodexCatalog,
-      codexHome: state.codexHome,
-    }, state.secrets);
-    const report = await applyCodexArtifacts(artifacts, { paths: state.paths, codexHome: state.codexHome });
-    recordEvent(state, "target.codex.apply", { bindingId: body.bindingId || null, files: report.applied });
-    sendJson(response, 200, {
-      ok: true,
-      report: {
-        ...report,
-        environment: publicArtifacts({ ...artifacts, ...report }).environment,
-      },
-    });
-  } catch (error) {
-    sendJson(response, 422, { error: { code: "codex_apply_failed", message: error.message } });
-  }
-}
-
 async function applyTarget(state, body, response) {
   try {
     const artifacts = await prepareTargetArtifacts(state.config, {
       bindingId: body.bindingId,
       loadCatalog: state.loadCodexCatalog,
       codexHome: state.codexHome,
+      claudeHome: state.claudeHome,
     }, state.secrets);
-    if (artifacts.target !== "codex") {
+    if (!["codex", "claude-code"].includes(artifacts.target)) {
       sendJson(response, 501, {
         error: {
           code: "target_apply_not_supported",
@@ -644,8 +662,9 @@ async function applyTarget(state, body, response) {
       });
       return;
     }
-    let report = { applied: [], mode: artifacts.mode };
-    report = await applyCodexArtifacts(artifacts, { paths: state.paths, codexHome: state.codexHome });
+    const report = artifacts.target === "claude-code"
+      ? await applyClaudeSettings(artifacts, { paths: state.paths, claudeHome: state.claudeHome })
+      : await applyCodexArtifacts(artifacts, { paths: state.paths, codexHome: state.codexHome });
     recordEvent(state, "target.apply", {
       bindingId: artifacts.bindingId,
       target: artifacts.target,
@@ -674,6 +693,7 @@ async function handleProxyRequest(state, config, secrets, virtualProviderId, pro
   }
 
   const protocol = provider.ingressProtocol;
+  const isClaude = protocol === "anthropic.messages";
 
   if (!IMPLEMENTED_INGRESS_PROTOCOLS.has(protocol)) {
     sendProtocolError(
@@ -686,6 +706,34 @@ async function handleProxyRequest(state, config, secrets, virtualProviderId, pro
     return;
   }
 
+  if (isClaude && request.method === "HEAD" && url.pathname === "/api/hello") {
+    response.writeHead(204, { "cache-control": "no-store" });
+    response.end();
+    return;
+  }
+  if (isClaude && request.method === "GET" && url.pathname === "/v1/models") {
+    const limit = url.searchParams.get("limit") ?? "1000";
+    if (!/^\d+$/.test(limit) || Number(limit) < 1 || Number(limit) > 1000) {
+      sendProtocolError(response, protocol, 400, "invalid_request_error", "limit 必须是 1 到 1000 之间的整数");
+      return;
+    }
+    let models = listClientModels(config, provider).map((model) => ({
+      id: model.id, type: "model", display_name: model.id,
+    }));
+    const after = url.searchParams.get("after_id");
+    if (after) {
+      const index = models.findIndex((model) => model.id === after);
+      if (index < 0) {
+        sendProtocolError(response, protocol, 400, "invalid_request_error", "after_id 不在当前模型列表中");
+        return;
+      }
+      models = models.slice(index + 1);
+    }
+    const data = models.slice(0, Number(limit));
+    sendJson(response, 200, { data, has_more: models.length > data.length,
+      first_id: data[0]?.id ?? null, last_id: data.at(-1)?.id ?? null });
+    return;
+  }
   if (
     protocol === "openai.responses" &&
     request.method === "GET" &&
@@ -695,8 +743,9 @@ async function handleProxyRequest(state, config, secrets, virtualProviderId, pro
     sendJson(response, 200, { object: "list", data: models });
     return;
   }
-  const supportedPaths = protocol === "anthropic.messages"
-    ? ["/v1/messages", "/messages"]
+  const countTokens = isClaude && url.pathname === "/v1/messages/count_tokens";
+  const supportedPaths = isClaude
+    ? ["/v1/messages", "/messages", "/v1/messages/count_tokens"]
     : [CODEX_NATIVE_RESPONSES_PATH, "/responses"];
   if (request.method !== "POST" || !supportedPaths.includes(url.pathname)) {
     sendProtocolError(
@@ -705,7 +754,7 @@ async function handleProxyRequest(state, config, secrets, virtualProviderId, pro
       404,
       "not_found",
       protocol === "anthropic.messages"
-        ? "只支持 POST /v1/messages"
+        ? "支持 POST /v1/messages、POST /v1/messages/count_tokens、GET /v1/models 和 HEAD /api/hello"
         : "只支持 POST /v1/responses 和 GET /v1/models",
     );
     return;
@@ -748,20 +797,14 @@ async function handleProxyRequest(state, config, secrets, virtualProviderId, pro
       config,
       provider,
       resolution,
-      body,
+      countTokens ? {} : body,
     );
   } catch (error) {
     sendProtocolError(response, protocol, 503, error.code || "upstream_unavailable", error.message);
     return;
   }
-  if (protocol !== selected.upstream.protocol) {
-    sendProtocolError(response, protocol, 501, "unsupported_transform", "MVP 暂不执行跨协议数据面转换");
-    return;
-  }
-
   const outgoing = structuredClone(body);
-  // Model metadata is a client-side artifact. Preserve the instructions,
-  // tools and per-request reasoning effort constructed by Codex.
+  // Only the protocol model field is mapped; prompts and tool payloads stay intact.
   outgoing.model = selected.upstreamModelId;
   const upstreamUrl = joinUpstreamUrl(selected.upstream.baseUrl, url.pathname, url.search);
   const upstreamHeaders = {
@@ -778,6 +821,7 @@ async function handleProxyRequest(state, config, secrets, virtualProviderId, pro
       headers: upstreamHeaders,
       body: JSON.stringify(outgoing),
       signal: upstreamAbort.signal,
+      ...(isClaude ? { redirect: "manual" } : {}),
     });
     recordHealth(
       state,
@@ -790,6 +834,7 @@ async function handleProxyRequest(state, config, secrets, virtualProviderId, pro
       upstreamId: selected.upstream.id,
       clientModelId: resolution.clientModelId,
       upstreamModelId: selected.upstreamModelId,
+      path: url.pathname,
       status: upstreamResponse.status,
       latencyMs: Date.now() - started,
     });
@@ -798,6 +843,8 @@ async function handleProxyRequest(state, config, secrets, virtualProviderId, pro
       upstreamResponse,
       resolution.clientModelId,
       selected.upstreamModelId,
+      protocol,
+      countTokens,
     );
     return;
   } catch (error) {
@@ -811,22 +858,30 @@ async function handleProxyRequest(state, config, secrets, virtualProviderId, pro
   }
 }
 
-async function relayResponse(response, upstreamResponse, clientModelId, upstreamModelId) {
+async function relayResponse(response, upstreamResponse, clientModelId, upstreamModelId, protocol, countTokens = false) {
   const contentType = upstreamResponse.headers.get("content-type") || "application/json";
   const isEventStream = contentType.includes("text/event-stream");
   const headers = {
     "content-type": contentType,
     "cache-control": upstreamResponse.headers.get("cache-control") || "no-cache",
   };
-  const requestId = upstreamResponse.headers.get("x-request-id");
-  if (requestId) headers["x-request-id"] = requestId;
+  for (const [name, value] of upstreamResponse.headers) {
+    if (["x-request-id", "request-id", "retry-after", "x-should-retry"].includes(name) || name.startsWith("anthropic-ratelimit-")) headers[name] = value;
+  }
   response.writeHead(upstreamResponse.status, headers);
+  response.flushHeaders();
 
   if (!upstreamResponse.body) {
     response.end();
     return;
   }
 
+  if (!upstreamResponse.ok || countTokens || clientModelId === upstreamModelId) {
+    await pipeline(Readable.fromWeb(upstreamResponse.body), response);
+    return;
+  }
+  const rewrite = protocol === "anthropic.messages" ? rewriteClaudeModel : rewriteModelFields;
+
   if (!isEventStream) {
     const text = await upstreamResponse.text();
     if (!text) {
@@ -834,7 +889,7 @@ async function relayResponse(response, upstreamResponse, clientModelId, upstream
       return;
     }
     try {
-      const body = rewriteModelFields(JSON.parse(text), clientModelId, upstreamModelId);
+      const body = rewrite(JSON.parse(text), clientModelId, upstreamModelId);
       response.end(JSON.stringify(body));
     } catch {
       response.end(text);
@@ -844,12 +899,20 @@ async function relayResponse(response, upstreamResponse, clientModelId, upstream
 
   await pipeline(
     Readable.fromWeb(upstreamResponse.body),
-    createSseRewriteTransform(clientModelId, upstreamModelId),
+    createSseRewriteTransform(clientModelId, upstreamModelId, rewrite),
     response,
   );
 }
 
-function createSseRewriteTransform(clientModelId, upstreamModelId) {
+function rewriteClaudeModel(value, clientModelId, upstreamModelId) {
+  if (value?.type === "message" && value.model === upstreamModelId) return { ...value, model: clientModelId };
+  if (value?.type === "message_start" && value.message?.model === upstreamModelId) {
+    return { ...value, message: { ...value.message, model: clientModelId } };
+  }
+  return value;
+}
+
+function createSseRewriteTransform(clientModelId, upstreamModelId, rewrite) {
   const decoder = new StringDecoder("utf8");
   let buffer = "";
 
@@ -859,7 +922,7 @@ function createSseRewriteTransform(clientModelId, upstreamModelId) {
         buffer += Buffer.isBuffer(chunk)
           ? decoder.write(chunk)
           : String(chunk, encoding);
-        const drained = drainSseBuffer(buffer, clientModelId, upstreamModelId);
+        const drained = drainSseBuffer(buffer, clientModelId, upstreamModelId, rewrite);
         buffer = drained.remaining;
         callback(null, drained.output || undefined);
       } catch (error) {
@@ -872,7 +935,7 @@ function createSseRewriteTransform(clientModelId, upstreamModelId) {
         callback(
           null,
           buffer
-            ? rewriteSseEvent(buffer, clientModelId, upstreamModelId)
+            ? rewriteSseEvent(buffer, clientModelId, upstreamModelId, rewrite)
             : undefined,
         );
       } catch (error) {
@@ -882,21 +945,21 @@ function createSseRewriteTransform(clientModelId, upstreamModelId) {
   });
 }
 
-function drainSseBuffer(buffer, clientModelId, upstreamModelId) {
+function drainSseBuffer(buffer, clientModelId, upstreamModelId, rewrite) {
   let remaining = buffer;
   let output = "";
   while (true) {
     const delimiter = remaining.match(/\r?\n\r?\n/);
     if (!delimiter || delimiter.index === undefined) break;
     const event = remaining.slice(0, delimiter.index);
-    output += rewriteSseEvent(event, clientModelId, upstreamModelId);
+    output += rewriteSseEvent(event, clientModelId, upstreamModelId, rewrite);
     output += delimiter[0];
     remaining = remaining.slice(delimiter.index + delimiter[0].length);
   }
   return { output, remaining };
 }
 
-function rewriteSseEvent(event, clientModelId, upstreamModelId) {
+function rewriteSseEvent(event, clientModelId, upstreamModelId, rewrite) {
   const separator = event.includes("\r\n") ? "\r\n" : "\n";
   const lines = event.split(/\r?\n/);
   const dataLines = [];
@@ -910,7 +973,8 @@ function rewriteSseEvent(event, clientModelId, upstreamModelId) {
   if (!payload || payload === "[DONE]") return event;
   try {
     const parsed = JSON.parse(payload);
-    const rewritten = rewriteModelFields(parsed, clientModelId, upstreamModelId);
+    const rewritten = rewrite(parsed, clientModelId, upstreamModelId);
+    if (rewritten === parsed) return event;
     const first = dataLines[0];
     const prefix = lines[first.index].match(/^data:/)?.[0] || "data:";
     lines[first.index] = `${prefix} ${JSON.stringify(rewritten)}`;
@@ -923,7 +987,7 @@ function rewriteSseEvent(event, clientModelId, upstreamModelId) {
 
 function copyProtocolHeaders(request, target, protocol) {
   const names = protocol === "anthropic.messages"
-    ? ["anthropic-version", "anthropic-beta"]
+    ? Object.keys(request.headers).filter((name) => name.startsWith("anthropic-") || name.startsWith("x-claude-code-"))
     : ["openai-beta", "openai-organization", "openai-project"];
   for (const name of names) {
     const value = request.headers[name];
@@ -1027,6 +1091,7 @@ async function persistRuntimeInfo(state, host, port) {
   await writeRuntimeInfo(
     {
       pid: process.pid,
+      pidStartTime: state.identity.startTime,
       startedAt: state.startedAt,
       web: {
         host,
@@ -1186,7 +1251,8 @@ function sendProtocolError(response, protocol, status, code, message) {
           ? "overloaded_error"
           : code === "not_found"
             ? "not_found_error"
-            : "invalid_request_error";
+            : status === 413 ? "request_too_large"
+              : status >= 500 ? "api_error" : "invalid_request_error";
     sendJson(response, status, {
       type: "error",
       error: {

package/src/target-artifacts.mjs

@@ -6,6 +6,16 @@ import {
 import { clientModelIdForProfile, resolveModelProfile } from "./model-resolver.mjs";
 import { normalizeConfig } from "./config.mjs";
 import { configurationId, providerIdForConfiguration, configurationBaseUrl } from "../web/config-identity.js";
+import { prepareClaudeSettings } from "./claude-config-file.mjs";
+import { CLAUDE_MODEL_ALIASES } from "../web/claude-models.js";
+
+export const CLAUDE_TARGET_FORMAT = "claude.settings.json.v1";
+export const CLAUDE_ENDPOINTS = [
+  { method: "POST", path: "/v1/messages", purpose: "messages", required: true },
+  { method: "POST", path: "/v1/messages/count_tokens", purpose: "token_counting", required: false },
+  { method: "GET", path: "/v1/models", purpose: "model_discovery", required: false },
+  { method: "HEAD", path: "/api/hello", purpose: "connection_probe", required: false },
+];
 
 export async function prepareTargetArtifacts(config, options = {}, secrets = {}) {
   const requested = findBinding(config, options.bindingId);
@@ -15,6 +25,9 @@ export async function prepareTargetArtifacts(config, options = {}, secrets = {})
   if (binding.target === "codex") {
     return prepareCodexArtifacts(config, { ...options, bindingId: binding.id }, secrets);
   }
+  if (binding.target === "claude-code") {
+    return prepareClaudeSettings(buildClaudeArtifacts(config, binding), options);
+  }
   return buildTargetArtifacts(config, { ...options, bindingId: binding.id }, secrets);
 }
 
@@ -80,23 +93,42 @@ function buildClaudeArtifacts(config, binding) {
     // Satisfy Claude Code's client-side credential check; the local service
     // ignores this public placeholder and authenticates only to the upstream.
     ANTHROPIC_AUTH_TOKEN: "cabletidy-local",
+    ANTHROPIC_API_KEY: "",
+    CLAUDE_CODE_OAUTH_TOKEN: "",
+    ANTHROPIC_CUSTOM_HEADERS: "",
+    CLAUDE_CODE_USE_BEDROCK: "0",
+    CLAUDE_CODE_USE_VERTEX: "0",
+    CLAUDE_CODE_USE_FOUNDRY: "0",
+    CLAUDE_CODE_USE_ANTHROPIC_AWS: "0",
+    CLAUDE_CODE_USE_MANTLE: "0",
+    CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: binding.claude?.discoverModels ? "1" : "0",
     ...(binding.claude?.setModel === false || !clientModel ? {} : { ANTHROPIC_MODEL: clientModel }),
   };
+  for (const family of ["opus", "sonnet", "fable", "haiku"]) {
+    const model = binding.claude?.models?.[family];
+    if (model) vars[`ANTHROPIC_DEFAULT_${family.toUpperCase()}_MODEL`] = model;
+  }
+  if (binding.claude?.models?.subagent) vars.CLAUDE_CODE_SUBAGENT_MODEL = binding.claude.models.subagent;
+  const contents = `${JSON.stringify({ env: vars }, null, 2)}\n`;
 
   return {
-    format: "claude.env.v1",
+    format: CLAUDE_TARGET_FORMAT,
     target: "claude-code",
     mode: "managed_proxy",
     bindingId: binding.id,
     virtualProviderId: virtualProvider.id,
     clientModelId: clientModel,
-    files: [],
+    files: [{ path: "cabletidy-claude.settings.json", kind: "json", contents }],
+    requiredEndpoints: CLAUDE_ENDPOINTS,
     environment: {
       vars,
       shell: shellExports(vars),
+      powershell: Object.entries(vars).map(([key, value]) => `$env:${key} = '${String(value).replaceAll("'", "''")}'`).join("\n"),
     },
     instructions: [
-      "将以下环境变量注入 Claude Code 进程即可，不需要修改上游 provider 配置。",
+      "应用时只合并到用户 settings.json 的 env，保留其他设置；原值保存以便撤销接入。",
+      "预览文件也可另存为独立文件，通过 claude --settings cabletidy-claude.settings.json 临时接入。",
+      "本地入口无需 Key；cabletidy-local 仅满足客户端认证检查，真实凭据只由 CableTidy 发给上游。",
       `ANTHROPIC_BASE_URL 指向本地 Virtual Provider: ${baseUrl}`,
       clientModel ? `Claude 客户端模型名: ${clientModel}` : "模型由 Claude Code 选择，默认透传请求中的模型名。",
     ],
@@ -149,6 +181,10 @@ function getVirtualProvider(config, binding) {
 function defaultProfile(config, binding, virtualProvider) {
   const requested = binding.defaultModel || virtualProvider.defaultModel;
   if (!requested) return { profileId: null, profile: null, clientModelId: null };
+  // A Claude alias takes precedence over a same-named internal profile reference.
+  if (binding.target === "claude-code" && CLAUDE_MODEL_ALIASES.defaultModel.includes(requested)) {
+    return { profileId: null, profile: null, clientModelId: requested };
+  }
   const resolved = resolveModelProfile(config, virtualProvider, requested);
   return {
     profileId: resolved.profileId,
@@ -173,5 +209,6 @@ function publicEnvironment(environment = {}) {
   return {
     vars: environment.vars || {},
     shell: environment.shell || "",
+    ...(environment.powershell ? { powershell: environment.powershell } : {}),
   };
 }

package/src/validation.mjs

@@ -11,9 +11,8 @@ const PROTOCOLS = new Set([
   "gemini.generate_content",
 ]);
 const INTEGRATIONS = new Set(["codex-native-provider"]);
-const TARGET_FORMATS = new Set(["codex.config.toml.v1", "claude.env.v1", "generic.env.v1"]);
+const TARGET_FORMATS = new Set(["codex.config.toml.v1", "claude.env.v1", "claude.settings.json.v1", "generic.env.v1"]);
 const TARGETS = new Set(["codex", "claude-code", "generic-env"]);
-const ROUTE_STRATEGIES = new Set(["priority"]);
 const COMPACT_STRATEGIES = new Set(["auto", "manual", "disabled"]);
 const IMPLEMENTED_INGRESS_PROTOCOLS = new Set([
   "openai.responses",
@@ -83,6 +82,10 @@ export function validateConfig(input) {
     if (authHeader && !HEADER_PATTERN.test(authHeader)) {
       add(errors, `upstreams.${id}.auth.header`, "认证 header 名称不合法");
     }
+    if (upstream.auth?.scheme !== undefined &&
+        (typeof upstream.auth.scheme !== "string" || !HEADER_PATTERN.test(upstream.auth.scheme))) {
+      add(errors, `upstreams.${id}.auth.scheme`, "认证 scheme 必须是合法的 HTTP token");
+    }
   }
 
   for (const [id, rawModel] of Object.entries(config.models)) {
@@ -137,13 +140,6 @@ export function validateConfig(input) {
     ) {
       add(errors, `models.${id}.compact.strategy`, "不支持的 compact strategy");
     }
-    if (
-      model.capabilityOverrides !== undefined &&
-      (!Array.isArray(model.capabilityOverrides) ||
-        model.capabilityOverrides.some((item) => typeof item !== "string" || !item.trim()))
-    ) {
-      add(errors, `models.${id}.capabilityOverrides`, "capabilityOverrides 必须是非空字符串数组");
-    }
     const aliases = new Set([
       id,
       ...(model.clientModelId ? [model.clientModelId] : []),
@@ -193,9 +189,6 @@ export function validateConfig(input) {
     const route = isRecord(rawRoute) ? rawRoute : {};
     if (!isRecord(rawRoute)) add(errors, `routes.${id}`, "route 必须是 object");
     if (!hasId(id)) add(errors, `routes.${id}`, "route ID 包含非法字符");
-    if (route.strategy && !ROUTE_STRATEGIES.has(route.strategy)) {
-      add(errors, `routes.${id}.strategy`, `不支持的 route strategy: ${route.strategy}`);
-    }
     if (!Array.isArray(route.backends) || route.backends.length === 0) {
       add(errors, `routes.${id}.backends`, "每份配置必须且只能连接一个 upstream（一个 backend）");
       continue;
@@ -225,12 +218,6 @@ export function validateConfig(input) {
           );
         }
       }
-      if (backend.priority !== undefined && !isInteger(backend.priority)) {
-        add(errors, `${base}.priority`, "priority 必须是非负整数");
-      }
-      if (backend.weight !== undefined && !isNumber(backend.weight)) {
-        add(errors, `${base}.weight`, "weight 必须是非负数字");
-      }
     }
   }
 
@@ -350,8 +337,27 @@ export function validateConfig(input) {
     ) {
       add(errors, `bindings.${id}.targetFormat`, "Codex binding 必须使用本地 config.toml 接入");
     }
-    if (binding.target === "claude-code" && binding.targetFormat && binding.targetFormat !== "claude.env.v1") {
-      add(errors, `bindings.${id}.targetFormat`, "Claude Code binding 必须使用 claude.env.v1");
+    if (binding.target === "claude-code" && binding.targetFormat &&
+        !["claude.env.v1", "claude.settings.json.v1"].includes(binding.targetFormat)) {
+      add(errors, `bindings.${id}.targetFormat`, "Claude Code binding 必须使用 Claude settings 或 env 接入");
+    }
+    if (binding.target === "claude-code" && binding.claude !== undefined) {
+      if (!isRecord(binding.claude)) add(errors, `bindings.${id}.claude`, "Claude 设置必须是 object");
+      else {
+        for (const key of ["setModel", "discoverModels"]) {
+          if (binding.claude[key] !== undefined && typeof binding.claude[key] !== "boolean") {
+            add(errors, `bindings.${id}.claude.${key}`, "必须是 boolean");
+          }
+        }
+        if (binding.claude.models !== undefined) {
+          if (!isRecord(binding.claude.models)) add(errors, `bindings.${id}.claude.models`, "模型选择必须是 object");
+          else for (const [key, value] of Object.entries(binding.claude.models)) {
+            if (!["opus", "sonnet", "fable", "haiku", "subagent"].includes(key) || typeof value !== "string" || !value.trim()) {
+              add(errors, `bindings.${id}.claude.models.${key}`, "仅支持 opus、sonnet、fable、haiku、subagent 的非空模型 ID");
+            }
+          }
+        }
+      }
     }
     if (
       binding.target === "generic-env" &&