u1s1-cli 1.14.5 → 1.15.0

package/dist/agent-setup.d.ts

@@ -106,6 +106,13 @@ export declare function writeAttributionExtension(site?: Site): void;
  * 所以启动时要把残留文件删掉(Desktop App 共用同一个 agentDir,同样受益)。
  */
 export declare function removeLegacyCompactUiExtension(outputDir?: string): void;
+/**
+ * 「界面文案」(斜杠命令补全描述、思考中提示)上一版投影成 <agentDir>/extensions/u1s1-ui-text.js,
+ * 用户带 --no-extensions 或在设置里禁用它时就失效;现在改由 pi.ts 的进程内扩展调用
+ * pi-ui-text.ts 的 registerUiText。启动时删掉残留文件,免得和进程内扩展各包一层
+ * (两层同时生效结果也正确,只是多余);Desktop App 共用 agentDir,它那里本来就是空转。
+ */
+export declare function removeLegacyUiTextExtension(outputDir?: string): void;
 /**
  * pi-web-ui 的就绪检测只认 <agentDir>/auth.json 里有没有凭据条目(models.json
  * 的 apiKey 它不看),空 {} 会在网页里弹「未检测到 pi agent 配置」引导装 pi。

package/dist/agent-setup.js

@@ -4,6 +4,7 @@ import { dirname, join } from "node:path";
 import { activeSite, agentDir, CUSTOM_ENDPOINTS, ENDPOINT_ID_RE, effectiveContextWindow, endpointKeyEnvName, MODELS, readCompactionBudgetSetting, PROVIDER_ID, UNKNOWN_MODEL_COST, VERSION, } from "./config.js";
 import { tr } from "./i18n.js";
 import { migrateLegacyMcpConfig } from "./mcp/config.js";
+import { LEGACY_UI_TEXT_EXTENSION_FILE } from "./pi-ui-text.js";
 /**
  * 系统提示里的品牌人设。中国站面向编程新手、兜底语言中文(保持原文一字不差);
  * 国际站面向开发者、兜底语言英文。按站点而不是界面语言判定,用时求值(配置可能晚于 import 才读)。
@@ -518,6 +519,19 @@ export function removeLegacyCompactUiExtension(outputDir) {
     }
     catch { }
 }
+/**
+ * 「界面文案」(斜杠命令补全描述、思考中提示)上一版投影成 <agentDir>/extensions/u1s1-ui-text.js,
+ * 用户带 --no-extensions 或在设置里禁用它时就失效;现在改由 pi.ts 的进程内扩展调用
+ * pi-ui-text.ts 的 registerUiText。启动时删掉残留文件,免得和进程内扩展各包一层
+ * (两层同时生效结果也正确,只是多余);Desktop App 共用 agentDir,它那里本来就是空转。
+ */
+export function removeLegacyUiTextExtension(outputDir) {
+    const dir = outputDir ?? join(agentDir, "extensions");
+    try {
+        rmSync(join(dir, LEGACY_UI_TEXT_EXTENSION_FILE), { force: true });
+    }
+    catch { }
+}
 /**
  * pi-web-ui 的就绪检测只认 <agentDir>/auth.json 里有没有凭据条目(models.json
  * 的 apiKey 它不看),空 {} 会在网页里弹「未检测到 pi agent 配置」引导装 pi。

package/dist/agents/agent-config.d.ts

@@ -0,0 +1,83 @@
+import { type RuntimeBrake } from "./runtime.js";
+export type GatewayAgentName = "claude-code" | "codex" | "pi";
+export interface AgentModel {
+    id: string;
+    name: string;
+    contextWindow?: number;
+}
+export interface AgentConfig {
+    agent: GatewayAgentName;
+    enabled: boolean;
+    disabledReason: string | null;
+    runtime: RuntimeBrake;
+    defaultModel: string | null;
+    smallModel: string | null;
+    models: AgentModel[];
+    settings: Record<string, unknown> | null;
+}
+/** 校验并规范化响应体;形状不对返回 undefined(按网关故障处理,可退回缓存)。 */
+export declare function parseAgentConfig(body: unknown, agent: GatewayAgentName): AgentConfig | undefined;
+export type AgentConfigResult = {
+    status: "ok";
+    config: AgentConfig;
+    fromCache: boolean;
+} | {
+    status: "disabled";
+    reason: string | null;
+    fromCache: boolean;
+} | {
+    status: "unavailable";
+} | {
+    status: "auth";
+    httpStatus: number;
+} | {
+    status: "error";
+    detail: string;
+};
+interface CacheFile {
+    site: string;
+    fetchedAt: number;
+    body: unknown;
+}
+export declare function readConfigCache(file: string, site: string): CacheFile | undefined;
+/**
+ * @param fetchConfig 发出请求(经签名代理);抛错 = 网络失败
+ * @param site 缓存按站点隔离(用 API origin),换站后不会用到另一站的配置
+ */
+export declare function loadAgentConfig(input: {
+    agent: GatewayAgentName;
+    fetchConfig: () => Promise<Response>;
+    cacheFile: string;
+    site: string;
+    now?: () => number;
+}): Promise<AgentConfigResult>;
+/**
+ * 网关 `GET /public/agents/:agent/runtime`(免鉴权):只有开关与版本刹车,没有模型阵容。
+ * 给还没登录、也没有配置缓存的 `u1s1 agents install` 用——那时拿不到 /v1/agents/:agent/config,
+ * 又不能在没有版本上限的情况下下载。不写缓存:缓存里要的是完整配置(离线启动时要用阵容)。
+ */
+export interface PublicAgentRuntime {
+    enabled: boolean;
+    disabledReason: string | null;
+    runtime: RuntimeBrake;
+}
+export declare function parsePublicAgentRuntime(body: unknown, agent: GatewayAgentName): PublicAgentRuntime | undefined;
+export type PublicAgentRuntimeResult = {
+    status: "ok";
+    brakes: PublicAgentRuntime;
+}
+/** 404:线上网关还没有这个接口 */
+ | {
+    status: "unavailable";
+}
+/** 网络失败、5xx、响应不成形 */
+ | {
+    status: "error";
+    detail: string;
+};
+export declare function loadPublicAgentRuntime(input: {
+    agent: GatewayAgentName;
+    /** 发出请求;抛错 = 网络失败 */
+    fetchRuntime: () => Promise<Response>;
+}): Promise<PublicAgentRuntimeResult>;
+export {};

package/dist/agents/agent-config.js

@@ -0,0 +1,154 @@
+/**
+ * 网关按客户端下发的配置:`GET /v1/agents/:agent/config`(经本机签名代理调用)。
+ *
+ * 契约(网关 workers/gateway/src/agent-config.ts):
+ *   { agent, enabled, disabled_reason, runtime: { min_version, max_tested_version, blocked_versions },
+ *     default_model, small_model, models: [...], settings }
+ * default_model / small_model 在没有模型时是 null;settings 只在 claude-code 启用时是对象,其余 null。
+ * 响应里没有任何凭证或端点:地址和本地 token 由启动器自己注入。
+ *
+ * 结果处理:
+ *   200 → 用并写缓存;enabled:false → 不启动,显示 disabled_reason;
+ *   404(老网关没有这个接口)→ 当作「暂未开放」;
+ *   网络失败 / 5xx / 超时 → 用同一站点上次成功拉到的缓存,没有缓存才报错。
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { dirname } from "node:path";
+import { brakeFromApi } from "./runtime.js";
+function isRecord(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function nonEmptyString(v, max = 200) {
+    return typeof v === "string" && v.length > 0 && v.length <= max ? v : null;
+}
+/** 校验并规范化响应体;形状不对返回 undefined(按网关故障处理,可退回缓存)。 */
+export function parseAgentConfig(body, agent) {
+    if (!isRecord(body) || body["agent"] !== agent || typeof body["enabled"] !== "boolean")
+        return undefined;
+    const models = [];
+    if (Array.isArray(body["models"])) {
+        for (const m of body["models"]) {
+            if (!isRecord(m))
+                continue;
+            const id = nonEmptyString(m["id"]);
+            if (!id)
+                continue;
+            const cw = m["context_window"];
+            models.push({
+                id,
+                name: nonEmptyString(m["name"]) ?? id,
+                contextWindow: typeof cw === "number" && Number.isFinite(cw) && cw > 0 ? cw : undefined,
+            });
+        }
+    }
+    const settings = isRecord(body["settings"]) ? body["settings"] : null;
+    return {
+        agent,
+        enabled: body["enabled"],
+        disabledReason: nonEmptyString(body["disabled_reason"], 2000),
+        runtime: brakeFromApi(body["runtime"]),
+        defaultModel: nonEmptyString(body["default_model"]),
+        smallModel: nonEmptyString(body["small_model"]),
+        models,
+        settings,
+    };
+}
+export function readConfigCache(file, site) {
+    try {
+        const raw = JSON.parse(readFileSync(file, "utf8"));
+        return raw && raw.site === site && typeof raw.fetchedAt === "number" ? raw : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeConfigCache(file, entry) {
+    try {
+        mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
+        const tmp = `${file}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+        writeFileSync(tmp, JSON.stringify(entry) + "\n", { mode: 0o600 });
+        renameSync(tmp, file);
+    }
+    catch {
+        // 缓存写不进去不影响本次启动
+    }
+}
+function fromConfig(config, fromCache) {
+    if (!config.enabled)
+        return { status: "disabled", reason: config.disabledReason, fromCache };
+    return { status: "ok", config, fromCache };
+}
+/**
+ * @param fetchConfig 发出请求(经签名代理);抛错 = 网络失败
+ * @param site 缓存按站点隔离(用 API origin),换站后不会用到另一站的配置
+ */
+export async function loadAgentConfig(input) {
+    const now = input.now ?? Date.now;
+    const fallback = (detail) => {
+        const cached = readConfigCache(input.cacheFile, input.site);
+        const config = cached ? parseAgentConfig(cached.body, input.agent) : undefined;
+        return config ? fromConfig(config, true) : { status: "error", detail };
+    };
+    let res;
+    try {
+        res = await input.fetchConfig();
+    }
+    catch (e) {
+        return fallback(e instanceof Error ? e.message : String(e));
+    }
+    if (res.status === 404)
+        return { status: "unavailable" };
+    if (res.status === 401 || res.status === 403)
+        return { status: "auth", httpStatus: res.status };
+    if (!res.ok)
+        return fallback(`HTTP ${res.status}`);
+    let body;
+    try {
+        const text = await res.text();
+        if (text.length > 1024 * 1024)
+            return fallback("response too large");
+        body = JSON.parse(text);
+    }
+    catch {
+        return fallback("malformed response");
+    }
+    const config = parseAgentConfig(body, input.agent);
+    if (!config)
+        return fallback("malformed response");
+    writeConfigCache(input.cacheFile, { site: input.site, fetchedAt: now(), body });
+    return fromConfig(config, false);
+}
+export function parsePublicAgentRuntime(body, agent) {
+    if (!isRecord(body) || body["agent"] !== agent || typeof body["enabled"] !== "boolean" || !isRecord(body["runtime"])) {
+        return undefined;
+    }
+    return {
+        enabled: body["enabled"],
+        disabledReason: nonEmptyString(body["disabled_reason"], 2000),
+        runtime: brakeFromApi(body["runtime"]),
+    };
+}
+export async function loadPublicAgentRuntime(input) {
+    let res;
+    try {
+        res = await input.fetchRuntime();
+    }
+    catch (e) {
+        return { status: "error", detail: e instanceof Error ? e.message : String(e) };
+    }
+    if (res.status === 404)
+        return { status: "unavailable" };
+    if (!res.ok)
+        return { status: "error", detail: `HTTP ${res.status}` };
+    try {
+        const text = await res.text();
+        if (text.length > 64 * 1024)
+            return { status: "error", detail: "response too large" };
+        const brakes = parsePublicAgentRuntime(JSON.parse(text), input.agent);
+        return brakes ? { status: "ok", brakes } : { status: "error", detail: "malformed response" };
+    }
+    catch {
+        return { status: "error", detail: "malformed response" };
+    }
+}

package/dist/agents/claude.d.ts

@@ -0,0 +1,80 @@
+import { type McpLaunchEnv } from "../mcp-server.js";
+import { type AgentConfig } from "./agent-config.js";
+import { type RuntimePaths } from "./runtime.js";
+export { agentsRoot, CLAUDE_TERMS_URL, cliInstallHooks, consentLines, notOpenText, overMaxTestedText, printRuntimeFailure, runtimeErrorText, spawnAgent, } from "./launch.js";
+export declare const CLAUDE_GATEWAY_AGENT: "claude-code";
+export interface ClaudePaths extends RuntimePaths {
+    /** CLAUDE_CONFIG_DIR */
+    configDir: string;
+    /** --settings 文件 */
+    settingsFile: string;
+    /** 上次成功拉到的 /v1/agents/claude-code/config */
+    configCache: string;
+    /** --mcp-config 文件 */
+    mcpConfigFile: string;
+}
+export declare function claudePaths(root?: string): ClaudePaths;
+/**
+ * 子进程环境里要去掉的变量:会让它绕开本机代理(云厂商开关与地址)、换用别的凭证
+ * (API Key、OAuth token,其中 x-api-key 会被代理拒绝),或盖过网关下发设置的模型变量。
+ * 只影响这一次启动的子进程环境,用户自己的 shell 与配置不动。
+ */
+export declare const CLAUDE_ENV_DROP: readonly string[];
+export interface ClaudeLaunchInput {
+    baseEnv: NodeJS.ProcessEnv;
+    /** 签名代理的 origin,形如 http://127.0.0.1:12345(不带 /v1) */
+    proxyOrigin: string;
+    /** 签名代理的一次性本地 token */
+    localToken: string;
+    configDir: string;
+    /** u1s1 工具服务要的变量(mcpLaunchEnv);不注入时省略 */
+    mcp?: McpLaunchEnv;
+}
+export declare function claudeLaunchEnv(input: ClaudeLaunchInput): NodeJS.ProcessEnv;
+/**
+ * --mcp-config 是可变参数(后面不是选项的参数都会被当成配置文件),所以放在 --settings 前面,
+ * 让 --settings 把它截住;用户自己的参数(包括直接写的提示词)放最后。
+ *
+ * 例外:用户参数恰好只有一个 --version / -v / -V 时原样传,什么都不加。Claude Code 只在参数只有
+ * 版本开关时走快速返回;前面多了 --mcp-config / --settings 就会先跑完整初始化,断网时要等很久。
+ * 只打印版本用不到这两个配置。
+ */
+export declare function claudeLaunchArgs(settingsFile: string, userArgs: readonly string[], mcpConfigFile?: string): string[];
+/** `u1s1 claude --version`(或 -v / -V)且没有别的参数。 */
+export declare function isBareVersionQuery(userArgs: readonly string[]): boolean;
+/**
+ * 写给 --mcp-config 的内容:一个 stdio 服务,env 里只有 `${变量名}` 引用,由 Claude Code 在拉起时
+ * 用它自己的环境展开(值是启动器放进子进程环境的,见 claudeLaunchEnv),文件里没有 token。
+ */
+export declare function claudeMcpConfig(command?: {
+    command: string;
+    args: string[];
+}, env?: NodeJS.ProcessEnv): Record<string, unknown>;
+/**
+ * 搜索与读网页预先允许(与 Pi 一致,不逐次确认;读网页直连不计费,搜索按次计费但单价低,
+ * 工具说明里要求模型别重复搜)。生图单价高:放进 ask,每次都问用户——不放 ask 的话,Claude Code
+ * 默认的 auto mode 会让它自己的安全检查替用户放行(2.1.322 实测),用户不知情就扣费。
+ */
+export declare const CLAUDE_MCP_ALLOWED_TOOLS: readonly string[];
+export declare const CLAUDE_MCP_ASK_TOOLS: readonly string[];
+export declare function withMcpPermissions(settings: Record<string, unknown>): Record<string, unknown>;
+/**
+ * 启动器自己钉在 settings.env 里的值(盖过网关下发的同名项)。CLAUDE_ENV_DROP 只管得到 shell 环境;
+ * 用户仓库里的 .claude/settings.json / settings.local.json 也能用 env 设这两个变量,改掉网关判定要核对的
+ * 请求形状(=0 时 system 里不带计费头;EXTRA_BODY 带 metadata 时盖掉 metadata.user_id),判成中转嫌疑。
+ * --settings 的优先级高于项目设置,在这里写回默认值。
+ */
+export declare const CLAUDE_SETTINGS_ENV_PINNED: Readonly<Record<string, string>>;
+/**
+ * 网关的 settings → 写给 --settings 的对象:去掉连接/凭证相关项,钉上 CLAUDE_SETTINGS_ENV_PINNED;
+ * model 用调用方选好的(用户在 u1s1 config 里定的、仍在阵容里的模型),没给时保留网关的,
+ * 网关也没有就用 default_model。
+ */
+export declare function claudeSettingsFromConfig(config: AgentConfig, model?: string | null): Record<string, unknown>;
+export declare function writeClaudeSettings(file: string, settings: Record<string, unknown>): void;
+/** 桌面端复用:同一份注入逻辑(embed.ts 导出)。 */
+export declare function agentLaunchEnv(agent: "claude", input: ClaudeLaunchInput): NodeJS.ProcessEnv;
+/**
+ * `u1s1 claude [参数…]`。返回子进程的退出码(启动前就失败返回 1)。
+ */
+export declare function runClaude(userArgs: string[]): Promise<number>;

package/dist/agents/claude.js

@@ -0,0 +1,233 @@
+/**
+ * `u1s1 claude`:以子进程启动用户机器上的官方原版客户端,经本机签名代理用设备凭证访问网关。
+ *
+ * 注入(规划 4.4):
+ *   CLAUDE_CONFIG_DIR=~/.u1s1/agents/claude/config   与用户自己的 ~/.claude 互不影响
+ *   ANTHROPIC_BASE_URL=http://127.0.0.1:<端口>        不带 /v1,客户端自己拼 /v1/messages
+ *   ANTHROPIC_AUTH_TOKEN=<本地 token>                  代理只认 Bearer;不能用 ANTHROPIC_API_KEY(发 x-api-key)
+ *   DISABLE_AUTOUPDATER=1                              更新由启动器管(runtime.ts)
+ *   --settings <启动器写出的文件>                     网关下发的模型阵容等;文件里没有任何凭证
+ *   --mcp-config <启动器写出的文件>                   u1s1 工具服务(搜索、读网页、生图,见 mcp-server.ts);
+ *                                                      文件里只引用环境变量名,代理地址和本地 token 的值在子进程环境里
+ *
+ * 真实凭证(设备令牌、设备私钥)只留在启动器进程里:子进程环境从 stripSecretEnv 起步、
+ * 再显式写入上面几项;本地 token 只对本进程的签名代理有效,进程退出即作废。
+ * 不改二进制,不删除也不禁用它自带的登录方式。
+ */
+import { rmSync } from "node:fs";
+import { join } from "node:path";
+import { writePrivateFile } from "../config.js";
+import { lang } from "../i18n.js";
+import { MCP_ENV_NAMES, MCP_SERVER_NAME, MCP_TRACE_ENV, mcpInjectionDisabled, mcpLaunchEnv, mcpServerCommand, } from "../mcp-server.js";
+import { AGENT_PROFILES, agentsRoot, prepareAgentLaunch, runPreparedAgent, } from "./launch.js";
+import { runtimePaths } from "./runtime.js";
+import { stripSecretEnv } from "../secret-env.js";
+// 共用的启动流程与文案在 launch.ts;这里保留原来的导出名,调用方与测试不用改
+export { agentsRoot, CLAUDE_TERMS_URL, cliInstallHooks, consentLines, notOpenText, overMaxTestedText, printRuntimeFailure, runtimeErrorText, spawnAgent, } from "./launch.js";
+export const CLAUDE_GATEWAY_AGENT = "claude-code";
+export function claudePaths(root = agentsRoot()) {
+    const base = runtimePaths(root, "claude");
+    return {
+        ...base,
+        configDir: join(base.root, "config"),
+        settingsFile: join(base.root, "settings.json"),
+        configCache: join(base.root, "agent-config.json"),
+        mcpConfigFile: join(base.root, "mcp.json"),
+    };
+}
+/**
+ * 子进程环境里要去掉的变量:会让它绕开本机代理(云厂商开关与地址)、换用别的凭证
+ * (API Key、OAuth token,其中 x-api-key 会被代理拒绝),或盖过网关下发设置的模型变量。
+ * 只影响这一次启动的子进程环境,用户自己的 shell 与配置不动。
+ */
+export const CLAUDE_ENV_DROP = [
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_AUTH_TOKEN",
+    "ANTHROPIC_BASE_URL",
+    "ANTHROPIC_CUSTOM_HEADERS",
+    "ANTHROPIC_MODEL",
+    "ANTHROPIC_SMALL_FAST_MODEL",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+    "CLAUDE_CODE_OAUTH_TOKEN",
+    "CLAUDE_CODE_USE_BEDROCK",
+    "CLAUDE_CODE_USE_VERTEX",
+    "CLAUDE_CODE_USE_FOUNDRY",
+    "ANTHROPIC_BEDROCK_BASE_URL",
+    "ANTHROPIC_VERTEX_BASE_URL",
+    "ANTHROPIC_FOUNDRY_BASE_URL",
+    "ANTHROPIC_FOUNDRY_API_KEY",
+    "AWS_BEARER_TOKEN_BEDROCK",
+    "CLAUDE_CONFIG_DIR",
+    // 下面两个会改掉网关客户端判定要核对的请求形状,判成中转嫌疑(只有赠送余额的账号直接 403):
+    // =0 时 system 里不再带计费头;
+    "CLAUDE_CODE_ATTRIBUTION_HEADER",
+    // 合并进请求体的 JSON,带 metadata 时会盖掉 metadata.user_id(会话标识核对不上)。
+    "CLAUDE_CODE_EXTRA_BODY",
+    // u1s1 工具服务的变量只由启动器设;关掉注入时也不留用户环境里的旧值
+    ...MCP_ENV_NAMES.filter((name) => name !== "U1S1_LANG"),
+];
+export function claudeLaunchEnv(input) {
+    if (!/^http:\/\/127\.0\.0\.1:\d+$/.test(input.proxyOrigin)) {
+        throw new Error(`proxy origin must be a loopback origin without a path: ${input.proxyOrigin}`);
+    }
+    const env = stripSecretEnv(input.baseEnv);
+    for (const key of CLAUDE_ENV_DROP)
+        delete env[key];
+    // scrubForeignProviderEnv 会从启动器自己的环境里删 ANTHROPIC_AUTH_TOKEN,所以这里显式写进子进程环境
+    env["CLAUDE_CONFIG_DIR"] = input.configDir;
+    env["ANTHROPIC_BASE_URL"] = input.proxyOrigin;
+    env["ANTHROPIC_AUTH_TOKEN"] = input.localToken;
+    env["DISABLE_AUTOUPDATER"] = "1";
+    if (input.mcp)
+        Object.assign(env, input.mcp);
+    return env;
+}
+/**
+ * --mcp-config 是可变参数(后面不是选项的参数都会被当成配置文件),所以放在 --settings 前面,
+ * 让 --settings 把它截住;用户自己的参数(包括直接写的提示词)放最后。
+ *
+ * 例外:用户参数恰好只有一个 --version / -v / -V 时原样传,什么都不加。Claude Code 只在参数只有
+ * 版本开关时走快速返回;前面多了 --mcp-config / --settings 就会先跑完整初始化,断网时要等很久。
+ * 只打印版本用不到这两个配置。
+ */
+export function claudeLaunchArgs(settingsFile, userArgs, mcpConfigFile) {
+    if (isBareVersionQuery(userArgs))
+        return [...userArgs];
+    return [...(mcpConfigFile ? ["--mcp-config", mcpConfigFile] : []), "--settings", settingsFile, ...userArgs];
+}
+const CLAUDE_VERSION_FLAGS = new Set(["--version", "-v", "-V"]);
+/** `u1s1 claude --version`(或 -v / -V)且没有别的参数。 */
+export function isBareVersionQuery(userArgs) {
+    return userArgs.length === 1 && CLAUDE_VERSION_FLAGS.has(userArgs[0]);
+}
+/**
+ * 写给 --mcp-config 的内容:一个 stdio 服务,env 里只有 `${变量名}` 引用,由 Claude Code 在拉起时
+ * 用它自己的环境展开(值是启动器放进子进程环境的,见 claudeLaunchEnv),文件里没有 token。
+ */
+export function claudeMcpConfig(command = mcpServerCommand(), env = process.env) {
+    const names = [...MCP_ENV_NAMES];
+    if (env[MCP_TRACE_ENV])
+        names.push(MCP_TRACE_ENV);
+    return {
+        mcpServers: {
+            [MCP_SERVER_NAME]: {
+                type: "stdio",
+                command: command.command,
+                args: command.args,
+                env: Object.fromEntries(names.map((name) => [name, `\${${name}}`])),
+            },
+        },
+    };
+}
+/**
+ * 搜索与读网页预先允许(与 Pi 一致,不逐次确认;读网页直连不计费,搜索按次计费但单价低,
+ * 工具说明里要求模型别重复搜)。生图单价高:放进 ask,每次都问用户——不放 ask 的话,Claude Code
+ * 默认的 auto mode 会让它自己的安全检查替用户放行(2.1.322 实测),用户不知情就扣费。
+ */
+export const CLAUDE_MCP_ALLOWED_TOOLS = [
+    `mcp__${MCP_SERVER_NAME}__web_search`,
+    `mcp__${MCP_SERVER_NAME}__web_fetch`,
+];
+export const CLAUDE_MCP_ASK_TOOLS = [`mcp__${MCP_SERVER_NAME}__generate_image`];
+function mergeRules(existing, rules) {
+    const out = Array.isArray(existing) ? [...existing] : [];
+    for (const rule of rules)
+        if (!out.includes(rule))
+            out.push(rule);
+    return out;
+}
+export function withMcpPermissions(settings) {
+    const raw = settings["permissions"];
+    const permissions = raw && typeof raw === "object" && !Array.isArray(raw) ? { ...raw } : {};
+    permissions["allow"] = mergeRules(permissions["allow"], CLAUDE_MCP_ALLOWED_TOOLS);
+    permissions["ask"] = mergeRules(permissions["ask"], CLAUDE_MCP_ASK_TOOLS);
+    return { ...settings, permissions };
+}
+/** settings.env 里绝不能出现的键(契约上网关也不会发,这里再兜一层)。 */
+const SETTINGS_ENV_FORBIDDEN = new Set([
+    "ANTHROPIC_BASE_URL",
+    "ANTHROPIC_AUTH_TOKEN",
+    "ANTHROPIC_API_KEY",
+    "CLAUDE_CODE_OAUTH_TOKEN",
+    "CLAUDE_CONFIG_DIR",
+]);
+/** 会让客户端去别处取凭证的设置项。 */
+const SETTINGS_FORBIDDEN = new Set(["apiKeyHelper"]);
+/**
+ * 启动器自己钉在 settings.env 里的值(盖过网关下发的同名项)。CLAUDE_ENV_DROP 只管得到 shell 环境;
+ * 用户仓库里的 .claude/settings.json / settings.local.json 也能用 env 设这两个变量,改掉网关判定要核对的
+ * 请求形状(=0 时 system 里不带计费头;EXTRA_BODY 带 metadata 时盖掉 metadata.user_id),判成中转嫌疑。
+ * --settings 的优先级高于项目设置,在这里写回默认值。
+ */
+export const CLAUDE_SETTINGS_ENV_PINNED = {
+    CLAUDE_CODE_ATTRIBUTION_HEADER: "1",
+    CLAUDE_CODE_EXTRA_BODY: "{}",
+};
+/**
+ * 网关的 settings → 写给 --settings 的对象:去掉连接/凭证相关项,钉上 CLAUDE_SETTINGS_ENV_PINNED;
+ * model 用调用方选好的(用户在 u1s1 config 里定的、仍在阵容里的模型),没给时保留网关的,
+ * 网关也没有就用 default_model。
+ */
+export function claudeSettingsFromConfig(config, model) {
+    const out = {};
+    for (const [key, value] of Object.entries(config.settings ?? {})) {
+        if (!SETTINGS_FORBIDDEN.has(key))
+            out[key] = value;
+    }
+    const rawEnv = out["env"];
+    if (rawEnv && typeof rawEnv === "object" && !Array.isArray(rawEnv)) {
+        const env = {};
+        for (const [key, value] of Object.entries(rawEnv)) {
+            if (!SETTINGS_ENV_FORBIDDEN.has(key))
+                env[key] = value;
+        }
+        out["env"] = { ...env, ...CLAUDE_SETTINGS_ENV_PINNED };
+    }
+    else {
+        out["env"] = { ...CLAUDE_SETTINGS_ENV_PINNED };
+    }
+    if (model)
+        out["model"] = model;
+    else if (out["model"] === undefined && config.defaultModel)
+        out["model"] = config.defaultModel;
+    return out;
+}
+export function writeClaudeSettings(file, settings) {
+    writePrivateFile(file, JSON.stringify(settings, null, 2) + "\n");
+}
+/** 桌面端复用:同一份注入逻辑(embed.ts 导出)。 */
+export function agentLaunchEnv(agent, input) {
+    if (agent !== "claude")
+        throw new Error(`unsupported agent: ${String(agent)}`);
+    return claudeLaunchEnv(input);
+}
+// ---------------------------------------------------------------- run
+/**
+ * `u1s1 claude [参数…]`。返回子进程的退出码(启动前就失败返回 1)。
+ */
+export async function runClaude(userArgs) {
+    const paths = claudePaths();
+    const prepared = await prepareAgentLaunch(AGENT_PROFILES.claude, paths);
+    if (typeof prepared === "number")
+        return prepared;
+    const mcp = mcpInjectionDisabled()
+        ? undefined
+        : mcpLaunchEnv({ proxyBaseUrl: prepared.proxy.baseUrl, localToken: prepared.proxy.localKey, features: prepared.features, lang: lang() });
+    const settings = claudeSettingsFromConfig(prepared.config, prepared.model);
+    writeClaudeSettings(paths.settingsFile, mcp ? withMcpPermissions(settings) : settings);
+    if (mcp)
+        writePrivateFile(paths.mcpConfigFile, JSON.stringify(claudeMcpConfig(), null, 2) + "\n");
+    else
+        rmSync(paths.mcpConfigFile, { force: true });
+    const env = claudeLaunchEnv({
+        baseEnv: process.env,
+        proxyOrigin: new URL(prepared.proxy.baseUrl).origin,
+        localToken: prepared.proxy.localKey,
+        configDir: paths.configDir,
+        mcp,
+    });
+    const args = claudeLaunchArgs(paths.settingsFile, userArgs, mcp ? paths.mcpConfigFile : undefined);
+    return runPreparedAgent({ agent: "claude", paths, prepared, args, env, userArgs });
+}