@offerpilot/axiomruntime 0.0.1 → 0.0.2

package/README.md

@@ -26,33 +26,34 @@ AI 与维护者使用的英文权威文档位于 `AGENTS.md`、`docs/AI_RUNTIME_
 
 ## 通过 npm 安装
 
-运行环境需要 Node.js `22.19.0` 或更高版本。全局安装后，npm 会把本包注册为 `ai` 命令：
+运行环境需要 Node.js `22.19.0` 或更高版本。先确认版本，再执行全局安装；npm 会把本包注册为 `ai` 命令：
 
 ```bash
+node --version
 npm install --global @offerpilot/axiomruntime
 ai --version
 ai setup
 ```
 
+如果 npm 显示 `EBADENGINE`，说明当前 Node.js 版本不受支持。请先升级到 `22.19.0+`，不要继续使用警告状态下安装的 CLI。
+
 `ai --version` 用于验证 npm 包和命令安装成功；`ai setup` 初始化 Runtime 配置，并可在确认后安装缺失的 Claude Code/Codex。之后可直接运行 `ai`。
 
+可用 root 完成全局安装，但日常执行 `ai` 和常驻服务应使用专用非 root 用户。若仍以 root 启动 Claude，Runtime 会把 `auto`/`bypassPermissions` 安全约束为默认权限、输出告警，并且绝不会传递 Claude Code 禁止 root 使用的 `--dangerously-skip-permissions`。
+
 ## 通过 Homebrew 安装
 
-发布流程会在 npm 发布成功后把 `Formula/axiomruntime.rb` 同步到 `offerpilot/homebrew-tap`。Tap 建立后可使用：
+维护者发布新版本时可直接双击仓库根目录的 `发布.command`，交互选择 npm、Homebrew 或发布条件检查，无需记发布命令。npm 发布成功后，再选择 Homebrew；助手会读取 npm Registry 的真实 tarball 与 SHA256，并把 `Formula/axiomruntime.rb` 同步到 GitLab 项目 `linlangli/axiom`。
+
+用户首次安装需要显式提供 GitLab 地址：
 
 ```bash
-brew tap offerpilot/tap
-brew install axiomruntime
+brew tap linlangli/axiom https://gitlab.com/linlangli/axiom.git
+brew install linlangli/axiom/axiomruntime
 ai --version
 ai setup
 ```
 
-如果 Tap 不托管在 GitHub，需要在首次添加时显式提供公开 Git 地址：
-
-```bash
-brew tap offerpilot/tap <homebrew-tap-public-git-url>
-```
-
 ## 安装开发依赖
 
 运行和开发需要 Node.js `22.19.0` 或更高版本。该下限与锁定依赖的运行时要求一致；Node.js 20 不受支持。
@@ -103,6 +104,8 @@ AI_GATEWAY_SERVER_TOKEN='replace-me' npm run server
 
 默认分支提交通过测试后，GitLab CI 会构建以 commit SHA 标记的镜像，并由锁定当前项目的受保护 Runner（标签 `axiomruntime-prod`）部署到 `154.201.73.41:/opt/AxiomRuntime`。部署只操作 `axiomruntime` Compose 项目；健康检查失败时恢复上一镜像，不清理服务器上的其他容器或镜像。
 
+镜像构建会在一次性 build stage 中编译 `better-sqlite3` 原生 addon，再把裁掉开发依赖后的 production dependency tree 复制到相同 Node.js 版本的最终镜像；最终镜像不包含编译器。
+
 首次部署前，服务器必须已有 `/opt/AxiomRuntime/config/providers.json` 和 `/opt/AxiomRuntime/secrets/server-token`，且容器用户 `10001:10001` 可以读写配置目录。CI 只校验这些文件，不生成或覆盖凭据。
 
 Telegram 容器默认不启动，以免与现有 long polling 进程争抢消息。完成迁移并停止旧 Bot 后，在服务器 `/opt/AxiomRuntime/.env` 中设置：
@@ -130,6 +133,10 @@ ai provider add
 ai provider list
 ai provider edit
 ai provider delete
+ai set codex chatgpt
+ai set codex provider 51talk-cq gpt-5.6-sol
+ai set codex provider 51talk-cq
+ai set codex proxy 127.0.0.1:7890
 ai telegram
 ai telegram list
 ai telegram start --bot ops

package/dist/cli/commands/set.js

@@ -0,0 +1,121 @@
+import { writeLog } from "../../core/logs/log-service.js";
+import { readCache } from "../../core/config/cache-store.js";
+import { listAvailableCodexGptModels, resolveCodexProviderModel, setCodexProvider, setCodexProxy } from "../../core/integrations/codex-provider-config.js";
+import { listProviders } from "../../core/providers/provider-service.js";
+import { promptSelect, promptText } from "../prompts/prompt.js";
+const SET_CODEX_USAGE = "Usage: ai set codex [chatgpt | provider [name] [model-id] | proxy <host:port|url|off>]";
+export async function runSetCommand(args) {
+    const [targetArg, modeArg, providerNameArg, modelArg, ...extra] = args;
+    const target = targetArg ?? "codex";
+    if (target !== "codex") {
+        throw new Error(SET_CODEX_USAGE);
+    }
+    if (extra.length) {
+        throw new Error(SET_CODEX_USAGE);
+    }
+    const mode = await getMode(modeArg);
+    if (mode === "proxy") {
+        if (modelArg)
+            throw new Error(SET_CODEX_USAGE);
+        const proxyValue = providerNameArg ?? await promptText("Codex proxy (host:port, URL, or off)");
+        const result = await setCodexProxy(proxyValue);
+        console.log(result.proxyUrl ? `Codex proxy set to: ${result.proxyUrl}` : "Codex proxy cleared.");
+        console.log(`Updated: ${result.configPath}`);
+        if (!result.environment.applied && result.environment.reason) {
+            console.log(result.environment.reason);
+        }
+        printRestartResult(result.restart);
+        await writeLog({
+            category: "provider",
+            action: "codex_proxy_set",
+            message: result.proxyUrl ? "Codex proxy enabled." : "Codex proxy cleared.",
+            metadata: {
+                enabled: Boolean(result.proxyUrl),
+                desktopEnvironmentApplied: result.environment.applied,
+                restartScheduled: result.restart.scheduled
+            }
+        });
+        return;
+    }
+    if (mode === "chatgpt" && (providerNameArg || modelArg)) {
+        throw new Error("Usage: ai set codex chatgpt");
+    }
+    const selection = mode === "chatgpt"
+        ? { type: "chatgpt" }
+        : { type: "provider", ...await getProviderAndModel(providerNameArg, modelArg) };
+    if (mode === "chatgpt") {
+        console.log("Opening ChatGPT login in your browser...");
+    }
+    const result = await setCodexProvider(selection);
+    console.log(`Codex provider set to: ${result.providerName}`);
+    if (result.model)
+        console.log(`Codex model set to: ${result.model}`);
+    console.log(`Updated: ${result.configPath}`);
+    console.log(`Updated: ${result.authPath}`);
+    printRestartResult(result.restart);
+    await writeLog({
+        category: "provider",
+        action: "codex_provider_set",
+        message: `Codex provider set to ${result.providerName}.`,
+        metadata: {
+            selection: result.selection,
+            provider: result.providerName,
+            providerId: result.providerId,
+            model: result.model,
+            restartScheduled: result.restart.scheduled
+        }
+    });
+}
+async function getMode(value) {
+    if (value === "chatgpt" || value === "provider" || value === "proxy")
+        return value;
+    if (value) {
+        throw new Error(`Unknown Codex setting: ${value}`);
+    }
+    return promptSelect("Set Codex", [
+        { label: "ChatGPT account", value: "chatgpt" },
+        { label: "Configured provider", value: "provider" },
+        { label: "Proxy", value: "proxy" }
+    ]);
+}
+function printRestartResult(restart) {
+    if (restart.scheduled) {
+        console.log(`Restarting ${restart.appPath ?? "Codex app"}...`);
+    }
+    else {
+        console.log(`Restart Codex app manually. ${restart.reason ?? ""}`.trim());
+    }
+}
+async function getProviderAndModel(name, requestedModel) {
+    const [providers, cache] = await Promise.all([listProviders(), readCache()]);
+    return selectCodexProviderAndModel(providers, cache.providers, name, requestedModel);
+}
+export async function selectCodexProviderAndModel(providers, providerCache, name, requestedModel, select = promptSelect) {
+    if (!providers.length) {
+        throw new Error("No providers configured. Run `ai provider add` first.");
+    }
+    if (!name && !providers.some((provider) => providerGptModels(provider.name, providerCache).length)) {
+        throw new Error("No configured provider has available GPT models. Run `ai status` to refresh model lists.");
+    }
+    const providerName = name ?? await select("Select provider for Codex", providers.map((provider) => ({
+        label: `${provider.name} / ${providerGptModels(provider.name, providerCache).length} GPT models`,
+        value: provider.name
+    })));
+    const provider = providers.find((item) => item.name === providerName);
+    if (!provider) {
+        throw new Error(`Provider not found: ${providerName}`);
+    }
+    const availableModels = providerGptModels(provider.name, providerCache);
+    if (!availableModels.length) {
+        resolveCodexProviderModel(provider.name, availableModels);
+    }
+    const model = requestedModel
+        ? resolveCodexProviderModel(provider.name, availableModels, requestedModel)
+        : name
+            ? resolveCodexProviderModel(provider.name, availableModels)
+            : await select(`Select GPT model for ${provider.name}`, availableModels.map((availableModel) => ({ label: availableModel, value: availableModel })));
+    return { provider, model };
+}
+function providerGptModels(providerName, providerCache) {
+    return listAvailableCodexGptModels(providerCache[providerName]?.models ?? []);
+}

package/dist/cli/index.js

@@ -10,6 +10,7 @@ import { runMemoryCommand } from "./commands/memory.js";
 import { runReportCommand } from "./commands/report.js";
 import { runLastCommand, runUseCommand } from "./commands/use.js";
 import { runSessionCommand } from "./commands/session.js";
+import { runSetCommand } from "./commands/set.js";
 import { runSetupCommand } from "./commands/setup.js";
 import { runStatusCommand } from "./commands/status.js";
 import { runTelegramCommand } from "./commands/telegram.js";
@@ -17,6 +18,7 @@ import { runVersionCommand } from "./commands/version.js";
 import { writeLog } from "../core/logs/log-service.js";
 import { promptSelect } from "./prompts/prompt.js";
 import { getCliCommand, registerCliCommand } from "./registry.js";
+import { redactCodexProxyCommandArgs } from "./sanitize-args.js";
 registerBuiltInCommands();
 async function main() {
     const [, , command, ...args] = process.argv;
@@ -52,6 +54,9 @@ async function main() {
     process.exitCode = 1;
 }
 function sanitizeArgs(command, args) {
+    const redactedProxyArgs = redactCodexProxyCommandArgs(command, args);
+    if (redactedProxyArgs)
+        return redactedProxyArgs;
     if (command === "add" && args.length >= 3) {
         return [args[0], args[1], maskSecretArg(args[2])];
     }
@@ -131,7 +136,7 @@ function maskSecretArg(value) {
     return `${value.slice(0, 4)}****${value.slice(-4)}`;
 }
 async function runInteractive() {
-    const interactiveCommandNames = ["setup", "use", "add", "memory", "telegram", "status", "session", "report", "doctor", "log", "context", "help", "last"];
+    const interactiveCommandNames = ["setup", "use", "set", "add", "memory", "telegram", "status", "session", "report", "doctor", "log", "context", "help", "last"];
     const command = await promptSelect("AI Gateway", [
         ...interactiveCommandNames
             .flatMap((name) => {
@@ -250,6 +255,11 @@ function registerBuiltInCommands() {
         description: "use",
         run: (args) => runUseCommand(args)
     });
+    registerCliCommand({
+        name: "set",
+        description: "set Codex provider or proxy",
+        run: (args) => runSetCommand(args)
+    });
     registerCliCommand({
         name: "last",
         description: "last",

package/dist/cli/sanitize-args.js

@@ -0,0 +1,6 @@
+export function redactCodexProxyCommandArgs(command, args) {
+    if (command !== "set" || args[0] !== "codex" || args[1] !== "proxy" || args.length < 3) {
+        return null;
+    }
+    return [args[0], args[1], "[proxy-redacted]", ...args.slice(3)];
+}

package/dist/core/integrations/codex-provider-config.js

@@ -0,0 +1,541 @@
+import { spawn } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import lockfile from "proper-lockfile";
+import { resolveToolCommand } from "../runner/command-resolver.js";
+const LOCK_OPTIONS = {
+    realpath: false,
+    stale: 10_000,
+    update: 5_000,
+    retries: {
+        retries: 100,
+        factor: 1.2,
+        minTimeout: 25,
+        maxTimeout: 500
+    }
+};
+const RESERVED_PROVIDER_IDS = new Set(["openai", "ollama", "lmstudio"]);
+const CODEX_PROXY_ENV_KEYS = [
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+    "ALL_PROXY",
+    "http_proxy",
+    "https_proxy",
+    "all_proxy"
+];
+export async function setCodexProvider(selection, options = {}) {
+    const codexHome = resolveCodexHome(options.codexHome);
+    const configPath = path.join(codexHome, "config.toml");
+    const authPath = path.join(codexHome, "auth.json");
+    await fs.mkdir(codexHome, { recursive: true, mode: 0o700 });
+    const release = await lockfile.lock(configPath, LOCK_OPTIONS);
+    let providerName;
+    let providerId;
+    let model;
+    try {
+        if (selection.type === "chatgpt") {
+            providerName = "ChatGPT";
+            providerId = "openai";
+            model = null;
+            await configureChatGpt(configPath, authPath, codexHome, options.runChatGptLogin);
+        }
+        else {
+            providerName = selection.provider.name;
+            providerId = providerIdForName(selection.provider.name);
+            model = assertCodexGptModel(selection.model);
+            await configureCustomProvider(configPath, authPath, selection.provider, providerId, model);
+        }
+    }
+    finally {
+        await release();
+    }
+    const restart = await (options.scheduleRestart ?? scheduleCodexAppRestart)();
+    return {
+        selection: selection.type,
+        providerName,
+        providerId,
+        model,
+        configPath,
+        authPath,
+        restart
+    };
+}
+export async function setCodexProxy(value, options = {}) {
+    const proxyUrl = normalizeCodexProxy(value);
+    const codexHome = resolveCodexHome(options.codexHome);
+    const configPath = path.join(codexHome, "config.toml");
+    await fs.mkdir(codexHome, { recursive: true, mode: 0o700 });
+    const release = await lockfile.lock(configPath, LOCK_OPTIONS);
+    let environment;
+    try {
+        const snapshot = await snapshotFile(configPath);
+        const current = snapshot?.content.toString("utf8") ?? "";
+        try {
+            if (snapshot || proxyUrl !== null) {
+                await atomicWriteFile(configPath, buildCodexProxyConfig(current, proxyUrl), snapshot?.mode ?? 0o600);
+            }
+            environment = await (options.applyProxyEnvironment
+                ?? ((nextProxyUrl) => applyCodexProxyEnvironment(nextProxyUrl, options.platform)))(proxyUrl);
+        }
+        catch (error) {
+            await restoreFile(configPath, snapshot).catch(() => undefined);
+            throw error;
+        }
+    }
+    finally {
+        await release();
+    }
+    const restart = await (options.scheduleRestart ?? scheduleCodexAppRestart)();
+    return { proxyUrl, configPath, environment, restart };
+}
+export function providerIdForName(name) {
+    const trimmed = name.trim();
+    if (/^[A-Za-z0-9_-]+$/.test(trimmed) && !RESERVED_PROVIDER_IDS.has(trimmed.toLowerCase())) {
+        return trimmed;
+    }
+    const slug = trimmed
+        .normalize("NFKD")
+        .replace(/[^A-Za-z0-9_-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .toLowerCase()
+        .slice(0, 40) || "provider";
+    const digest = createHash("sha256").update(trimmed).digest("hex").slice(0, 8);
+    return `ai-${slug}-${digest}`;
+}
+export function listAvailableCodexGptModels(models) {
+    return [...new Set(models.map((model) => model.trim()).filter(isCodexGptModel))]
+        .sort(compareCodexGptModelsNewestFirst);
+}
+export function resolveCodexProviderModel(providerName, models, requestedModel) {
+    const available = listAvailableCodexGptModels(models);
+    if (!available.length) {
+        throw new Error(`Provider ${providerName} has no available GPT models. Run \`ai status\` to refresh its model list.`);
+    }
+    if (!requestedModel)
+        return available[0];
+    const requested = assertCodexGptModel(requestedModel);
+    const selected = available.find((model) => model.toLowerCase() === requested.toLowerCase());
+    if (!selected) {
+        throw new Error(`GPT model ${requested} is not available for provider ${providerName}. Available: ${available.join(", ")}`);
+    }
+    return selected;
+}
+export function buildCodexProviderConfig(current, provider, providerId, model = provider.model) {
+    if (!provider.baseUrl.trim())
+        throw new Error(`Provider ${provider.name} has no base URL.`);
+    if (!provider.apiKey.trim())
+        throw new Error(`Provider ${provider.name} has no API key.`);
+    const selectedModel = assertCodexGptModel(model);
+    const eol = current.includes("\r\n") ? "\r\n" : "\n";
+    let next = removeProviderTables(current, providerId);
+    next = setTopLevelTomlString(next, "cli_auth_credentials_store", "file");
+    next = setTopLevelTomlString(next, "model_provider", providerId);
+    next = setTopLevelTomlString(next, "model", selectedModel);
+    const table = [
+        `[model_providers.${providerId}]`,
+        `name = ${tomlString(provider.name)}`,
+        `base_url = ${tomlString(provider.baseUrl.trim().replace(/\/+$/, ""))}`,
+        `env_key = ${tomlString("OPENAI_API_KEY")}`,
+        "requires_openai_auth = true",
+        `wire_api = ${tomlString("responses")}`
+    ].join(eol);
+    return `${next.trimEnd()}${eol}${eol}${table}${eol}`;
+}
+export function buildCodexChatGptConfig(current) {
+    let next = setTopLevelTomlString(current, "cli_auth_credentials_store", "file");
+    next = setTopLevelTomlString(next, "model_provider", "openai");
+    return ensureTrailingNewline(next);
+}
+export function normalizeCodexProxy(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new Error("Proxy address is required. Example: 127.0.0.1:7890");
+    }
+    if (["off", "none", "clear", "disable"].includes(trimmed.toLowerCase()))
+        return null;
+    const candidate = /^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(trimmed)
+        ? trimmed
+        : `http://${trimmed}`;
+    let parsed;
+    try {
+        parsed = new URL(candidate);
+    }
+    catch {
+        throw new Error(`Invalid proxy address: ${value}`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error("Codex proxy must use http:// or https://.");
+    }
+    if (!parsed.hostname)
+        throw new Error(`Invalid proxy address: ${value}`);
+    if (parsed.username || parsed.password) {
+        throw new Error("Proxy credentials are not accepted on the command line; use a local unauthenticated proxy endpoint.");
+    }
+    if ((parsed.pathname && parsed.pathname !== "/") || parsed.search || parsed.hash) {
+        throw new Error("Codex proxy must be an origin only, without a path, query, or fragment.");
+    }
+    return `${parsed.protocol}//${parsed.host}`;
+}
+export function buildCodexProxyConfig(current, proxyUrl) {
+    return updateTomlTableStrings(current, "shell_environment_policy.set", Object.fromEntries(CODEX_PROXY_ENV_KEYS.map((key) => [key, proxyUrl])));
+}
+export async function applyCodexProxyEnvironment(proxyUrl, platform = process.platform) {
+    if (platform !== "darwin") {
+        return {
+            applied: false,
+            reason: "Automatic desktop proxy environment updates are currently supported on macOS only."
+        };
+    }
+    const snapshots = new Map();
+    for (const key of CODEX_PROXY_ENV_KEYS) {
+        const result = await runProcess("/bin/launchctl", ["getenv", key]);
+        const previous = result.code === 0 ? result.stdout.replace(/\r?\n$/, "") : "";
+        snapshots.set(key, previous || null);
+    }
+    const changed = [];
+    try {
+        for (const key of CODEX_PROXY_ENV_KEYS) {
+            const args = proxyUrl === null ? ["unsetenv", key] : ["setenv", key, proxyUrl];
+            const result = await runProcess("/bin/launchctl", args);
+            if (result.code !== 0) {
+                throw new Error(`launchctl ${args[0]} failed for ${key}: ${result.stderr.trim() || `exit ${result.code}`}`);
+            }
+            changed.push(key);
+        }
+    }
+    catch (error) {
+        for (const key of changed.reverse()) {
+            const previous = snapshots.get(key);
+            const args = previous === null || previous === undefined
+                ? ["unsetenv", key]
+                : ["setenv", key, previous];
+            await runProcess("/bin/launchctl", args).catch(() => undefined);
+        }
+        throw error;
+    }
+    return { applied: true };
+}
+export async function scheduleCodexAppRestart(options = {}) {
+    const platform = options.platform ?? process.platform;
+    if (platform !== "darwin") {
+        return { scheduled: false, reason: "Automatic Codex app restart is currently supported on macOS only." };
+    }
+    const homeDir = options.homeDir ?? os.homedir();
+    const candidates = options.appCandidates ?? [
+        "/Applications/Codex.app",
+        "/Applications/ChatGPT.app",
+        path.join(homeDir, "Applications/Codex.app"),
+        path.join(homeDir, "Applications/ChatGPT.app")
+    ];
+    const pathExists = options.pathExists ?? fileExists;
+    let appPath;
+    for (const candidate of candidates) {
+        if (await pathExists(candidate)) {
+            appPath = candidate;
+            break;
+        }
+    }
+    if (!appPath) {
+        return { scheduled: false, reason: "Codex.app or ChatGPT.app was not found." };
+    }
+    const appName = path.basename(appPath, ".app");
+    if (!/^[A-Za-z0-9 ._-]+$/.test(appName)) {
+        return { scheduled: false, reason: `Unsupported application name: ${appName}` };
+    }
+    const appleScriptName = appName.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+    const helper = [
+        "const { spawnSync } = require('node:child_process');",
+        `const appPath = ${JSON.stringify(appPath)};`,
+        `const quitScript = ${JSON.stringify(`tell application "${appleScriptName}" to quit`)};`,
+        "setTimeout(() => {",
+        "  spawnSync('/usr/bin/osascript', ['-e', quitScript], { stdio: 'ignore' });",
+        "  setTimeout(() => spawnSync('/usr/bin/open', [appPath], { stdio: 'ignore' }), 1000);",
+        "}, 750);"
+    ].join("\n");
+    (options.spawnDetached ?? defaultSpawnDetached)(process.execPath, ["-e", helper]);
+    return { scheduled: true, appPath };
+}
+async function configureChatGpt(configPath, authPath, codexHome, runner) {
+    const [configSnapshot, authSnapshot] = await Promise.all([
+        snapshotFile(configPath),
+        snapshotFile(authPath)
+    ]);
+    try {
+        const exitCode = await (runner ?? runCodexChatGptLogin)({ codexHome });
+        if (exitCode !== 0) {
+            throw new Error(`ChatGPT login failed with exit code ${exitCode}.`);
+        }
+        await validateChatGptAuth(authPath);
+        await fs.chmod(authPath, 0o600);
+        const currentConfig = configSnapshot?.content.toString("utf8") ?? "";
+        await atomicWriteFile(configPath, buildCodexChatGptConfig(currentConfig), configSnapshot?.mode ?? 0o600);
+    }
+    catch (error) {
+        await Promise.allSettled([
+            restoreFile(configPath, configSnapshot),
+            restoreFile(authPath, authSnapshot)
+        ]);
+        throw error;
+    }
+}
+async function configureCustomProvider(configPath, authPath, provider, providerId, model) {
+    const [configSnapshot, authSnapshot] = await Promise.all([
+        snapshotFile(configPath),
+        snapshotFile(authPath)
+    ]);
+    const currentConfig = configSnapshot?.content.toString("utf8") ?? "";
+    const auth = `${JSON.stringify({ auth_mode: "apikey", OPENAI_API_KEY: provider.apiKey.trim() }, null, 2)}\n`;
+    try {
+        await atomicWriteFile(authPath, auth, 0o600);
+        await atomicWriteFile(configPath, buildCodexProviderConfig(currentConfig, provider, providerId, model), configSnapshot?.mode ?? 0o600);
+    }
+    catch (error) {
+        await Promise.allSettled([
+            restoreFile(configPath, configSnapshot),
+            restoreFile(authPath, authSnapshot)
+        ]);
+        throw error;
+    }
+}
+async function runCodexChatGptLogin({ codexHome }) {
+    const command = resolveToolCommand("codex");
+    if (!command) {
+        throw new Error("Codex CLI not found. Run `ai setup --install-tools` first.");
+    }
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, ["-c", "cli_auth_credentials_store=\"file\"", "login"], {
+            env: { ...process.env, CODEX_HOME: codexHome },
+            stdio: "inherit"
+        });
+        child.once("error", reject);
+        child.once("close", (code, signal) => {
+            if (signal) {
+                reject(new Error(`ChatGPT login was interrupted by ${signal}.`));
+                return;
+            }
+            resolve(code ?? 1);
+        });
+    });
+}
+async function validateChatGptAuth(authPath) {
+    let auth;
+    try {
+        auth = JSON.parse(await fs.readFile(authPath, "utf8"));
+    }
+    catch {
+        throw new Error("ChatGPT login completed without a readable Codex auth.json.");
+    }
+    if (!isRecord(auth) || auth.auth_mode !== "chatgpt" || !isRecord(auth.tokens)) {
+        throw new Error("ChatGPT login did not produce valid Codex credentials.");
+    }
+    if (typeof auth.tokens.access_token !== "string" || typeof auth.tokens.refresh_token !== "string") {
+        throw new Error("ChatGPT login credentials are incomplete.");
+    }
+}
+function setTopLevelTomlString(current, key, value) {
+    const eol = current.includes("\r\n") ? "\r\n" : "\n";
+    const lines = current.split(/\r?\n/);
+    const firstTable = lines.findIndex((line) => /^\s*\[\[?/.test(line));
+    const end = firstTable < 0 ? lines.length : firstTable;
+    const assignment = `${key} = ${tomlString(value)}`;
+    const pattern = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`);
+    let replaced = false;
+    const top = lines.slice(0, end).filter((line) => {
+        if (!pattern.test(line))
+            return true;
+        if (replaced)
+            return false;
+        replaced = true;
+        return true;
+    });
+    if (replaced) {
+        const index = top.findIndex((line) => pattern.test(line));
+        top[index] = assignment;
+    }
+    else {
+        while (top.length && top[top.length - 1] === "")
+            top.pop();
+        top.push(assignment, "");
+    }
+    return [...top, ...lines.slice(end)].join(eol);
+}
+function updateTomlTableStrings(current, tableName, values) {
+    const eol = current.includes("\r\n") ? "\r\n" : "\n";
+    const lines = current.split(/\r?\n/);
+    const tablePattern = new RegExp(`^\\s*\\[${escapeRegExp(tableName)}\\]\\s*(?:#.*)?$`);
+    const tableIndex = lines.findIndex((line) => tablePattern.test(line));
+    const assignments = Object.entries(values)
+        .filter((entry) => entry[1] !== null)
+        .map(([key, value]) => `${key} = ${tomlString(value)}`);
+    if (tableIndex < 0) {
+        if (!assignments.length)
+            return ensureTrailingNewline(current);
+        const prefix = current.trimEnd();
+        const table = [`[${tableName}]`, ...assignments].join(eol);
+        return `${prefix ? `${prefix}${eol}${eol}` : ""}${table}${eol}`;
+    }
+    let tableEnd = lines.length;
+    for (let index = tableIndex + 1; index < lines.length; index += 1) {
+        if (/^\s*\[\[?/.test(lines[index])) {
+            tableEnd = index;
+            break;
+        }
+    }
+    const managedPatterns = Object.keys(values).map((key) => new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`));
+    const body = lines
+        .slice(tableIndex + 1, tableEnd)
+        .filter((line) => !managedPatterns.some((pattern) => pattern.test(line)));
+    while (body.length && body[body.length - 1] === "")
+        body.pop();
+    if (body.length && assignments.length)
+        body.push("");
+    body.push(...assignments);
+    return ensureTrailingNewline([
+        ...lines.slice(0, tableIndex + 1),
+        ...body,
+        ...lines.slice(tableEnd)
+    ].join(eol));
+}
+function removeProviderTables(current, providerId) {
+    const lines = current.split(/\r?\n/);
+    const prefix = `model_providers.${providerId}`;
+    let skip = false;
+    const kept = [];
+    for (const line of lines) {
+        const header = /^\s*\[([^\]]+)\]\s*(?:#.*)?$/.exec(line)?.[1];
+        if (header) {
+            skip = header === prefix || header.startsWith(`${prefix}.`);
+        }
+        if (!skip)
+            kept.push(line);
+    }
+    return kept.join(current.includes("\r\n") ? "\r\n" : "\n");
+}
+async function snapshotFile(filePath) {
+    try {
+        const [content, stat] = await Promise.all([fs.readFile(filePath), fs.stat(filePath)]);
+        return { content, mode: stat.mode & 0o777 };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+async function restoreFile(filePath, snapshot) {
+    if (!snapshot) {
+        await fs.rm(filePath, { force: true });
+        return;
+    }
+    await atomicWriteFile(filePath, snapshot.content, snapshot.mode);
+}
+async function atomicWriteFile(filePath, content, mode) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    const temporaryPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`);
+    try {
+        await fs.writeFile(temporaryPath, content, { mode });
+        await fs.chmod(temporaryPath, mode);
+        await fs.rename(temporaryPath, filePath);
+    }
+    catch (error) {
+        await fs.rm(temporaryPath, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+function resolveCodexHome(explicit) {
+    const value = explicit ?? process.env.CODEX_HOME;
+    return value ? path.resolve(value) : path.join(os.homedir(), ".codex");
+}
+function ensureTrailingNewline(value) {
+    return `${value.trimEnd()}\n`;
+}
+function tomlString(value) {
+    return JSON.stringify(value);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function assertCodexGptModel(model) {
+    const value = model.trim();
+    if (!isCodexGptModel(value)) {
+        throw new Error(`Codex provider model must be a GPT model id starting with \"gpt-\": ${model || "(empty)"}`);
+    }
+    return value;
+}
+function isCodexGptModel(model) {
+    return /^gpt-/i.test(model.trim());
+}
+function compareCodexGptModelsNewestFirst(left, right) {
+    const leftKey = codexGptModelSortKey(left);
+    const rightKey = codexGptModelSortKey(right);
+    const versionLength = Math.max(leftKey.version.length, rightKey.version.length);
+    for (let index = 0; index < versionLength; index += 1) {
+        const difference = (rightKey.version[index] ?? -1) - (leftKey.version[index] ?? -1);
+        if (difference)
+            return difference;
+    }
+    if (leftKey.tier !== rightKey.tier)
+        return rightKey.tier - leftKey.tier;
+    if (leftKey.alias !== rightKey.alias)
+        return rightKey.alias - leftKey.alias;
+    if (leftKey.snapshot !== rightKey.snapshot)
+        return rightKey.snapshot - leftKey.snapshot;
+    return left.localeCompare(right);
+}
+function codexGptModelSortKey(model) {
+    const value = model.toLowerCase();
+    const version = /^gpt-(\d+(?:\.\d+)*)/.exec(value)?.[1]
+        ?.split(".")
+        .map(Number) ?? [];
+    const snapshotMatch = /(?:^|-)(\d{4})-(\d{2})-(\d{2})(?:$|-)/.exec(value);
+    const snapshot = snapshotMatch
+        ? Number(`${snapshotMatch[1]}${snapshotMatch[2]}${snapshotMatch[3]}`)
+        : 0;
+    const tier = /(?:^|-)sol(?:-|$)/.test(value) ? 60
+        : /(?:^|-)pro(?:-|$)/.test(value) ? 50
+            : /^gpt-\d+(?:\.\d+)*(?:-\d{4}-\d{2}-\d{2})?$/.test(value) ? 45
+                : /(?:^|-)codex(?:-|$)/.test(value) ? 40
+                    : /(?:^|-)terra(?:-|$)/.test(value) ? 30
+                        : /(?:^|-)mini(?:-|$)/.test(value) ? 20
+                            : /(?:^|-)luna(?:-|$)/.test(value) ? 10
+                                : /(?:^|-)nano(?:-|$)/.test(value) ? 5
+                                    : 0;
+    return { version, tier, alias: snapshot ? 0 : 1, snapshot };
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function defaultSpawnDetached(command, args) {
+    const child = spawn(command, args, { detached: true, stdio: "ignore" });
+    child.unref();
+}
+function runProcess(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => { stdout += chunk; });
+        child.stderr.on("data", (chunk) => { stderr += chunk; });
+        child.once("error", reject);
+        child.once("close", (code, signal) => {
+            if (signal) {
+                reject(new Error(`${command} was interrupted by ${signal}.`));
+                return;
+            }
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+    });
+}

package/dist/core/runner/claude-permission-policy.js

@@ -0,0 +1,19 @@
+export const CLAUDE_ROOT_PERMISSION_WARNING = "Claude bypass permissions is unavailable while Axiom Runtime runs as root; using default permissions. Run `ai` as a non-root user to enable auto mode.";
+export function getProcessUid() {
+    return typeof process.getuid === "function" ? process.getuid() : null;
+}
+export function isPrivilegedProcess(options = {}) {
+    const uid = options.uid === undefined ? getProcessUid() : options.uid;
+    return uid === 0;
+}
+export function resolveClaudePermissionMode(requestedMode, options = {}) {
+    const privileged = isPrivilegedProcess(options);
+    const constrained = privileged && requestedMode === "bypassPermissions";
+    return {
+        requestedMode,
+        effectiveMode: constrained ? "default" : requestedMode,
+        privileged,
+        constrained,
+        reason: constrained ? "root_bypass_permissions_unsupported" : null
+    };
+}

package/dist/core/runner/engine-registry.js

@@ -1,3 +1,4 @@
+import { resolveClaudePermissionMode } from "./claude-permission-policy.js";
 const runnerEngines = new Map();
 export function registerRunnerEngine(descriptor) {
     runnerEngines.set(descriptor.name, descriptor);
@@ -30,12 +31,13 @@ registerRunnerEngine({
             ANTHROPIC_MODEL: model
         };
     },
-    buildArgs: ({ provider, model, settingsPath }) => {
+    buildArgs: ({ provider, model, settingsPath, uid }) => {
         const args = ["--model", model];
         if (settingsPath) {
             args.push("--settings", settingsPath);
         }
-        if (provider.mode === "auto") {
+        const permission = resolveClaudePermissionMode(provider.mode === "auto" ? "bypassPermissions" : "default", { uid });
+        if (permission.effectiveMode === "bypassPermissions") {
             args.push("--permission-mode", "bypassPermissions");
             args.push("--dangerously-skip-permissions");
         }

package/dist/core/runner/tool-runner.js

@@ -7,6 +7,7 @@ import { writeLog } from "../logs/log-service.js";
 import { isRecord } from "../utils/is-record.js";
 import { resolveToolCommand } from "./command-resolver.js";
 import { getRunnerEngine } from "./engine-registry.js";
+import { CLAUDE_ROOT_PERMISSION_WARNING, resolveClaudePermissionMode } from "./claude-permission-policy.js";
 import { finishSession, startSession } from "../sessions/session-service.js";
 export async function runTool(tool, provider, model, options = {}) {
     await saveLastSelection(tool, provider.name, model);
@@ -15,13 +16,20 @@ export async function runTool(tool, provider, model, options = {}) {
         throw new Error(`Failed to find ${tool} CLI. Run \`ai doctor\` to check local CLI installation.`);
     }
     const engine = getRunnerEngine(tool);
-    const env = buildRunnerEnv(tool, provider, model);
+    const launchPolicy = resolveRunnerLaunchPolicy(tool, provider);
+    if (launchPolicy.warning) {
+        console.warn(`Warning: ${launchPolicy.warning}`);
+    }
+    const effectiveProvider = launchPolicy.provider;
+    const env = buildRunnerEnv(tool, effectiveProvider, model);
     const temporaryFiles = [];
-    const claudeSettingsPath = engine.requiresSettingsFile ? writeTemporaryClaudeSettings(provider) : null;
+    const claudeSettingsPath = engine.requiresSettingsFile
+        ? writeTemporaryClaudeSettings(effectiveProvider, { permissionMode: launchPolicy.claudeSettingsPermissionMode })
+        : null;
     if (claudeSettingsPath)
         temporaryFiles.push(claudeSettingsPath);
-    const args = buildRunnerArgs(tool, provider, model, claudeSettingsPath);
-    const effectiveBaseUrl = getToolBaseUrl(tool, provider);
+    const args = buildRunnerArgs(tool, effectiveProvider, model, claudeSettingsPath);
+    const effectiveBaseUrl = getToolBaseUrl(tool, effectiveProvider);
     await writeLog({
         category: "usage",
         action: "tool_spawn",
@@ -30,7 +38,9 @@ export async function runTool(tool, provider, model, options = {}) {
             tool,
             provider: provider.name,
             model,
-            mode: provider.mode,
+            mode: effectiveProvider.mode,
+            configuredMode: provider.mode,
+            permissionConstraint: launchPolicy.reason,
             baseUrl: effectiveBaseUrl,
             configuredBaseUrl: provider.baseUrl,
             apiKeyFingerprint: getSecretFingerprint(provider.apiKey),
@@ -41,7 +51,7 @@ export async function runTool(tool, provider, model, options = {}) {
     });
     const session = await startSession({
         tool,
-        provider,
+        provider: effectiveProvider,
         model,
         projectPath: process.cwd(),
         fallbackFrom: options.fallbackFrom ?? null
@@ -70,8 +80,27 @@ export function getSecretFingerprint(value) {
         return `len=${value.length}`;
     return `${value.slice(0, 8)}...${value.slice(-6)} len=${value.length}`;
 }
-export function buildRunnerArgs(tool, provider, model, claudeSettingsPath) {
-    return getRunnerEngine(tool).buildArgs({ provider, model, settingsPath: claudeSettingsPath });
+export function buildRunnerArgs(tool, provider, model, claudeSettingsPath, identity = {}) {
+    const launchPolicy = resolveRunnerLaunchPolicy(tool, provider, identity);
+    return getRunnerEngine(tool).buildArgs({
+        provider: launchPolicy.provider,
+        model,
+        settingsPath: claudeSettingsPath,
+        uid: identity.uid
+    });
+}
+export function resolveRunnerLaunchPolicy(tool, provider, identity = {}) {
+    if (tool !== "claude") {
+        return { provider, claudeSettingsPermissionMode: "provider", warning: null, reason: null };
+    }
+    const requestedMode = provider.mode === "auto" ? "bypassPermissions" : "default";
+    const resolution = resolveClaudePermissionMode(requestedMode, identity);
+    return {
+        provider: resolution.constrained ? { ...provider, mode: "ask" } : provider,
+        claudeSettingsPermissionMode: resolution.privileged ? "safeDefault" : "provider",
+        warning: resolution.constrained ? CLAUDE_ROOT_PERMISSION_WARNING : null,
+        reason: resolution.reason
+    };
 }
 const AUTO_PERMISSIONS = {
     defaultMode: "bypassPermissions",
@@ -94,6 +123,11 @@ const READ_ONLY_PERMISSIONS = {
     allow: ["Read", "Glob", "Grep", "WebFetch", "WebSearch"],
     deny: ["Bash", "Edit", "Write", "MultiEdit", "NotebookEdit"]
 };
+const SAFE_DEFAULT_PERMISSIONS = {
+    defaultMode: "default",
+    allow: [],
+    deny: []
+};
 export function writeTemporaryClaudeSettings(provider, options = {}) {
     const userSettingsPath = path.join(os.homedir(), ".claude", "settings.json");
     const settings = readClaudeSettings(userSettingsPath);
@@ -104,7 +138,10 @@ export function writeTemporaryClaudeSettings(provider, options = {}) {
         ANTHROPIC_API_KEY: provider.apiKey,
         ANTHROPIC_BASE_URL: baseUrl
     };
-    if (options.permissionMode === "readOnly") {
+    if (options.permissionMode === "safeDefault") {
+        settings.permissions = { ...SAFE_DEFAULT_PERMISSIONS };
+    }
+    else if (options.permissionMode === "readOnly") {
         settings.permissions = { ...READ_ONLY_PERMISSIONS };
     }
     else if (provider.mode === "auto") {

package/dist/core/status/doctor-service.js

@@ -8,6 +8,7 @@ import { readProviders } from "../config/providers-store.js";
 import { checkProvider, runDeepCheck } from "../models/model-discovery.js";
 import { writeLog } from "../logs/log-service.js";
 import { getKnownCandidates, resolveToolCommand } from "../runner/command-resolver.js";
+import { isPrivilegedProcess } from "../runner/claude-permission-policy.js";
 import { resolveProviderCandidatesForTool } from "../runner/fallback.js";
 import { buildUsageEvent } from "../usage/usage-service.js";
 const MIN_NODE_VERSION = "22.19.0";
@@ -16,6 +17,7 @@ export async function runDoctor(options = {}) {
     const fix = options.fix ?? false;
     const checkProviders = options.checkProviders ?? true;
     checkNodeVersion(items);
+    checkExecutionUser(items);
     if (options.checkNativeDependencies ?? true) {
         await checkNativeDependencies(items);
     }
@@ -26,6 +28,21 @@ export async function runDoctor(options = {}) {
     checkCommand("Local CLIs", "codex", items);
     return items;
 }
+function checkExecutionUser(items) {
+    const item = getExecutionUserDoctorItem();
+    if (item)
+        items.push(item);
+}
+export function getExecutionUserDoctorItem(identity = {}) {
+    if (!isPrivilegedProcess(identity))
+        return null;
+    return {
+        group: "Execution User",
+        status: "warn",
+        message: "Axiom Runtime is running as root; Claude auto/bypass permission mode is unavailable and will be constrained to default permissions.",
+        suggestion: "Install globally as root if required, but run `ai` and long-lived services with a dedicated non-root account."
+    };
+}
 export async function runDeepDoctor(tool = "codex", options = {}) {
     const items = await runDoctor(options);
     try {

package/dist/telegram/bot-registry.js

@@ -3,6 +3,7 @@ import fsPromises from "node:fs/promises";
 import path from "node:path";
 import { getConfigRoot, getTelegramBotConfigPath, getTelegramBotDbPath, getTelegramBotDir, getTelegramBotLogPath, getTelegramBotPidPath, getTelegramConfigPath, getTelegramDbPath } from "../core/config/paths.js";
 const BOT_NAME_RE = /^[a-z0-9]([a-z0-9_-]*[a-z0-9])?$/;
+const LEGACY_MIGRATION_MARKER = ".telegram-legacy-migrated";
 export function isValidBotName(name) {
     return BOT_NAME_RE.test(name) && name.length <= 32;
 }
@@ -42,13 +43,19 @@ export async function migrateLegacyConfig() {
     const legacyPath = getTelegramConfigPath();
     if (!fs.existsSync(legacyPath))
         return;
-    if (botExists("default"))
+    if (fs.existsSync(getLegacyMigrationMarkerPath()))
         return;
     const dir = getTelegramBotDir();
     await fsPromises.mkdir(dir, { recursive: true });
-    await fsPromises.copyFile(legacyPath, getTelegramBotConfigPath("default"));
+    if (!botExists("default")) {
+        await fsPromises.copyFile(legacyPath, getTelegramBotConfigPath("default"));
+    }
+    await markLegacyMigrationComplete();
 }
 export async function removeBotFiles(name, configuredDbPath) {
+    if (name === "default") {
+        await markLegacyMigrationComplete();
+    }
     const managedConfiguredDbPath = configuredDbPath && isManagedConfigPath(configuredDbPath)
         ? path.resolve(configuredDbPath)
         : undefined;
@@ -61,8 +68,7 @@ export async function removeBotFiles(name, configuredDbPath) {
         getTelegramBotConfigPath(name),
         getTelegramBotPidPath(name),
         getTelegramBotLogPath(name),
-        ...[...dbPaths].flatMap((dbPath) => [dbPath, `${dbPath}-shm`, `${dbPath}-wal`]),
-        ...(name === "default" ? [getTelegramConfigPath()] : [])
+        ...[...dbPaths].flatMap((dbPath) => [dbPath, `${dbPath}-shm`, `${dbPath}-wal`])
     ];
     for (const p of paths) {
         try {
@@ -78,3 +84,10 @@ function isManagedConfigPath(filePath) {
     const relative = path.relative(getConfigRoot(), path.resolve(filePath));
     return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
 }
+function getLegacyMigrationMarkerPath() {
+    return path.join(getConfigRoot(), LEGACY_MIGRATION_MARKER);
+}
+async function markLegacyMigrationComplete() {
+    await fsPromises.mkdir(getConfigRoot(), { recursive: true });
+    await fsPromises.writeFile(getLegacyMigrationMarkerPath(), "completed\n", { mode: 0o600 });
+}

package/dist/telegram/engine/claude-engine.js

@@ -3,13 +3,15 @@ import { createJsonLineAccumulator, extractJsonLines, spawnCapture, stripAnsi, t
 import { requiresDangerousConfirmation } from "../interaction/approval.js";
 import { writeTelegramLog } from "../log.js";
 import { isRecord } from "../../core/utils/is-record.js";
+import { CLAUDE_ROOT_PERMISSION_WARNING, resolveClaudePermissionMode } from "../../core/runner/claude-permission-policy.js";
 export class ClaudeEngine {
     name = "claude";
     processes = new Map();
     controllers = new Map();
     async execute(params) {
-        const permissionMode = params.permissionMode ?? "default";
-        const runtime = await prepareEngineRuntime("claude", params.providerName, params.modelName, permissionMode);
+        const requestedPermissionMode = params.permissionMode ?? "default";
+        const runtime = await prepareEngineRuntime("claude", params.providerName, params.modelName, requestedPermissionMode);
+        const permissionMode = runtime.claudePermission?.effectiveMode ?? requestedPermissionMode;
         const controller = new AbortController();
         this.controllers.set(params.chatId, controller);
         const signal = params.signal ?? controller.signal;
@@ -29,11 +31,25 @@ export class ClaudeEngine {
             resume: params.resume,
             allowedTools: params.allowedTools
         });
-        await params.onProgress?.({ phase: "thinking", message: "Claude started" });
+        const permissionWarning = runtime.claudePermission?.constrained ? CLAUDE_ROOT_PERMISSION_WARNING : null;
+        await params.onProgress?.({ phase: "thinking", message: permissionWarning ?? "Claude started" });
+        if (permissionWarning) {
+            await writeTelegramLog({
+                level: "warn",
+                action: "claude_permission_constrained",
+                message: permissionWarning,
+                metadata: { requestedPermissionMode, effectivePermissionMode: permissionMode, reason: runtime.claudePermission?.reason }
+            });
+        }
         await writeTelegramLog({
             action: "claude_start",
             message: `Starting Claude for Telegram chat ${params.chatId}`,
-            metadata: { ...summarizeRuntime(runtime.provider, runtime.model, "claude"), cwd: params.cwd }
+            metadata: {
+                ...summarizeRuntime(runtime.provider, runtime.model, "claude"),
+                cwd: params.cwd,
+                requestedPermissionMode,
+                effectivePermissionMode: permissionMode
+            }
         });
         try {
             const progressParser = createJsonLineAccumulator((event) => handleClaudeProgressEvent(event, params.onProgress));
@@ -89,7 +105,8 @@ export class ClaudeEngine {
     }
 }
 export function buildClaudeArgs(options) {
-    const permissionMode = options.permissionMode === "readOnly" ? "default" : options.permissionMode;
+    const resolution = resolveClaudePermissionMode(options.permissionMode, { uid: options.uid });
+    const permissionMode = resolution.effectiveMode === "readOnly" ? "default" : resolution.effectiveMode;
     const args = [
         "-p",
         options.prompt,
@@ -111,7 +128,7 @@ export function buildClaudeArgs(options) {
     if (options.allowedTools?.length) {
         args.push("--allowedTools", options.allowedTools.join(","));
     }
-    if (options.permissionMode === "bypassPermissions") {
+    if (resolution.effectiveMode === "bypassPermissions") {
         args.push("--dangerously-skip-permissions");
     }
     if (options.permissionMode === "readOnly") {

package/dist/telegram/engine/engine-utils.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { resolveExactProviderForTool, resolveProviderForTool } from "../../core/runner/fallback.js";
 import { buildRunnerEnv, cleanupTemporaryFiles, getToolBaseUrl, writeTemporaryClaudeSettings } from "../../core/runner/tool-runner.js";
+import { resolveClaudePermissionMode } from "../../core/runner/claude-permission-policy.js";
 import { resolveToolCommand } from "../../core/runner/command-resolver.js";
 export async function prepareEngineRuntime(tool, providerName, modelName, permissionMode) {
     // Telegram resolves and orders fallback candidates before invoking an
@@ -13,17 +14,27 @@ export async function prepareEngineRuntime(tool, providerName, modelName, permis
     if (!command) {
         throw new Error(`Failed to find ${tool} CLI. Run \`ai doctor\` to check local CLI installation.`);
     }
+    const claudePermission = tool === "claude"
+        ? resolveClaudePermissionMode(permissionMode ?? "default")
+        : null;
+    const effectiveProvider = claudePermission?.constrained ? { ...provider, mode: "ask" } : provider;
     const env = {
-        ...buildRunnerEnv(tool, provider, model),
+        ...buildRunnerEnv(tool, effectiveProvider, model),
         AI_GATEWAY_SOURCE: "telegram"
     };
     const temporaryFiles = [];
     const claudeSettingsPath = tool === "claude"
-        ? writeTemporaryClaudeSettings(provider, { permissionMode: permissionMode === "readOnly" ? "readOnly" : "provider" })
+        ? writeTemporaryClaudeSettings(provider, {
+            permissionMode: permissionMode === "readOnly"
+                ? "readOnly"
+                : claudePermission?.privileged
+                    ? "safeDefault"
+                    : "provider"
+        })
         : null;
     if (claudeSettingsPath)
         temporaryFiles.push(claudeSettingsPath);
-    return { provider, model, env, command, temporaryFiles, claudeSettingsPath };
+    return { provider, model, env, command, temporaryFiles, claudeSettingsPath, claudePermission };
 }
 export function cleanupRuntime(runtime) {
     cleanupTemporaryFiles(runtime.temporaryFiles);

package/docs/USAGE.html

@@ -458,13 +458,16 @@
         <section id="install" class="panel">
           <h2>通过 npm 安装</h2>
           <div class="detail-body">
-            <pre>npm install --global @offerpilot/axiomruntime
+            <pre>node --version
+npm install --global @offerpilot/axiomruntime
 ai --version
 ai setup</pre>
             <p>npm 包名是 <code>@offerpilot/axiomruntime</code>，安装后注册的可执行命令是 <code>ai</code>。需要 Node.js <code>22.19.0+</code>。</p>
+            <p>如果 npm 显示 <code>EBADENGINE</code>，请先升级 Node.js 再重新安装，不要继续使用警告状态下安装的 CLI。</p>
             <p><code>ai --version</code> 无副作用地验证安装；<code>ai setup</code> 初始化 Runtime，并可在确认后安装缺失的 Claude Code/Codex。</p>
-            <pre>brew tap offerpilot/tap
-brew install axiomruntime
+            <p>全局安装可以由 root 完成，但日常执行和常驻服务应使用专用非 root 用户。root 下请求 Claude <code>auto</code>/<code>bypassPermissions</code> 时，Runtime 会安全约束为默认权限并告警，不会传递 <code>--dangerously-skip-permissions</code>。</p>
+            <pre>brew tap linlangli/axiom https://gitlab.com/linlangli/axiom.git
+brew install linlangli/axiom/axiomruntime
 ai --version
 ai setup</pre>
             <p>Homebrew Formula 复用同版本 npm tarball并校验 SHA256，固定使用 Homebrew <code>node@22</code>。非 GitHub Tap 首次添加时需提供公开 Git URL。</p>
@@ -534,6 +537,12 @@ ai setup</pre>
                 <td>指定 provider 和模型启动工具。</td>
                 <td>provider 不可用时按 level 降级。</td>
               </tr>
+              <tr data-search="set codex chatgpt login oauth provider proxy config auth restart app">
+                <td><span class="group-label">使用</span></td>
+                <td><code class="cmd">ai set codex chatgpt</code><br /><code class="cmd">ai set codex provider 51talk-cq gpt-5.6-sol</code><br /><code class="cmd">ai set codex provider 51talk-cq</code><br /><code class="cmd">ai set codex provider</code><br /><code class="cmd">ai set codex proxy 127.0.0.1:7890</code></td>
+                <td>持久切换 Codex App 的 ChatGPT 账号、已添加 provider 或 HTTP proxy。</td>
+                <td>一致更新配置与必要环境，成功后重启 app。</td>
+              </tr>
               <tr data-search="last resume previous selection">
                 <td><span class="group-label">使用</span></td>
                 <td><code class="cmd">ai last</code></td>
@@ -556,7 +565,7 @@ ai setup</pre>
                 <td><span class="group-label">Provider</span></td>
                 <td><code class="cmd">ai provider edit</code><br /><code class="cmd">ai provider edit 51talk</code></td>
                 <td>修改 name、baseUrl、凭证、mode、level、model。</td>
-                <td>凭证写入 SecretStore，配置只保存 apiKeyRef；编辑时不回显原值。</td>
+                <td>当前 apiKey 以明文保存在 providers.json，编辑时会回显当前值。SecretStore + apiKeyRef 是目标态，尚未实现。</td>
               </tr>
               <tr data-search="provider delete remove fallback">
                 <td><span class="group-label">Provider</span></td>
@@ -628,13 +637,35 @@ ai use codex 51talk gpt-5.5</pre>
                 <ul>
                   <li>provider 不可用时按 <code>level</code> 自动降级。</li>
                   <li>Claude Code 使用临时 <code>--settings</code> 注入环境变量，不修改用户 settings。</li>
-                  <li>Codex 使用本次子进程的 <code>-c model_provider=...</code> 固定所选 provider，并通过 <code>env_key = "OPENAI_API_KEY"</code> 使用 AI Gateway 注入的 Key；不会修改 Codex 全局认证或配置。</li>
-                  <li>provider 的 <code>mode</code> 为 <code>auto</code> 时，Claude Code 会追加 <code>--dangerously-skip-permissions</code>；<code>ask</code> 模式不会追加，并会在启动前确认。</li>
+                  <li><code>ai use codex</code> 使用本次子进程的 <code>-c model_provider=...</code> 固定所选 provider，并通过 <code>env_key = "OPENAI_API_KEY"</code> 使用 AI Gateway 注入的 Key；不会修改 Codex 全局认证或配置。</li>
+                  <li>provider 的 <code>mode</code> 为 <code>auto</code> 时，非 root 执行 Claude Code 会追加 <code>--dangerously-skip-permissions</code>；<code>ask</code> 模式不会追加，并会在启动前确认。root 下请求 <code>auto</code> 会被安全约束为默认权限，临时 settings 中继承的 bypass 配置也会被清除。</li>
                   <li>OpenAI 兼容地址用于 Codex 时会使用 <code>/v1</code>，用于 Claude 时会去掉 <code>/v1</code>。</li>
                   <li>日志只记录 Key 指纹，不记录完整 API Key。</li>
                 </ul>
               </div>
             </div>
+            <details open>
+              <summary>持久设置 Codex App provider</summary>
+              <div class="detail-body">
+                <pre>ai set codex chatgpt
+ai set codex provider 51talk-cq gpt-5.6-sol
+ai set codex provider 51talk-cq
+ai set codex provider
+ai set codex proxy 127.0.0.1:7890
+ai set codex proxy off</pre>
+                <ul>
+                  <li><code>chatgpt</code> 调用 <code>codex login</code> 打开浏览器，并在成功后选择内建 <code>model_provider = "openai"</code>。</li>
+                  <li><code>provider name model-id</code> 显式选择该 provider 已探测的 <code>gpt-*</code> 模型；只给 provider 时自动选最新 GPT。</li>
+                  <li><code>provider</code> 不带名称时依次交互选择已添加的 provider 和 GPT 模型；没有可用 GPT 时提示运行 <code>ai status</code>，不修改配置。</li>
+                  <li>自动选择先比较 GPT 数字版本，同版本优先 <code>sol</code>、<code>pro</code>、alias、<code>codex</code>、<code>terra</code>、<code>mini</code>、<code>luna</code>、<code>nano</code>，并优先滚动 alias。API Key 只写入 mode <code>0600</code> 的 <code>auth.json</code>。</li>
+                  <li>原有 project、MCP、plugin、feature 设置会保留；任一步失败会恢复原 <code>config.toml</code> 和 <code>auth.json</code>。</li>
+                  <li>切换自定义 provider 会替换当前 ChatGPT token；切回 ChatGPT 时需重新登录。</li>
+                  <li>成功后 macOS 会重启 <code>Codex.app</code> 或当前名称的 <code>ChatGPT.app</code>；无法自动重启时按提示手动操作。</li>
+                  <li><code>proxy</code> 把裸 <code>host:port</code> 规范化为 HTTP origin，只更新 <code>shell_environment_policy.set</code> 的大小写 HTTP(S)/ALL proxy keys；<code>off</code> 清除这些 managed keys，不修改 <code>auth.json</code>。</li>
+                  <li>Proxy URL 禁止包含账号密码、path、query 或 fragment，command usage log 会整体脱敏。macOS 会同步当前登录会话的 user launchd environment；失败时恢复原 config 且不重启，注销或重启 macOS 后需重新运行本命令。</li>
+                </ul>
+              </div>
+            </details>
           </section>
 
           <section id="memory" class="panel">
@@ -712,7 +743,7 @@ ai telegram status --all</pre>
                   <li><code>--bot=&lt;name&gt;</code> 与 <code>--bot &lt;name&gt;</code> 等价。旧位置参数写法继续兼容；新脚本推荐显式指定 <code>--bot</code> 或 <code>--all</code>。</li>
                   <li>裸 <code>ai telegram</code> 会先选操作再列出 Bot；生命周期菜单可选 <code>all bots</code>，删除菜单会二次确认。带 <code>--bot</code> 进入交互菜单时会跳过 Bot 选择。</li>
                   <li><code>edit</code> 交互式编辑指定 Bot；<code>delete</code> 先停止目标 Bot，再删除该 Bot 的 config、PID、log 和 SQLite 文件。旧 <code>remove</code> 是兼容别名。</li>
-                  <li>删除迁移得到的 <code>default</code> Bot 时，同时清理 legacy <code>telegram.json</code> 与数据库，避免后续迁移重新创建绑定。</li>
+                  <li>legacy <code>telegram.json</code> 首次会自动迁移为命名 Bot <code>default</code>；删除 <code>default</code> 后，列表、生命周期命令和 Bot 服务不会再从 legacy 配置重建它。无目标 <code>ai telegram config</code> 仍可管理 legacy global config。</li>
                   <li><code>config set ... --bot &lt;name&gt;</code> 只修改指定 Bot，不影响全局或其他 Bot；token 不会出现在命令日志或终端输出中。</li>
                   <li>命名 Bot 的配置、PID、日志和会话保存在 <code>~/.ai-gateway/telegram/bots/&lt;name&gt;.json|.pid|.log|.sqlite</code>。</li>
                   <li>为保持兼容，存在命名 Bot 时，无目标 <code>start</code>、<code>stop</code>、<code>status</code> 仍作用于全部命名 Bot。</li>
@@ -809,7 +840,8 @@ ai session clear</pre>
                 <pre>~/.ai-gateway/providers.json
 ~/.ai-gateway/memory.json
 ~/.ai-gateway/model-pricing.json</pre>
-                <p><code>providers.json</code> 保存聊天 provider 与 <code>apiKeyRef</code>；<code>memory.json</code> 保存记忆检索 embedding 模型与 secret ref；实际凭证进入 SecretStore。<code>model-pricing.json</code> 保存美元 / 百万 token 的模型价格。</p>
+                <p><code>providers.json</code> 保存聊天 provider；<code>memory.json</code> 保存记忆检索 embedding 模型。<code>model-pricing.json</code> 保存美元 / 百万 token 的模型价格。</p>
+                <p><strong>注意：</strong>这两个文件当前都以明文保存 <code>apiKey</code>。请限制文件权限并且不要提交到仓库。凭证改由 SecretStore 管理、配置只留 <code>apiKeyRef</code> 是目标架构，尚未实现。</p>
               </div>
             </details>
             <details>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@offerpilot/axiomruntime",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "CLI-first foundation for an enterprise AI Runtime with provider routing and governed execution.",
   "homepage": "https://gitlab.com/linlangli/agent-router",
   "repository": {
@@ -22,10 +22,11 @@
     "telegram:service": "node --enable-source-maps dist/telegram/supervisor.js",
     "test": "npm run build && node --test test/*.test.js",
     "release": "node scripts/release.js",
-    "release:current": "node scripts/release.js --current",
-    "release:check": "npm test && npm run homebrew:check",
+    "release:current": "node scripts/release.js --npm",
+    "release:check": "npm test && npm pack --dry-run",
     "homebrew:update": "node scripts/update-homebrew-formula.js --write",
     "homebrew:check": "node scripts/update-homebrew-formula.js",
+    "homebrew:publish": "node scripts/release.js --homebrew",
     "prepublishOnly": "npm run release:check"
   },
   "files": [
@@ -47,11 +48,11 @@
     "typescript": "^5.8.0"
   },
   "dependencies": {
-    "better-sqlite3": "^12.11.1",
+    "better-sqlite3": "^13.0.2",
     "gpt-tokenizer": "^3.4.0",
     "grammy": "^1.44.0",
     "https-proxy-agent": "^9.1.0",
     "proper-lockfile": "^4.1.2",
-    "undici": "^8.7.0"
+    "undici": "^8.10.0"
   }
 }