u1s1-cli 1.14.6 → 1.15.1

package/dist/agents/claude.js

@@ -0,0 +1,411 @@
+/**
+ * `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 <启动器写出的文件>                     网关下发的模型阵容等;文件里没有任何凭证
+ *                                                      调用方自己传的 --settings(文件或 JSON,可多个)不转给客户端,
+ *                                                      按顺序合并进这份文件再清洗(Claude Code 只认最后一个 --settings),
+ *                                                      见 extractSettingsArgs / mergeClaudeSettings
+ *   --mcp-config <启动器写出的文件>                   u1s1 工具服务(搜索、读网页、生图,见 mcp-server.ts);
+ *                                                      文件里只引用环境变量名,代理地址和本地 token 的值在子进程环境里
+ *
+ * 真实凭证(设备令牌、设备私钥)只留在启动器进程里:子进程环境从 stripSecretEnv 起步、
+ * 再显式写入上面几项;本地 token 只对本进程的签名代理有效,进程退出即作废。
+ * 不改二进制,不删除也不禁用它自带的登录方式。
+ */
+import { readdirSync, readFileSync, rmSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { writePrivateFile } from "../config.js";
+import { lang, tr } 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 里绝不能出现的键(契约上网关也不会发,这里再兜一层;调用方的 --settings 合并进来后同样过这一遍):
+ * CLAUDE_ENV_DROP 里换凭证、换地址、换云厂商、改 u1s1 工具服务连接的那些。模型变量可以由调用方改
+ * (等同于改 model);两个请求形状变量另由 CLAUDE_SETTINGS_ENV_PINNED 钉回默认值。
+ */
+const SETTINGS_ENV_ALLOWED_FROM_DROP = new Set([
+    "ANTHROPIC_MODEL",
+    "ANTHROPIC_SMALL_FAST_MODEL",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+]);
+/** 会让客户端去别处取凭证的设置项。 */
+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: "{}",
+};
+const SETTINGS_ENV_FORBIDDEN = new Set(CLAUDE_ENV_DROP.filter((key) => !SETTINGS_ENV_ALLOWED_FROM_DROP.has(key) && !(key in CLAUDE_SETTINGS_ENV_PINNED)));
+function isPlainObject(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+/** 去掉连接/凭证相关项(SETTINGS_FORBIDDEN、env 里的 SETTINGS_ENV_FORBIDDEN),钉上 CLAUDE_SETTINGS_ENV_PINNED。 */
+export function sanitizeClaudeSettings(settings) {
+    const out = {};
+    for (const [key, value] of Object.entries(settings)) {
+        if (!SETTINGS_FORBIDDEN.has(key))
+            out[key] = value;
+    }
+    const env = {};
+    if (isPlainObject(out["env"])) {
+        for (const [key, value] of Object.entries(out["env"])) {
+            if (!SETTINGS_ENV_FORBIDDEN.has(key))
+                env[key] = value;
+        }
+    }
+    out["env"] = { ...env, ...CLAUDE_SETTINGS_ENV_PINNED };
+    return out;
+}
+/**
+ * 网关的 settings → 写给 --settings 的对象:去掉连接/凭证相关项,钉上 CLAUDE_SETTINGS_ENV_PINNED;
+ * model 用调用方选好的(用户在 u1s1 config 里定的、仍在阵容里的模型),没给时保留网关的,
+ * 网关也没有就用 default_model。
+ */
+export function claudeSettingsFromConfig(config, model) {
+    const out = sanitizeClaudeSettings(config.settings ?? {});
+    if (model)
+        out["model"] = model;
+    else if (out["model"] === undefined && config.defaultModel)
+        out["model"] = config.defaultModel;
+    return out;
+}
+// ---------------------------------------------------------------- 调用方的 --settings
+/** 调用方的 --settings 有问题(缺值、读不了、不是 JSON 对象);runClaude 报出来后以非 0 退出。 */
+export class ClaudeSettingsArgError extends Error {
+    name = "ClaudeSettingsArgError";
+}
+/**
+ * Claude Code 的 --settings 只认最后一个(2.1.323 实测),用户参数里再带一个就把启动器的整份设置盖掉。
+ * 所以从用户参数里把它们全抽出来(`--settings <值>` 与 `--settings=<值>`,按出现顺序;`--` 之后不动),
+ * 由启动器合并进自己写的那份。值可以是文件路径,也可以是 JSON 字符串(与 Claude Code 一样)。
+ */
+export function extractSettingsArgs(userArgs) {
+    const rest = [];
+    const sources = [];
+    for (let i = 0; i < userArgs.length; i++) {
+        const arg = userArgs[i];
+        if (arg === "--") {
+            rest.push(...userArgs.slice(i));
+            break;
+        }
+        if (arg === "--settings") {
+            const value = userArgs[i + 1];
+            if (value === undefined || value === "")
+                throw new ClaudeSettingsArgError(tr("--settings 后面缺少文件路径或 JSON。", "--settings needs a file path or a JSON string."));
+            sources.push(value);
+            i++;
+        }
+        else if (arg.startsWith("--settings=")) {
+            const value = arg.slice("--settings=".length);
+            if (value === "")
+                throw new ClaudeSettingsArgError(tr("--settings= 后面缺少文件路径或 JSON。", "--settings= needs a file path or a JSON string."));
+            sources.push(value);
+        }
+        else {
+            rest.push(arg);
+        }
+    }
+    return { rest, sources };
+}
+/** 读一个 --settings 的值:以 `{` 开头按 JSON 字符串解析,否则当文件路径(相对 cwd)。必须是 JSON 对象。 */
+export function loadCallerSettings(source, cwd = process.cwd()) {
+    const inline = source.trimStart().startsWith("{");
+    let text;
+    if (inline) {
+        text = source;
+    }
+    else {
+        const file = resolve(cwd, source);
+        try {
+            text = readFileSync(file, "utf8");
+        }
+        catch (e) {
+            const reason = e.code ?? e.message;
+            throw new ClaudeSettingsArgError(tr(`读不了 --settings 文件 ${file}(${reason})。`, `Couldn't read the --settings file ${file} (${reason}).`));
+        }
+    }
+    const what = inline ? tr("--settings 的 JSON", "The --settings JSON") : tr(`--settings 文件 ${resolve(cwd, source)}`, `The --settings file ${resolve(cwd, source)}`);
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (e) {
+        throw new ClaudeSettingsArgError(tr(`${what} 不是合法的 JSON:${e.message}`, `${what} is not valid JSON: ${e.message}`));
+    }
+    if (!isPlainObject(parsed))
+        throw new ClaudeSettingsArgError(tr(`${what} 必须是一个 JSON 对象。`, `${what} must be a JSON object.`));
+    return parsed;
+}
+function mergeArrays(base, extra, dedupe) {
+    if (!dedupe)
+        return [...base, ...extra];
+    const out = [...base];
+    const seen = new Set(out.map((item) => JSON.stringify(item)));
+    for (const item of extra) {
+        const key = JSON.stringify(item);
+        if (!seen.has(key)) {
+            seen.add(key);
+            out.push(item);
+        }
+    }
+    return out;
+}
+function mergeValue(base, extra, path) {
+    if (isPlainObject(base) && isPlainObject(extra)) {
+        const out = { ...base };
+        for (const [key, value] of Object.entries(extra)) {
+            if (key === "__proto__")
+                continue;
+            out[key] = Object.hasOwn(out, key) ? mergeValue(out[key], value, [...path, key]) : value;
+        }
+        return out;
+    }
+    // hooks.<事件> 按原样拼接(调用方的回调排在后面);其余数组(permissions.allow/ask/deny 等)拼接去重
+    if (Array.isArray(base) && Array.isArray(extra))
+        return mergeArrays(base, extra, !(path.length === 2 && path[0] === "hooks"));
+    return extra;
+}
+/**
+ * 把调用方的设置合并进启动器的:对象逐层合并;hooks 每个事件的数组拼接;其余数组拼接去重;
+ * 标量(含 model、statusLine 这类整项)以调用方为准。合并后调用方还要再过 sanitizeClaudeSettings 与
+ * withMcpPermissions,不能借此换凭证、换地址、改请求形状。
+ */
+export function mergeClaudeSettings(base, caller) {
+    return mergeValue(base, caller, []);
+}
+/** 启动器的设置 + 调用方的设置(按顺序)→ 清洗 → MCP 权限:写进 --settings 文件的最终内容。 */
+export function finalClaudeSettings(launcher, callers, withMcp) {
+    const merged = sanitizeClaudeSettings(callers.reduce(mergeClaudeSettings, launcher));
+    return withMcp ? withMcpPermissions(merged) : merged;
+}
+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
+const PROCESS_SETTINGS = /^settings-(\d+)\.json$/;
+/**
+ * 带调用方 --settings 时,合并结果写进这个进程自己的文件:Claude Code 会监视 --settings 文件、改了就重读,
+ * 几个进程共用一份的话,后起的会把先起的那个的 hooks(调用方按会话区分的回调)换成自己的。
+ * 没有调用方 --settings 时内容只取决于网关配置,仍用共用的 settingsFile。
+ */
+export function processSettingsFile(paths, pid = process.pid) {
+    return join(paths.root, `settings-${pid}.json`);
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === "EPERM";
+    }
+}
+/** 删掉上次没来得及清理(进程被强杀)的每进程设置文件;进程还在的不动。 */
+export function cleanStaleSettingsFiles(root, alive = pidAlive) {
+    let names;
+    try {
+        names = readdirSync(root);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        const m = PROCESS_SETTINGS.exec(name);
+        if (m && !alive(Number(m[1])))
+            rmSync(join(root, name), { force: true });
+    }
+}
+/**
+ * `u1s1 claude [参数…]`。返回子进程的退出码(启动前就失败返回 1)。
+ */
+export async function runClaude(userArgs) {
+    // 调用方的 --settings 先读出来:有错在登录、联网之前就报。只查版本的快速路径原样不动。
+    let launchArgs = userArgs;
+    let callerSettings = [];
+    if (!isBareVersionQuery(userArgs)) {
+        try {
+            const { rest, sources } = extractSettingsArgs(userArgs);
+            launchArgs = rest;
+            callerSettings = sources.map((source) => loadCallerSettings(source));
+        }
+        catch (e) {
+            if (!(e instanceof ClaudeSettingsArgError))
+                throw e;
+            console.error(e.message);
+            return 1;
+        }
+    }
+    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);
+    cleanStaleSettingsFiles(paths.root);
+    const settingsFile = callerSettings.length ? processSettingsFile(paths) : paths.settingsFile;
+    writeClaudeSettings(settingsFile, finalClaudeSettings(settings, callerSettings, !!mcp));
+    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(settingsFile, launchArgs, mcp ? paths.mcpConfigFile : undefined);
+    try {
+        return await runPreparedAgent({ agent: "claude", paths, prepared, args, env, userArgs });
+    }
+    finally {
+        if (settingsFile !== paths.settingsFile)
+            rmSync(settingsFile, { force: true });
+    }
+}

package/dist/agents/codex.d.ts

@@ -0,0 +1,111 @@
+import { type McpLaunchEnv } from "../mcp-server.js";
+import type { AgentConfig } from "./agent-config.js";
+import { type RuntimePaths } from "./runtime.js";
+export declare const CODEX_GATEWAY_AGENT: "codex";
+/** config.toml 里我们的 provider id(不能用 openai、ollama 等内置保留名)。 */
+export declare const CODEX_PROVIDER_ID = "u1s1";
+/** provider 的 env_key:子进程环境里放本地 token 的变量名。 */
+export declare const CODEX_KEY_ENV = "U1S1_LOCAL_KEY";
+export interface CodexPaths extends RuntimePaths {
+    /** CODEX_HOME */
+    configDir: string;
+    /** CODEX_HOME/config.toml */
+    configToml: string;
+    /** 网关下发的模型目录,原样写成文件给 model_catalog_json 用 */
+    catalogFile: string;
+    /** 上次成功拉到的 /v1/agents/codex/config */
+    configCache: string;
+}
+export declare function codexPaths(root?: string): CodexPaths;
+/**
+ * 子进程环境里要去掉的变量(依据 Codex 0.167.2 源码):
+ *   - 会换掉配置/状态目录的:CODEX_HOME(我们自己设)、CODEX_SQLITE_HOME(状态库改放别处,
+ *     可能是用户自己的目录);
+ *   - 别的凭证:OPENAI_API_KEY、CODEX_API_KEY(`codex exec` 读它当 API Key 登录)、CODEX_ACCESS_TOKEN;
+ *     我们的 provider 只用 env_key,但有了它们 Codex 会以为已登录官方账号,去做相应的事;
+ *   - 改官方 provider 地址的 OPENAI_BASE_URL(老版本读,0.167.2 只在它的网络代理里用);
+ *   - 改请求形状的:CODEX_INTERNAL_ORIGINATOR_OVERRIDE 会换掉 originator 头和 User-Agent 前缀,
+ *     网关的客户端判定看这两样;
+ *   - 「由某包管理器管理」的标记(CODEX_MANAGED_BY_*、CODEX_MANAGED_PACKAGE_ROOT):会让它提示用
+ *     npm/bun 等升级,更新由启动器管。
+ * 只影响这一次启动的子进程环境,用户自己的 shell 与配置不动。
+ */
+export declare const CODEX_ENV_DROP: readonly string[];
+export interface CodexLaunchInput {
+    baseEnv: NodeJS.ProcessEnv;
+    /** 签名代理的一次性本地 token */
+    localToken: string;
+    /** CODEX_HOME(须已存在,否则 Codex 报错退出) */
+    home: string;
+    /** u1s1 工具服务要的变量(mcpLaunchEnv);不注入时省略 */
+    mcp?: McpLaunchEnv;
+}
+/**
+ * 本机代理地址不走用户的 HTTP(S)_PROXY:0.167.2 实测,设了 HTTP_PROXY / HTTPS_PROXY 又没有 NO_PROXY 时,
+ * Codex 把发往 http://127.0.0.1:<端口>/v1/responses 的请求也交给那个代理(连同本地 token),
+ * 代理不在本机就直接失败。用户原有的 NO_PROXY 条目保留,只补上 127.0.0.1 和 localhost。
+ */
+export declare function withLoopbackNoProxy(value: string | undefined): string;
+export declare function codexLaunchEnv(input: CodexLaunchInput): NodeJS.ProcessEnv;
+/**
+ * 启动器的 -c 覆盖放在用户参数前面:用户自己传的 -c / -m / --profile 照样生效(同名 -c 以后出现的为准)。
+ * @param proxyOrigin 签名代理的 origin,形如 http://127.0.0.1:12345(不带 /v1)
+ */
+export declare function codexLaunchArgs(proxyOrigin: string, userArgs: readonly string[]): string[];
+/**
+ * 启动器管的顶层键:每次启动重写;不在这里的键(包括 Codex 自己写的项目信任)原样保留。
+ * model 每次都写成「用户在 u1s1 config 里定的模型(仍在阵容里时),否则网关默认」:Codex 里用 /model 换的
+ * 模型只管那一次会话,和 u1s1 claude 一致(那边 --settings 的 model 也盖过客户端里 /model 的选择)。
+ */
+export declare const CODEX_MANAGED_KEYS: readonly ["model", "model_provider", "check_for_update_on_startup", "cli_auth_credentials_store", "model_catalog_json"];
+/**
+ * 跟着模型走的顶层键:Codex 的 /model 把它们和 model 一起写进 config.toml。启动器把 model 换掉时
+ * 一并去掉(回到新模型自己的默认),免得为别的模型选的思考强度带到新模型上;model 没变就保留。
+ */
+export declare const CODEX_MODEL_BOUND_KEYS: readonly ["model_reasoning_effort"];
+export interface CodexManagedSettings {
+    model: string | null;
+    /** model_catalog_json 的绝对路径;null = 不写这一项 */
+    catalogFile: string | null;
+    /** u1s1 工具服务怎么拉起;null / 省略 = 不注入(原有的 [mcp_servers.u1s1] 也去掉) */
+    mcp?: CodexMcpServer | null;
+}
+export interface CodexMcpServer {
+    command: string;
+    args: string[];
+    /** 从 Codex 环境转给服务的变量名(Codex 默认只转 HOME、PATH 等少数几个) */
+    envVars: string[];
+}
+export interface RenderedCodexConfig {
+    text: string;
+    /** 原文件里有没法逐行安全改写的写法:原文件要先备份,再整份重写 */
+    replaced: boolean;
+}
+/**
+ * 生成新的 config.toml。保守做法:不解析整份 TOML,只逐行处理我们管的东西——
+ *   - 顶层(第一个表头之前)的受管键整行去掉,换成新值,放在文件最前面;
+ *   - `[model_providers.u1s1]`、`[mcp_servers.u1s1]` 及其子表整段去掉,换成新的放在最后
+ *     (例外:用户对 u1s1 工具的审批选择 `[mcp_servers.u1s1.tools.*]`,注入时跟在新表后面保留);
+ *   - 其余每一行(用户加的键、别的表、注释、Codex 自己写的项目信任等)原样保留,顺序不变。
+ * 遇到没法逐行安全改写的写法(受管键是跨行值、在顶层或 [model_providers] 表里用点号/内联表写我们的
+ * provider)就整份重写,由调用方先把原文件备份。
+ */
+export declare function renderCodexConfig(existing: string | undefined, managed: CodexManagedSettings): RenderedCodexConfig;
+/** 网关 settings.model_catalog:必须是对象才写;CLI 不解析、不改它的内容。 */
+export declare function modelCatalogFromConfig(config: AgentConfig): Record<string, unknown> | undefined;
+/**
+ * 写 model-catalog.json 与 config.toml。返回原 config.toml 被整份重写时的备份路径(给用户一句说明)。
+ */
+export declare function writeCodexConfig(paths: CodexPaths, config: AgentConfig, now?: () => number, mcp?: CodexMcpServer | null, 
+/** 这次启动用的模型(launch.ts 按 u1s1 config 选好);undefined = 网关默认 */
+model?: string | null): string | undefined;
+/** [mcp_servers.u1s1] 的内容:同一个 node、同一份 CLI;只列要转发的变量名。 */
+export declare function codexMcpServer(command?: {
+    command: string;
+    args: string[];
+}, env?: NodeJS.ProcessEnv): CodexMcpServer;
+/**
+ * `u1s1 codex [参数…]`。返回子进程的退出码(启动前就失败返回 1)。
+ * 是否可用完全由网关配置的 enabled 决定(prepareAgentLaunch)。
+ */
+export declare function runCodex(userArgs: string[]): Promise<number>;