@ailuntz/codex-desktop-router 0.6.1

package/LICENSE

@@ -0,0 +1,202 @@
+MIT License
+
+Copyright (c) 2026 ailuntz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+The text-only Responses gateway in src/chat.mjs also carries the following notice:
+
+Copyright 2026 ailuntz
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

package/README.md

@@ -0,0 +1,50 @@
+# codex-desktop-router
+
+在 ChatGPT / Codex Desktop 的原生模型菜单中使用已有 profiles。
+
+自动读取 `~/.codex/*.config.toml`。有 `model_catalog_json` 就使用该目录，否则继承原生模型列表，无需维护模型名单。支持 API key 的 Responses 连接还会追加 `-Chat`，用于不带工具和工作区上下文的纯文字聊天。
+
+## 安装
+
+macOS，Node.js ≥22.16。
+
+```sh
+npm install -g @ailuntz/codex-desktop-router
+codex-desktop-router install
+```
+
+完全退出并重开 Desktop，再运行：
+
+```sh
+codex-desktop-router on
+```
+
+## 命令
+
+| 命令 | 用途 |
+| --- | --- |
+| `install` | 安装或升级本机接入 |
+| `on` | 开启模型选项，打开模型选择页 |
+| `off` | 关闭追加选项和选择页接管 |
+| `doctor` | 检查配置、运行状态和新版 |
+| `uninstall` | 移除 Desktop 接入，保留用户配置 |
+
+额度提示挡住菜单时，运行 `on`，在选择页切换模型后回 Desktop 发送。选择持续到交回菜单、执行 `off` 或退出 Desktop。
+
+## 更新
+
+每天自动检查一次，新版会在终端和模型选择页提示。升级：
+
+```sh
+npm install -g @ailuntz/codex-desktop-router@latest
+codex-desktop-router install
+```
+
+升级或修改 profiles、连接、密钥后，重启 Desktop。设置 `CODEX_DESKTOP_ROUTER_NO_UPDATE_CHECK=1` 可关闭检查。
+
+## 使用说明
+
+- 跨连接切换需要任务已保存且空闲；临时任务、尚无历史或含子代理的任务请新建。
+- Chat 仅支持纯文字历史，不支持附件、中途追加和上下文压缩。
+- 模型选择保留当前任务权限，不应用 profile 中的权限覆盖。
+- 密钥使用提供商声明的环境变量，也可放在 `~/.codex/.env`。支持 `CODEX_HOME`。

package/bin/codex-desktop-router.mjs

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { VERSION, readConfig, configPath, codexHome, atomicJSON, discoverProfiles, resolveRealCodex, childEnvironment } from '../src/config.mjs';
+import { checkForUpdates } from '../src/update.mjs';
+import { runProxy } from '../src/proxy.mjs';
+import { openPicker } from '../src/picker.mjs';
+import { install, uninstall, installation, environmentStatus } from '../src/install.mjs';
+
+const self = fileURLToPath(import.meta.url), args = process.argv.slice(2);
+const commands = ['install', 'on', 'off', 'doctor', 'uninstall'];
+const output = value => console.log(typeof value === 'string' ? value : JSON.stringify(value, null, 2));
+const help = `codex-desktop-router
+
+  install      安装或升级本机接入
+  on           开启 profile 模型选项，并打开模型选择页
+  off          隐藏额外选项，停止选择页接管
+  doctor       检查 profiles、连接和是否需要重启
+  uninstall    移除本机接入
+
+自动读取 CODEX_HOME 下的 *.config.toml，无需重复配置。
+有 model_catalog_json 时使用生效目录，否则继承客户端模型目录。
+权限仍由当前任务管理。其他 Codex 参数原样透传。`;
+
+async function main() {
+  const command = args[0];
+  if (!command || ['--help', '-h'].includes(command)) return output(help);
+  if (commands.includes(command) && args.length !== 1) throw new Error(`${command} 不接受额外参数。`);
+  if (['configure', 'picker'].includes(command)) throw new Error('此入口已移除。配置直接在客户端管理，开启和选择模型统一使用 on。');
+  if (command === 'install') {
+    resolveRealCodex(self);
+    const state = readConfig();
+    const result = install(); atomicJSON(configPath(), state);
+    return output(`已安装 ${VERSION}：${result.wrapper}\n请完全退出并重开 Desktop，然后运行 codex-desktop-router on。`);
+  }
+  if (command === 'on' || command === 'off') {
+    if (command === 'on') discoverProfiles();
+    atomicJSON(configPath(), { version: 1, enabled: command === 'on' });
+    return output(command === 'off' ? '已关闭额外选项和选择页接管。已有任务保留当前提供商。' : openPicker(codexHome()) ? '已开启，并打开模型选择页。' : '已开启。请完全退出并重开 Desktop；需要选择页时再次运行 on。');
+  }
+  if (command === 'uninstall') return output(uninstall() ? '已移除本机接入。重启 Desktop 后生效。' : '未发现安装记录。');
+  if (command === 'doctor') {
+    const active = [], profiles = discoverProfiles(), env = childEnvironment(profiles);
+    try {
+      for (const file of readdirSync(join(codexHome(), 'desktop-router-runs'))) if (/^\d+\.json$/.test(file)) {
+        try { const run = JSON.parse(readFileSync(join(codexHome(), 'desktop-router-runs', file), 'utf8')); process.kill(run.pid, 0); process.kill(run.childPid, 0); active.push({ pid: run.pid, version: run.version }); } catch { /* stale process */ }
+      }
+    } catch { /* no active process */ }
+    return output({ version: VERSION, enabled: readConfig().enabled, realCodex: resolveRealCodex(self), installed: Boolean(installation()), launchEnvironment: environmentStatus(),
+      profiles: profiles.map(r => ({ name: r.profile, provider: r.originalProvider, catalog: r.catalogPath || '继承客户端目录', chat: r.chat, keyAvailable: r.providerDefinition?.env_key ? Boolean(env[r.providerDefinition.env_key]) : null })),
+      update: await checkForUpdates(), active, restartRequired: active.length === 0 || active.some(r => r.version !== VERSION) });
+  }
+  process.exitCode = await runProxy(args, self);
+}
+main().then(async () => {
+  if (['install', 'on'].includes(args[0])) {
+    const update = await checkForUpdates();
+    if (update.available) process.stderr.write(`新版 ${update.latest} 可用：${update.command}\n升级后请重启 Desktop。\n`);
+  }
+}).catch(error => { process.stderr.write(`codex-desktop-router: ${error.message}\n`); process.exitCode = 1; });

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@ailuntz/codex-desktop-router",
+  "version": "0.6.1",
+  "description": "Add custom-provider routes to the native Codex Desktop model picker without maintaining a model catalog.",
+  "type": "module",
+  "license": "MIT AND Apache-2.0",
+  "engines": {
+    "node": ">=22.16"
+  },
+  "bin": {
+    "codex-desktop-router": "bin/codex-desktop-router.mjs"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
+  "dependencies": {
+    "smol-toml": "1.8.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/src/chat.mjs

@@ -0,0 +1,158 @@
+import { randomBytes, createHash } from 'node:crypto';
+import { Readable, Transform } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { StringDecoder } from 'node:string_decoder';
+import { chatProviderId } from './config.mjs';
+
+const instructions = 'You are a helpful conversational assistant. Answer the user directly. No tools are available.';
+const limit = 16 * 1024 * 1024;
+const textMessage = (role, text) => ({ type: 'message', role, content: [{ type: role === 'assistant' ? 'output_text' : 'input_text', text }] });
+function userText(content) {
+  if (!Array.isArray(content) || content.some(p => p.type !== 'text' || typeof p.text !== 'string')) throw new Error('Chat 模式目前只支持文字；图片、附件和技能请使用普通模型。');
+  return content.map(p => p.text).join('\n');
+}
+
+// Check each complete SSE event before Codex can receive a tool-call item.
+function textEvents() {
+  const decoder = new StringDecoder('utf8');
+  let pending = '';
+  function inspect(frame) {
+    const data = frame.split(/\r?\n/).filter(line => line.startsWith('data:')).map(line => line.slice(5).trimStart()).join('\n');
+    if (!data || data === '[DONE]') return;
+    const event = JSON.parse(data);
+    const items = [...(event.item ? [event.item] : []), ...(event.response?.output || [])];
+    if (items.some(item => !['message', 'reasoning'].includes(item.type) || (item.type === 'message' && item.role !== 'assistant'))) throw new Error('Chat upstream returned a non-text item');
+  }
+  return new Transform({
+    transform(chunk, encoding, done) {
+      try {
+        pending += decoder.write(chunk);
+        let match;
+        while ((match = /\r?\n\r?\n/.exec(pending))) {
+          const end = match.index + match[0].length, frame = pending.slice(0, end);
+          if (Buffer.byteLength(frame) > limit) throw new Error('Chat response event too large');
+          inspect(frame); this.push(frame); pending = pending.slice(end);
+        }
+        if (Buffer.byteLength(pending) > limit) throw new Error('Chat response event too large');
+        done();
+      } catch (error) { done(error); }
+    },
+    flush(done) {
+      try { pending += decoder.end(); if (pending) { inspect(pending); this.push(pending); } done(); }
+      catch (error) { done(error); }
+    }
+  });
+}
+
+export class Chat {
+  constructor({ config, key, env = {} }) {
+    this.config = config; this.key = key;
+    this.headers = { ...config.providerDefinition.http_headers };
+    for (const [name, variable] of Object.entries(config.providerDefinition.env_http_headers || {})) if (env[variable]) this.headers[name] = env[variable];
+    this.path = `/chat-${randomBytes(24).toString('hex')}`;
+    this.envKey = `CDR_CHAT_${randomBytes(8).toString('hex')}`;
+    this.providers = new Set([chatProviderId(config), ...(config.legacyProvider ? [`cdr_chat_${config.legacyProvider}`] : [])]);
+    this.token = randomBytes(32).toString('hex');
+    this.contexts = new Map(); this.pending = new Map(); this.starts = new Set(); this.fresh = new Set();
+  }
+  definition(port) {
+    return { name: `${this.config.providerDefinition.name} Chat`, base_url: `http://127.0.0.1:${port}${this.path}`, env_key: this.envKey,
+      wire_api: 'responses', requires_openai_auth: false, supports_websockets: false };
+  }
+  async prepare(message) {
+    if (!message || !Object.hasOwn(message, 'id')) return message;
+    const { method, params } = message || {};
+    if (method === 'thread/start' && this.providers.has(params?.modelProvider)) {
+      if (params.ephemeral) throw new Error('Chat 模式需要保存任务历史，不支持临时任务。');
+      this.starts.add(message.id);
+    }
+    if (!params?.threadId || !this.providers.has(this.menu.threads.get(params.threadId))) return message;
+    if (method === 'turn/steer' || method === 'thread/compact/start') throw new Error('Chat 模式请等回复结束后再发送；暂不支持中途追加和手动压缩。');
+    if (method !== 'turn/start') return message;
+    if (this.contexts.has(params.threadId)) throw new Error('请等当前 Chat 回复结束后再发送。');
+    const current = userText(params.input);
+    // Native list_turns is unavailable before a fresh task's first turn. Only
+    // tasks created on this connection may skip that read; never omit old history.
+    const { thread } = await this.bridge.rpc('thread/read', { threadId: params.threadId, includeTurns: !this.fresh.has(params.threadId) });
+    if (thread.modelProvider && !this.providers.has(thread.modelProvider)) throw new Error('任务提供商已经改变，请重新打开任务。');
+    const input = [];
+    for (const turn of thread.turns || []) for (const item of turn.items || []) {
+      if (item.type === 'userMessage') input.push(textMessage('user', userText(item.content)));
+      if (item.type === 'agentMessage' && typeof item.text === 'string') input.push(textMessage('assistant', item.text));
+    }
+    input.push(textMessage('user', current));
+    if (Buffer.byteLength(JSON.stringify(input)) > limit) throw new Error('这段 Chat 历史过长，请新建任务继续。');
+    const context = { input, model: params.model || params.collaborationMode?.settings?.model || thread.model, requests: new Set() };
+    this.contexts.set(params.threadId, context);
+    this.pending.set(message.id, params.threadId);
+    return message;
+  }
+  response(message) {
+    if (!message?.method && this.starts.delete(message?.id) && message.result?.thread?.id) this.fresh.add(message.result.thread.id);
+    const id = !message?.method && this.pending.get(message?.id);
+    if (id) {
+      this.pending.delete(message.id);
+      if (message.error) this.clear(id);
+      else {
+        this.fresh.delete(id);
+        if (this.contexts.has(id)) this.contexts.get(id).turnId = message.result?.turn?.id;
+      }
+    }
+    if (message?.method === 'turn/completed') {
+      const context = this.contexts.get(message.params?.threadId);
+      if (context && (!context.turnId || context.turnId === message.params.turn?.id)) this.clear(message.params.threadId);
+    }
+    if (message?.method === 'thread/closed') { this.clear(message.params?.threadId); this.fresh.delete(message.params?.threadId); }
+  }
+  clear(id) {
+    const context = this.contexts.get(id);
+    for (const controller of context?.requests || []) controller.abort();
+    this.contexts.delete(id);
+  }
+  async handle(req, res) {
+    const reply = (status, message) => { res.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-store' }); res.end(JSON.stringify({ error: { message, type: 'chat_gateway_error' } })); };
+    if (req.headers.authorization !== `Bearer ${this.token}`) return reply(401, 'Chat 入口已失效。');
+    if (req.method !== 'POST' || req.url !== `${this.path}/responses`) return reply(400, 'Chat 仅支持文字 Responses 请求；历史过长时请新建任务。');
+    const context = this.contexts.get(req.headers['thread-id']);
+    if (!context || !this.key) return reply(400, '未找到当前 Chat 请求或提供商密钥。');
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    context.requests.add(controller); res.once('close', abort);
+    try {
+      const chunks = []; let size = 0;
+      for await (const chunk of req) {
+        size += chunk.length;
+        if (size > limit) return reply(413, 'Chat 请求过大，请新建任务。');
+        chunks.push(chunk);
+      }
+      const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+      if (body.model !== context.model) return reply(400, 'Chat 模型与当前任务不匹配，请重新选择。');
+      // Allow only generation options. Agent instructions, tools, cache/history
+      // handles and workspace metadata never cross this boundary.
+      const outgoing = { model: body.model, input: context.input, instructions, stream: true, store: false, tool_choice: 'none', parallel_tool_calls: false,
+        prompt_cache_key: `cdr:chat:${createHash('sha256').update(`${body.model}\0${instructions}`).digest('hex').slice(0, 32)}` };
+      for (const field of ['reasoning', 'text', 'service_tier']) if (body[field] != null) outgoing[field] = body[field];
+      const headers = { authorization: `Bearer ${this.key}`, 'content-type': 'application/json', accept: 'text/event-stream' };
+      // Preserve the actual native client's protocol identity. Some providers
+      // require it; do not invent a UA or forward workspace/account metadata.
+      for (const name of ['user-agent', 'originator', 'version', 'openai-beta', 'x-codex-window-id']) if (typeof req.headers[name] === 'string') headers[name] = req.headers[name];
+      for (const [name, value] of Object.entries(this.headers)) if (!['authorization', 'host', 'connection', 'content-length', 'accept-encoding'].includes(name.toLowerCase())) headers[name.toLowerCase()] = value;
+      const upstream = await fetch(`${this.config.providerDefinition.base_url.replace(/\/+$/, '')}/responses`, {
+        method: 'POST', headers,
+        body: JSON.stringify(outgoing), signal: controller.signal, redirect: 'error'
+      });
+      if (!upstream.ok || !upstream.headers.get('content-type')?.includes('text/event-stream')) {
+        await upstream.body?.cancel();
+        return reply(upstream.ok ? 502 : upstream.status, `Chat 上游请求失败（HTTP ${upstream.status}）。`);
+      }
+      res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-store' });
+      await pipeline(Readable.fromWeb(upstream.body), textEvents(), res, { signal: controller.signal });
+    } catch {
+      if (!res.destroyed && !res.writableEnded) {
+        if (res.headersSent) res.destroy();
+        else reply(502, 'Chat 请求未完成，请检查提供商连接后重试。');
+      }
+    } finally { context.requests.delete(controller); res.removeListener('close', abort); controller.abort(); }
+  }
+  close() { for (const id of this.contexts.keys()) this.clear(id); this.pending.clear(); this.starts.clear(); this.fresh.clear(); }
+}

package/src/config.mjs

@@ -0,0 +1,99 @@
+import { readFileSync, readdirSync, mkdirSync, writeFileSync, renameSync, rmSync, existsSync, realpathSync, accessSync, constants } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolve, join, dirname, isAbsolute } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { parseEnv } from 'node:util';
+import { parse } from 'smol-toml';
+
+export const VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+export const defaults = { version: 1, enabled: false };
+export const codexHome = () => resolve(process.env.CODEX_HOME || join(homedir(), '.codex'));
+export const configPath = () => resolve(process.env.CODEX_DESKTOP_ROUTER_CONFIG || join(codexHome(), 'desktop-router.json'));
+export const object = x => x !== null && typeof x === 'object' && !Array.isArray(x);
+export const chatProviderId = route => `cdr_chat_${route.provider}`;
+export const findRoute = (provider, config) => config.routes.find(r => [r.provider, chatProviderId(r), r.legacyProvider, r.legacyProvider && `cdr_chat_${r.legacyProvider}`].filter(Boolean).includes(provider));
+export const isRoutedProvider = (provider, config) => Boolean(findRoute(provider, config));
+export const isChatProvider = (provider, config) => { const r = findRoute(provider, config); return Boolean(r && provider !== r.provider && provider !== r.legacyProvider); };
+
+export function atomicJSON(path, value) {
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  const tmp = `${path}.${randomUUID()}.tmp`;
+  try { writeFileSync(tmp, JSON.stringify(value, null, 2) + '\n', { mode: 0o600, flag: 'wx' }); renameSync(tmp, path); }
+  finally { rmSync(tmp, { force: true }); }
+}
+
+export function readConfig(path = configPath()) {
+  let raw;
+  try { raw = readFileSync(path, 'utf8'); } catch (e) { if (e.code === 'ENOENT') return { ...defaults }; throw new Error('无法读取路由开关。'); }
+  let value;
+  try { value = JSON.parse(raw); } catch { throw new Error('路由开关文件不是有效 JSON。'); }
+  if (value?.version !== 1 || typeof value.enabled !== 'boolean') throw new Error('路由开关文件格式错误。');
+  return { version: 1, enabled: value.enabled };
+}
+
+export function merge(base, overlay) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(overlay)) result[key] = object(value) && object(base[key]) ? merge(base[key], value) : value;
+  return result;
+}
+
+export function discoverProfiles(home = codexHome()) {
+  const read = file => {
+    try { return parse(readFileSync(join(home, file), 'utf8')); }
+    catch (e) { if (file === 'config.toml' && e.code === 'ENOENT') return {}; throw new Error(`${file} 无法解析，请在客户端修复。`); }
+  };
+  const base = read('config.toml');
+  let files;
+  try { files = readdirSync(home); } catch (e) { if (e.code === 'ENOENT') return []; throw e; }
+  const routes = files.filter(f => /^[A-Za-z0-9_-]+\.config\.toml$/.test(f)).sort().map(file => {
+    const profile = file.slice(0, -12), layer = read(file), effective = merge(base, layer);
+    const originalProvider = effective.model_provider || 'openai';
+    const providerDefinition = effective.model_providers?.[originalProvider] || (originalProvider === 'openai' ? { name: 'OpenAI', wire_api: 'responses', requires_openai_auth: true, supports_websockets: true } : null);
+    const catalogPath = effective.model_catalog_json == null ? null : resolve(home, effective.model_catalog_json);
+    return { profile, provider: `cdr_profile_${profile}`, originalProvider, providerDefinition,
+      catalogPath, layer, fingerprint: JSON.stringify({ originalProvider, providerDefinition, catalogPath }),
+      chat: Boolean(providerDefinition?.base_url && providerDefinition?.env_key && providerDefinition.requires_openai_auth !== true && (providerDefinition.wire_api || 'responses') === 'responses') };
+  });
+  for (const route of routes) {
+    // Existing tasks keep their old provider metadata until their next switch.
+    if (/^[A-Za-z0-9_-]+$/.test(route.originalProvider) && !route.originalProvider.startsWith('cdr_') && route.originalProvider !== (base.model_provider || 'openai') && routes.filter(r => r.originalProvider === route.originalProvider).length === 1) route.legacyProvider = route.originalProvider;
+  }
+  return routes;
+}
+
+export function findApp() {
+  return [process.env.CODEX_DESKTOP_APP, '/Applications/ChatGPT.app', '/Applications/Codex.app', join(homedir(), 'Applications/ChatGPT.app'), join(homedir(), 'Applications/Codex.app')].filter(Boolean).find(p => existsSync(join(p, 'Contents/Resources/codex')));
+}
+
+export function resolveRealCodex(selfPath) {
+  const app = findApp();
+  const candidate = process.env.CODEX_DESKTOP_ROUTER_REAL_CODEX || (app && join(app, 'Contents/Resources/codex'));
+  if (!candidate || !isAbsolute(candidate)) throw new Error('找不到内置 Codex；可用 CODEX_DESKTOP_ROUTER_REAL_CODEX 指定绝对路径。');
+  let actual;
+  try { actual = realpathSync(candidate); accessSync(actual, constants.X_OK); } catch { throw new Error('真正的 Codex 不存在或不可执行。'); }
+  if (actual === realpathSync(selfPath) || actual === realpathSync(process.execPath)) throw new Error('检测到路由递归调用。');
+  return actual;
+}
+
+export function childEnvironment(routes = []) {
+  const env = { ...process.env, CODEX_DESKTOP_ROUTER_ACTIVE: String((Number.parseInt(process.env.CODEX_DESKTOP_ROUTER_ACTIVE, 10) || 0) + 1) };
+  let values = {};
+  try { values = parseEnv(readFileSync(join(codexHome(), '.env'), 'utf8')); }
+  catch (e) { if (e.code !== 'ENOENT') throw new Error('无法读取 CODEX_HOME/.env。'); }
+  for (const { providerDefinition: d } of routes) {
+    const names = [d?.env_key, ...Object.values(d?.env_http_headers || {})];
+    for (const key of names) if (typeof key === 'string' && !env[key] && values[key]) env[key] = values[key];
+  }
+  return env;
+}
+
+export function providerArgs(routes, chats = new Map()) {
+  const inline = value => object(value) ? `{ ${Object.entries(value).map(([k, v]) => `${JSON.stringify(k)} = ${inline(v)}`).join(', ')} }` : Array.isArray(value) ? `[${value.map(inline).join(', ')}]` : JSON.stringify(value);
+  return routes.flatMap(route => {
+    const pairs = route.providerDefinition ? [[route.provider, route.providerDefinition]] : [];
+    if (route.legacyProvider && route.providerDefinition) pairs.push([route.legacyProvider, route.providerDefinition]);
+    const chat = chats.get(route.provider);
+    if (chat) { pairs.push([chatProviderId(route), chat]); if (route.legacyProvider) pairs.push([`cdr_chat_${route.legacyProvider}`, chat]); }
+    return pairs.flatMap(([id, definition]) => ['-c', `model_providers.${id}=${inline(definition)}`]);
+  });
+}