@yhong91/cpac 0.1.0 → 0.1.2

package/README.md

@@ -2,7 +2,7 @@
 
 CPAC 将 Codex 和 Claude Code 接入远端 CLIProxyAPI（CPA）：
 
-- **Codex**：注入模型目录和 provider，并可逐字节恢复原配置。
+- **Codex**：注入模型目录和 loopback 网关，保留内置 `openai` provider，并可逐字节恢复原配置。
 - **Claude Code**：通过临时环境变量启动，不修改 Claude Code 配置。
 
 实现基于 TypeScript + Node.js，运行时零依赖。
@@ -110,7 +110,7 @@ ANTHROPIC_AUTH_TOKEN=<CPA_API_KEY>
 
 同时清除可能覆盖网关选择的 `ANTHROPIC_API_KEY` 和 Claude Code 云 provider 环境变量。它不会修改 `~/.claude/`，并原样返回 Claude Code 的退出码。
 
-> CPA 服务端必须支持 Claude Code 使用的 Anthropic Messages API（`/v1/messages`）。CPAC 不负责协议转换，也不启动本地代理。
+> CPA 服务端必须支持 Claude Code 使用的 Anthropic Messages API（`/v1/messages`）。Claude 路径直接连接远端 CPA；CPAC 不负责协议转换。
 
 ### Codex
 
@@ -126,15 +126,45 @@ cpac inject
 cpac status
 ```
 
+`status` 列出所有支持的 agent 及当前状态：
+
+```text
+codex: injected proxy=http://127.0.0.1:10101/v1 sha256=...
+claude: ready
+pi: ready
+```
+
+- **codex**：`native`（未注入）、`injected`（已注入，附代理地址和配置摘要）、`injected (loopback proxy stopped)` 或 `injected (config missing)`
+- **claude**：`ready`（密钥已配置）或 `not configured`
+- **pi**：`ready`（密钥已配置）或 `not configured`
+
 恢复注入前的原配置：
 
 ```bash
 cpac restore
 ```
 
-`inject` 从 `/v1/models?client_version=1` 获取 Codex rich catalog，将根级 `model_provider`、`model_catalog_json` 指向 CPA，并追加 `[model_providers.cpac_cpa]`。其他用户 TOML 内容会保留；若已有同名 provider 且没有 CPAC state，CPAC 会拒绝接管。
+`inject` 从远端 `/v1/models?client_version=1` 获取 Codex rich catalog，并启动只监听 `127.0.0.1` 的轻量转发代理。Codex 配置保留内置 `openai` provider，只写入根级 `model_catalog_json` 和：
+
+```toml
+openai_base_url = "http://127.0.0.1:10101/v1"
+```
+
+Codex App/CLI 发给本地代理的 ChatGPT bearer 不会转发到 CPA；代理会改用 `CPA_API_KEY`，并将请求和流式响应原样转发到远端 CPA。这保留了 Codex App 的原生 `openai` provider 身份、历史和账号相关界面。已有用户自定义根级 `openai_base_url` 或非 `openai` 的活动 `model_provider` 时，CPAC 会拒绝覆盖。
 
-第一次注入时，原文件按原始 bytes 备份到 `state_dir/config.toml.backup`。重复注入不会覆盖首次备份，并会保留 CPAC 管理字段之外的用户编辑。`restore` 按原 mode 逐字节恢复首次备份；若原文件不存在，则删除注入创建的 `config.toml`。
+Codex App 的长驻 `app-server` 可能缓存旧目录。`inject` 会删除 `models_cache.json`；如果选择器仍未更新，请重启 Codex App。
+
+第一次注入时，原文件按原始 bytes 备份到 `state_dir/config.toml.backup`。重复注入不会覆盖首次备份，并会保留 CPAC 管理字段之外的用户编辑。`restore` 按原 mode 逐字节恢复首次备份、关闭 CPAC loopback 代理；若原文件不存在，则删除注入创建的 `config.toml`。
+
+loopback 代理是 detached 用户进程，不安装系统服务。机器重启或进程意外退出后，`cpac status` 会报告 `loopback proxy stopped`；重新执行 `cpac inject` 即可恢复。
+
+需要由现有进程管理器监督时，可使用前台入口：
+
+```bash
+cpac proxy
+```
+
+它复用当前注入记录的端口和实例身份；没有活动注入时会拒绝启动。
 
 默认路径：
 
@@ -171,6 +201,7 @@ CPA_BASE_URL='https://cpa.example.com' cpac claude
   "cpa_url": "https://cpa.example.com",
   "api_key_env": "CPA_API_KEY",
   "codex_config": "~/.codex/config.toml",
+  "codex_proxy_port": 10101,
   "state_dir": "~/.cpac"
 }
 ```
@@ -180,6 +211,7 @@ CPA_BASE_URL='https://cpa.example.com' cpac claude
 - `cpa_url`：可选，绝对 `http(s)` URL，可带或不带 `/v1`
 - `api_key_env`：可选，密钥环境变量名，默认 `CPA_API_KEY`
 - `codex_config`：可选，Codex 配置路径
+- `codex_proxy_port`：可选，本地 Codex 转发端口，默认 `10101`；设为 `0` 时自动选择空闲端口
 - `state_dir`：可选，CPAC state 路径
 
 使用自定义配置：
@@ -198,6 +230,7 @@ export CPAC_CONFIG=/path/to/cpac.json
 ## 安全行为
 
 - API key 不写入 CPAC JSON、Codex 配置、备份、state、catalog 或日志。
+- Codex loopback 代理仅监听 `127.0.0.1`，拒绝非本地浏览器 Origin，并在内存中用 CPA key 替换入站 Authorization。
 - 引导输入不回显，写入 shell 时会正确引用特殊字符。
 - shell 启动文件和 Codex 配置均通过同目录临时文件原子替换。
 - CPA 请求失败、catalog 无效或 key 缺失时，首次注入不会修改 Codex 配置。
@@ -218,7 +251,7 @@ npm run pack:check
 
 ## npm 发布
 
-`.github/workflows/publish.yml` 在推送 `v*` tag 或手动触发时执行测试、类型检查、构建并发布到 npm。tag 发布会校验 tag 必须等于 `v` 加 `package.json` 的版本，例如 `v0.1.0`。
+`.github/workflows/publish.yml` 在推送到 `main` 或手动触发时执行测试、类型检查、构建并发布到 npm。发布前会确认 `package.json` 中的版本尚未存在；因此每次计划发布的 push 都必须先提升版本。普通 PR 仅运行 CI。
 
 首次发布前：
 
@@ -230,8 +263,12 @@ npm run pack:check
 正常发布新版本：
 
 ```bash
-npm version patch   # 或 minor / major
-git push --follow-tags
+npm version patch --no-git-tag-version   # 或 minor / major
+git add package.json package-lock.json
+git commit -m 'Release 0.1.1'
+git push
 ```
 
+也可以手工修改并提交两个版本文件。push 到 `main` 后 Action 自动发布；若忘记提升版本，发布 workflow 会明确失败，不会覆盖 npm 已发布版本。
+
 仓库当前为 private，因此 npm Trusted Publishing 可以使用，但 npm 不会为发布包生成 provenance。

package/cpac.example.json

@@ -1,4 +1,5 @@
 {
   "cpa_url": "https://cpa.example.com",
-  "api_key_env": "CPA_API_KEY"
+  "api_key_env": "CPA_API_KEY",
+  "codex_proxy_port": 10101
 }

package/dist/cpac.js

@@ -1,24 +1,43 @@
 #!/usr/bin/env node
 import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, rmdirSync, rmSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
 import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
+import { createServer, request as httpRequest, } from "node:http";
+import { request as httpsRequest } from "node:https";
 import { homedir, tmpdir } from "node:os";
 import { dirname, isAbsolute, join, parse, relative, resolve } from "node:path";
-import { pathToFileURL } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { createInterface } from "node:readline/promises";
 import { Writable } from "node:stream";
 export const PROVIDER = "cpac_cpa";
 const DEFAULT_CPA_URL = "https://cpa.vibetime.cc";
+const DEFAULT_CODEX_PROXY_PORT = 10101;
 const MAX_CATALOG_BYTES = 16 * 1024 * 1024;
 const CONFIG_KEYS = new Set([
     "cpa_url",
     "api_key_env",
     "codex_config",
+    "codex_proxy_port",
     "state_dir",
 ]);
-const STATE_KEYS = new Set(["config_path", "config_existed", "config_mode"]);
+const REQUIRED_STATE_KEYS = new Set([
+    "config_path",
+    "config_existed",
+    "config_mode",
+]);
+const STATE_KEYS = new Set([
+    ...REQUIRED_STATE_KEYS,
+    "proxy_id",
+    "proxy_fingerprint",
+    "proxy_pid",
+    "proxy_port",
+]);
 const STATE_FILES = ["state.json", "config.toml.backup", "codex-models.json"];
-const ROOT_KEY = /^\s*(?:model_provider|"model_provider"|'model_provider'|model_catalog_json|"model_catalog_json"|'model_catalog_json')\s*=/;
+const MODEL_PROVIDER_KEY = /^\s*(?:model_provider|"model_provider"|'model_provider')\s*=/;
+const MODEL_CATALOG_KEY = /^\s*(?:model_catalog_json|"model_catalog_json"|'model_catalog_json')\s*=/;
+const OPENAI_BASE_URL_KEY = /^\s*(?:openai_base_url|"openai_base_url"|'openai_base_url')\s*=/;
+const ROOT_KEY = new RegExp(`(?:${MODEL_PROVIDER_KEY.source}|${MODEL_CATALOG_KEY.source}|${OPENAI_BASE_URL_KEY.source})`);
+const MANAGED_MARKER = "# CPAC managed; run CPAC 'restore' to restore the original file.";
 let atomicSequence = 0;
 export class CPACError extends Error {
 }
@@ -94,6 +113,12 @@ export function loadConfig(path, useDefaultsIfMissing = false) {
         (typeof value.state_dir !== "string" || !value.state_dir.trim())) {
         throw new CPACError("state_dir must be a non-empty string");
     }
+    const codexProxyPort = value.codex_proxy_port ?? DEFAULT_CODEX_PROXY_PORT;
+    if (!Number.isInteger(codexProxyPort) ||
+        codexProxyPort < 0 ||
+        codexProxyPort > 65535) {
+        throw new CPACError("codex_proxy_port must be an integer from 0 to 65535");
+    }
     const codexHome = expandUserPath(process.env.CODEX_HOME?.trim() || join(homedir(), ".codex"));
     const codexConfig = resolve(expandUserPath(value.codex_config ||
         join(codexHome, "config.toml")));
@@ -108,6 +133,7 @@ export function loadConfig(path, useDefaultsIfMissing = false) {
         cpa_url: cpaUrl,
         api_key_env: apiKeyEnv,
         codex_config: codexConfig,
+        codex_proxy_port: codexProxyPort,
         state_dir: stateDir,
     };
 }
@@ -245,6 +271,7 @@ function stripManagedConfig(content) {
     const lines = text.replace(/\r\n/g, "\n").split("\n");
     let inRoot = true;
     let inProvider = false;
+    let managedRootKeys = 0;
     const kept = [];
     for (const line of lines) {
         if (inProvider && /^\s*\[/.test(line))
@@ -257,14 +284,20 @@ function stripManagedConfig(content) {
             continue;
         if (/^\s*\[/.test(line))
             inRoot = false;
-        if (inRoot && (ROOT_KEY.test(line) || line.startsWith("# CPAC managed;")))
+        if (inRoot && line === MANAGED_MARKER) {
+            managedRootKeys = 2;
+            continue;
+        }
+        if (inRoot && managedRootKeys > 0 && ROOT_KEY.test(line)) {
+            managedRootKeys -= 1;
             continue;
+        }
         kept.push(line);
     }
     const output = kept.join("\n");
     return Buffer.from(eol === "\n" ? output : output.replace(/\n/g, "\r\n"));
 }
-export function buildCodexConfig(original, cpaUrl, apiKeyEnv, catalogPath) {
+export function buildCodexConfig(original, proxyPort, catalogPath) {
     let text;
     try {
         text = new TextDecoder("utf-8", { fatal: true }).decode(original);
@@ -275,33 +308,37 @@ export function buildCodexConfig(original, cpaUrl, apiKeyEnv, catalogPath) {
     if (hasProviderTable(text)) {
         throw new CPACError(`Codex config already contains [model_providers.${PROVIDER}]`);
     }
+    const normalizedLines = text.replace(/\r\n/g, "\n").split("\n");
+    const firstTable = normalizedLines.findIndex((line) => /^\s*\[/.test(line));
+    const rootLines = normalizedLines.slice(0, firstTable === -1 ? undefined : firstTable);
+    const providerLine = rootLines.find((line) => MODEL_PROVIDER_KEY.test(line));
+    if (providerLine) {
+        const match = /=\s*["']([^"']+)["']/.exec(providerLine);
+        if (!match || match[1] !== "openai") {
+            throw new CPACError("Codex config selects an external model_provider; restore it to openai before injecting CPAC");
+        }
+    }
+    if (rootLines.some((line) => OPENAI_BASE_URL_KEY.test(line))) {
+        throw new CPACError("Codex config already contains openai_base_url; remove that user-owned override before injecting CPAC");
+    }
     const eol = dominantEol(text);
     const lines = text.replace(/\r\n/g, "\n").split("\n");
     let inRoot = true;
     const kept = lines.filter((line) => {
         if (/^\s*\[/.test(line))
             inRoot = false;
-        return !(inRoot && ROOT_KEY.test(line));
+        return !(inRoot && MODEL_CATALOG_KEY.test(line));
     });
     let body = kept.join("\n");
     if (body && !body.endsWith("\n"))
         body += "\n";
     const root = [
-        "# CPAC managed; run CPAC 'restore' to restore the original file.",
-        `model_provider = ${tomlString(PROVIDER)}`,
+        MANAGED_MARKER,
         `model_catalog_json = ${tomlString(catalogPath)}`,
+        `openai_base_url = ${tomlString(`http://127.0.0.1:${proxyPort}/v1`)}`,
         "",
     ].join("\n");
-    const provider = [
-        "",
-        `[model_providers.${PROVIDER}]`,
-        'name = "CPA"',
-        `base_url = ${tomlString(apiBase(cpaUrl))}`,
-        `env_key = ${tomlString(apiKeyEnv)}`,
-        'wire_api = "responses"',
-        "",
-    ].join("\n");
-    const output = root + body + provider;
+    const output = root + body;
     return Buffer.from(eol === "\n" ? output : output.replace(/\n/g, "\r\n"));
 }
 export function atomicWrite(path, data, mode = 0o600) {
@@ -335,6 +372,243 @@ export function atomicWrite(path, data, mode = 0o600) {
         throw error;
     }
 }
+const HOP_BY_HOP_HEADERS = new Set([
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "proxy-connection",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+]);
+const CLIENT_CREDENTIAL_HEADERS = new Set([
+    "authorization",
+    "chatgpt-account-id",
+    "cookie",
+    "openai-organization",
+    "openai-project",
+    "x-api-key",
+    "x-opencodex-api-key",
+]);
+function localBrowserOrigin(value) {
+    if (!value)
+        return true;
+    try {
+        const hostname = new URL(value).hostname.toLowerCase();
+        return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
+    }
+    catch {
+        return false;
+    }
+}
+function proxyHeaders(headers, apiKey) {
+    const forwarded = {};
+    for (const [name, value] of Object.entries(headers)) {
+        if (value === undefined ||
+            name === "host" ||
+            CLIENT_CREDENTIAL_HEADERS.has(name) ||
+            HOP_BY_HOP_HEADERS.has(name)) {
+            continue;
+        }
+        forwarded[name] = value;
+    }
+    forwarded.authorization = `Bearer ${apiKey}`;
+    return forwarded;
+}
+function responseHeaders(headers) {
+    const forwarded = {};
+    for (const [name, value] of Object.entries(headers)) {
+        if (value === undefined || HOP_BY_HOP_HEADERS.has(name))
+            continue;
+        forwarded[name] = value;
+    }
+    return forwarded;
+}
+function upstreamUrl(cpaUrl, requestUrl) {
+    const incoming = new URL(requestUrl, "http://127.0.0.1");
+    const suffix = incoming.pathname === "/v1"
+        ? ""
+        : incoming.pathname.startsWith("/v1/")
+            ? incoming.pathname.slice(3)
+            : incoming.pathname;
+    return new URL(`${apiBase(cpaUrl)}${suffix}${incoming.search}`);
+}
+export async function createLoopbackProxy(cpaUrl, apiKey, proxyId, port) {
+    const server = createServer((request, response) => {
+        const requestUrl = request.url ?? "/";
+        if (requestUrl === "/_cpac/health") {
+            if (request.headers["x-cpac-proxy-id"] !== proxyId) {
+                response.writeHead(404).end();
+                return;
+            }
+            response.writeHead(204).end();
+            return;
+        }
+        if (requestUrl === "/_cpac/shutdown" && request.method === "POST") {
+            if (request.headers["x-cpac-proxy-id"] !== proxyId) {
+                response.writeHead(404).end();
+                return;
+            }
+            response.writeHead(204).end();
+            setImmediate(() => {
+                server.closeAllConnections?.();
+                server.close();
+            });
+            return;
+        }
+        if (!localBrowserOrigin(request.headers.origin)) {
+            response.writeHead(403, { "content-type": "application/json" });
+            response.end(JSON.stringify({ error: "non-local origin rejected" }));
+            return;
+        }
+        let target;
+        try {
+            target = upstreamUrl(cpaUrl, requestUrl);
+        }
+        catch {
+            response.writeHead(400).end("invalid request URL");
+            return;
+        }
+        const send = target.protocol === "https:" ? httpsRequest : httpRequest;
+        const upstream = send(target, {
+            method: request.method,
+            headers: proxyHeaders(request.headers, apiKey),
+        }, (upstreamResponse) => {
+            response.writeHead(upstreamResponse.statusCode ?? 502, responseHeaders(upstreamResponse.headers));
+            upstreamResponse.pipe(response);
+        });
+        upstream.once("error", () => {
+            if (!response.headersSent) {
+                response.writeHead(502, { "content-type": "application/json" });
+            }
+            if (!response.writableEnded)
+                response.end(JSON.stringify({ error: "CPA upstream request failed" }));
+        });
+        request.once("aborted", () => upstream.destroy());
+        request.pipe(upstream);
+    });
+    server.on("upgrade", (_request, socket) => {
+        socket.end("HTTP/1.1 426 Upgrade Required\r\nConnection: close\r\nContent-Length: 0\r\n\r\n");
+    });
+    server.on("clientError", (_error, socket) => socket.destroy());
+    await new Promise((resolveListen, rejectListen) => {
+        server.once("error", rejectListen);
+        server.listen(port, "127.0.0.1", () => {
+            server.off("error", rejectListen);
+            resolveListen();
+        });
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        server.close();
+        throw new CPACError("cannot determine loopback proxy port");
+    }
+    return { server, port: address.port };
+}
+async function runProxyChild(port) {
+    const cpaUrl = process.env.CPAC_PROXY_UPSTREAM;
+    const apiKey = process.env.CPAC_PROXY_API_KEY;
+    const proxyId = process.env.CPAC_PROXY_ID;
+    if (!cpaUrl || !apiKey || !proxyId)
+        return 1;
+    try {
+        const proxy = await createLoopbackProxy(cpaUrl, apiKey, proxyId, port);
+        process.send?.({ ready: true, port: proxy.port, pid: process.pid });
+        const close = () => {
+            proxy.server.closeAllConnections?.();
+            proxy.server.close();
+        };
+        process.once("SIGINT", close);
+        process.once("SIGTERM", close);
+        await new Promise((resolveClose) => proxy.server.once("close", resolveClose));
+        return 0;
+    }
+    catch (error) {
+        process.send?.({
+            ready: false,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return 1;
+    }
+}
+async function proxyIsHealthy(proxy) {
+    try {
+        const response = await fetch(`http://127.0.0.1:${proxy.port}/_cpac/health`, {
+            headers: { "x-cpac-proxy-id": proxy.id },
+            signal: AbortSignal.timeout(1_000),
+        });
+        return response.status === 204;
+    }
+    catch {
+        return false;
+    }
+}
+async function startProxyProcess(config, apiKey) {
+    const id = randomBytes(24).toString("hex");
+    const child = spawn(process.execPath, [fileURLToPath(import.meta.url), "_proxy", String(config.codex_proxy_port)], {
+        detached: true,
+        env: {
+            ...process.env,
+            CPAC_PROXY_API_KEY: apiKey,
+            CPAC_PROXY_ID: id,
+            CPAC_PROXY_UPSTREAM: config.cpa_url,
+        },
+        stdio: ["ignore", "ignore", "ignore", "ipc"],
+    });
+    return await new Promise((resolveStart, rejectStart) => {
+        let settled = false;
+        let timeout;
+        const finish = (error, value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            child.removeAllListeners();
+            if (child.connected)
+                child.disconnect();
+            child.unref();
+            if (error)
+                rejectStart(error);
+            else
+                resolveStart(value);
+        };
+        timeout = setTimeout(() => {
+            child.kill();
+            finish(new CPACError("loopback proxy did not become ready"));
+        }, 5_000);
+        child.once("error", (error) => finish(new CPACError(`cannot start loopback proxy: ${error.message}`)));
+        child.once("exit", (code) => finish(new CPACError(`loopback proxy exited before ready (${code ?? 1})`)));
+        child.once("message", (message) => {
+            if (objectValue(message) &&
+                message.ready === true &&
+                typeof message.pid === "number" &&
+                typeof message.port === "number") {
+                finish(undefined, { id, pid: message.pid, port: message.port });
+                return;
+            }
+            const detail = objectValue(message) && typeof message.error === "string"
+                ? `: ${message.error}`
+                : "";
+            finish(new CPACError(`cannot start loopback proxy${detail}`));
+        });
+    });
+}
+async function stopProxyProcess(proxy) {
+    if (!(await proxyIsHealthy(proxy)))
+        return;
+    try {
+        await fetch(`http://127.0.0.1:${proxy.port}/_cpac/shutdown`, {
+            method: "POST",
+            headers: { "x-cpac-proxy-id": proxy.id },
+            signal: AbortSignal.timeout(1_000),
+        });
+    }
+    catch {
+        // The server may close the connection while shutting down.
+    }
+}
 function readState(stateDir) {
     const path = join(stateDir, "state.json");
     if (!existsSync(path))
@@ -348,7 +622,7 @@ function readState(stateDir) {
     }
     if (!objectValue(value) ||
         Object.keys(value).some((key) => !STATE_KEYS.has(key)) ||
-        Object.keys(value).length !== STATE_KEYS.size) {
+        [...REQUIRED_STATE_KEYS].some((key) => !(key in value))) {
         throw new CPACError("invalid state file");
     }
     if (typeof value.config_path !== "string" || !isAbsolute(value.config_path)) {
@@ -361,8 +635,42 @@ function readState(stateDir) {
         value.config_mode > 0o7777) {
         throw new CPACError("invalid config_mode value in state");
     }
+    const proxyKeys = ["proxy_id", "proxy_pid", "proxy_port"];
+    const proxyKeyCount = proxyKeys.filter((key) => key in value).length;
+    if (proxyKeyCount !== 0 &&
+        (proxyKeyCount !== proxyKeys.length ||
+            typeof value.proxy_id !== "string" ||
+            !/^[a-f0-9]{48}$/.test(value.proxy_id) ||
+            !Number.isInteger(value.proxy_pid) ||
+            value.proxy_pid <= 0 ||
+            !Number.isInteger(value.proxy_port) ||
+            value.proxy_port <= 0 ||
+            value.proxy_port > 65535)) {
+        throw new CPACError("invalid loopback proxy state");
+    }
+    if (value.proxy_fingerprint !== undefined &&
+        (typeof value.proxy_fingerprint !== "string" ||
+            !/^[a-f0-9]{64}$/.test(value.proxy_fingerprint))) {
+        throw new CPACError("invalid loopback proxy fingerprint");
+    }
     return value;
 }
+function stateProxy(state) {
+    return state.proxy_id && state.proxy_pid && state.proxy_port
+        ? { id: state.proxy_id, pid: state.proxy_pid, port: state.proxy_port }
+        : null;
+}
+function stateBytes(config, existed, mode, proxy, proxyFingerprint) {
+    return Buffer.from(`${JSON.stringify({
+        config_path: config.codex_config,
+        config_existed: existed,
+        config_mode: mode,
+        proxy_id: proxy.id,
+        proxy_fingerprint: proxyFingerprint,
+        proxy_pid: proxy.pid,
+        proxy_port: proxy.port,
+    }, null, 2)}\n`);
+}
 function originalBytes(stateDir, state, expectedPath) {
     if (state.config_path !== expectedPath) {
         throw new CPACError(`active injection belongs to ${state.config_path}; restore it first`);
@@ -388,6 +696,13 @@ function cleanupStateFiles(stateDir) {
             throw error;
     }
 }
+function proxyFingerprint(config, apiKey) {
+    return createHash("sha256")
+        .update(config.cpa_url)
+        .update("\0")
+        .update(apiKey)
+        .digest("hex");
+}
 export async function inject(config) {
     const apiKey = process.env[config.api_key_env]?.trim();
     if (!apiKey)
@@ -423,20 +738,58 @@ export async function inject(config) {
             throw new CPACError(`cannot read Codex config: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    const catalogPath = join(config.state_dir, "codex-models.json");
-    const injected = buildCodexConfig(original, config.cpa_url, config.api_key_env, catalogPath);
     const catalog = await fetchCatalog(config.cpa_url, apiKey);
     const stateDirExisted = existsSync(config.state_dir);
     if (!state &&
         STATE_FILES.some((name) => existsSync(join(config.state_dir, name)))) {
         throw new CPACError("state_dir contains CPAC files without a valid state; refusing to overwrite them");
     }
+    const fingerprint = proxyFingerprint(config, apiKey);
+    const previousProxy = state ? stateProxy(state) : null;
+    let proxy;
+    let startedProxy = false;
+    if (previousProxy &&
+        state?.proxy_fingerprint === fingerprint &&
+        (config.codex_proxy_port === 0 ||
+            config.codex_proxy_port === previousProxy.port) &&
+        (await proxyIsHealthy(previousProxy))) {
+        proxy = previousProxy;
+    }
+    else {
+        if (previousProxy)
+            await stopProxyProcess(previousProxy);
+        try {
+            proxy = await startProxyProcess(config, apiKey);
+            startedProxy = true;
+        }
+        catch (error) {
+            throw new CPACError(`${error instanceof Error ? error.message : String(error)}; choose another codex_proxy_port if the port is occupied`);
+        }
+    }
+    const catalogPath = join(config.state_dir, "codex-models.json");
+    let injected;
+    try {
+        injected = buildCodexConfig(original, proxy.port, catalogPath);
+    }
+    catch (error) {
+        if (startedProxy)
+            await stopProxyProcess(proxy);
+        throw error;
+    }
     mkdirSync(config.state_dir, { recursive: true, mode: 0o700 });
     if (!stateDirExisted)
         chmodSync(config.state_dir, 0o700);
     if (state) {
-        atomicWrite(catalogPath, catalog.bytes);
-        atomicWrite(config.codex_config, injected, originalMode);
+        try {
+            atomicWrite(catalogPath, catalog.bytes);
+            atomicWrite(config.codex_config, injected, originalMode);
+            atomicWrite(join(config.state_dir, "state.json"), stateBytes(config, existed, originalMode, proxy, fingerprint));
+        }
+        catch (error) {
+            if (startedProxy)
+                await stopProxyProcess(proxy);
+            throw error;
+        }
     }
     else {
         let configWritten = false;
@@ -446,11 +799,7 @@ export async function inject(config) {
             atomicWrite(catalogPath, catalog.bytes);
             atomicWrite(config.codex_config, injected, originalMode);
             configWritten = true;
-            atomicWrite(join(config.state_dir, "state.json"), Buffer.from(`${JSON.stringify({
-                config_path: config.codex_config,
-                config_existed: existed,
-                config_mode: originalMode,
-            }, null, 2)}\n`));
+            atomicWrite(join(config.state_dir, "state.json"), stateBytes(config, existed, originalMode, proxy, fingerprint));
         }
         catch (error) {
             if (configWritten) {
@@ -464,18 +813,33 @@ export async function inject(config) {
                     throw new CPACError(`injection failed and config rollback failed; backup retained in ${config.state_dir}: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
                 }
             }
+            let cleanupError;
             try {
                 cleanupStateFiles(config.state_dir);
             }
-            catch (cleanupError) {
+            catch (caught) {
+                cleanupError = caught;
+            }
+            if (startedProxy)
+                await stopProxyProcess(proxy);
+            if (cleanupError) {
                 throw new CPACError(`injection failed and state cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
             }
             throw error;
         }
     }
-    console.log(`Injected ${catalog.modelCount} CPA models into ${config.codex_config}`);
+    try {
+        rmSync(join(dirname(config.codex_config), "models_cache.json"), {
+            force: true,
+        });
+    }
+    catch {
+        console.warn("CPAC could not invalidate Codex models_cache.json; restart Codex App if its model list is stale.");
+    }
+    console.log(`Injected ${catalog.modelCount} CPA models into ${config.codex_config} via http://127.0.0.1:${proxy.port}/v1`);
+    console.log("Restart Codex App if its running app-server still shows the old model list.");
 }
-export function restore(config) {
+export async function restore(config) {
     const state = readState(config.state_dir);
     if (!state)
         throw new CPACError("no active CPAC injection");
@@ -484,6 +848,9 @@ export function restore(config) {
         atomicWrite(config.codex_config, original, state.config_mode);
     else
         rmSync(config.codex_config, { force: true });
+    const proxy = stateProxy(state);
+    if (proxy)
+        await stopProxyProcess(proxy);
     try {
         cleanupStateFiles(config.state_dir);
     }
@@ -492,22 +859,39 @@ export function restore(config) {
     }
     console.log(`Restored ${config.codex_config}`);
 }
-export function status(config) {
+export async function status(config) {
+    const apiKey = process.env[config.api_key_env]?.trim();
+    const keyConfigured = !!apiKey;
     const state = readState(config.state_dir);
     if (!state) {
-        console.log("native");
-        return 1;
+        console.log("codex: native");
     }
-    originalBytes(config.state_dir, state, config.codex_config);
-    if (!existsSync(config.codex_config)) {
-        console.log(`injected (config missing: ${config.codex_config})`);
-        return 2;
+    else {
+        originalBytes(config.state_dir, state, config.codex_config);
+        if (!existsSync(config.codex_config)) {
+            console.log(`codex: injected (config missing: ${config.codex_config})`);
+        }
+        else {
+            const proxy = stateProxy(state);
+            if (!proxy || !(await proxyIsHealthy(proxy))) {
+                console.log(`codex: injected (loopback proxy stopped: ${config.codex_config})`);
+            }
+            else {
+                const digest = createHash("sha256")
+                    .update(readFileSync(config.codex_config))
+                    .digest("hex")
+                    .slice(0, 12);
+                console.log(`codex: injected proxy=http://127.0.0.1:${proxy.port}/v1 sha256=${digest}`);
+            }
+        }
     }
-    const digest = createHash("sha256")
-        .update(readFileSync(config.codex_config))
-        .digest("hex")
-        .slice(0, 12);
-    console.log(`injected: ${config.codex_config} sha256=${digest}`);
+    console.log(`claude: ${keyConfigured ? "ready" : "not configured"}`);
+    console.log(`pi: ${keyConfigured ? "ready" : "not configured"}`);
+    if (!state)
+        return 1;
+    const proxy = stateProxy(state);
+    if (!proxy || !(await proxyIsHealthy(proxy)))
+        return 2;
     return 0;
 }
 function claudeBaseUrl(cpaUrl) {
@@ -568,7 +952,7 @@ export function saveApiKeyExport(profile, name, apiKey) {
     atomicWrite(profile, Buffer.from(content), mode);
 }
 async function guide(config) {
-    console.log(`CPA Companion\n\nCPA: ${config.cpa_url}\nCPA_API_KEY: ${process.env[config.api_key_env]?.trim() ? "configured" : "not configured"}\n\nCommands:\n  cpac claude [args...]  Launch Claude Code through CPA\n  cpac inject            Inject CPA into Codex\n  cpac status            Show Codex injection status\n  cpac restore           Restore the original Codex config\n  cpac --help            Show command usage`);
+    console.log(`CPA Companion\n\nCPA: ${config.cpa_url}\nCPA_API_KEY: ${process.env[config.api_key_env]?.trim() ? "configured" : "not configured"}\n\nCommands:\n  cpac claude [args...]  Launch Claude Code through CPA\n  cpac inject            Inject CPA into Codex and start its loopback proxy\n  cpac proxy             Run the injected loopback proxy in the foreground\n  cpac status            Show agent support status (Codex, Claude, Pi)\n  cpac restore           Restore the original Codex config\n  cpac --help            Show command usage`);
     if (process.env[config.api_key_env]?.trim())
         return 0;
     const apiKey = await promptSecret(config.api_key_env);
@@ -600,10 +984,43 @@ export async function runClaude(config, args, executable = "claude") {
         child.once("close", (code) => resolve(code ?? 1));
     });
 }
+export async function runProxy(config) {
+    const apiKey = await resolveApiKey(config.api_key_env);
+    const state = readState(config.state_dir);
+    if (!state)
+        throw new CPACError("no active CPAC injection; run cpac inject first");
+    originalBytes(config.state_dir, state, config.codex_config);
+    const recorded = stateProxy(state);
+    if (!recorded) {
+        throw new CPACError("injection has no loopback proxy state; run cpac inject to migrate it");
+    }
+    if (await proxyIsHealthy(recorded)) {
+        throw new CPACError(`loopback proxy is already running on 127.0.0.1:${recorded.port}`);
+    }
+    const proxy = await createLoopbackProxy(config.cpa_url, apiKey, recorded.id, recorded.port);
+    try {
+        atomicWrite(join(config.state_dir, "state.json"), stateBytes(config, state.config_existed, state.config_mode, { id: recorded.id, pid: process.pid, port: proxy.port }, proxyFingerprint(config, apiKey)));
+    }
+    catch (error) {
+        proxy.server.closeAllConnections?.();
+        proxy.server.close();
+        throw error;
+    }
+    console.log(`CPAC loopback proxy listening on http://127.0.0.1:${proxy.port}/v1`);
+    const close = () => {
+        proxy.server.closeAllConnections?.();
+        proxy.server.close();
+    };
+    process.once("SIGINT", close);
+    process.once("SIGTERM", close);
+    await new Promise((resolveClose) => proxy.server.once("close", resolveClose));
+    return 0;
+}
 function usage() {
     return [
         "Usage: cpac",
         "       cpac <inject|status|restore> [--config PATH]",
+        "       cpac proxy [--config PATH]",
         "       cpac claude [--config PATH] [--] [claude args...]",
     ].join("\n");
 }
@@ -645,7 +1062,7 @@ function parseArgs(args) {
             positional.push(args[index]);
     }
     if (positional.length !== 1 ||
-        !["inject", "status", "restore"].includes(positional[0])) {
+        !["inject", "status", "restore", "proxy"].includes(positional[0])) {
         throw new CPACError(usage());
     }
     return {
@@ -655,6 +1072,12 @@ function parseArgs(args) {
 }
 export async function main(args = process.argv.slice(2)) {
     try {
+        if (args[0] === "_proxy") {
+            const port = Number(args[1]);
+            if (!Number.isInteger(port) || port < 0 || port > 65535)
+                return 1;
+            return await runProxyChild(port);
+        }
         const parsed = parseArgs(args);
         if (!parsed)
             return 0;
@@ -663,12 +1086,14 @@ export async function main(args = process.argv.slice(2)) {
             return await guide(config);
         if (parsed.command === "claude")
             return await runClaude(config, parsed.args);
+        if (parsed.command === "proxy")
+            return await runProxy(config);
         if (parsed.command === "inject")
             await inject(config);
         else if (parsed.command === "restore")
-            restore(config);
+            await restore(config);
         else
-            return status(config);
+            return await status(config);
         return 0;
     }
     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yhong91/cpac",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Connect Codex and Claude Code to a remote CLIProxyAPI gateway",
   "type": "module",
   "bin": {