orbit-codex-bridge 0.1.6 → 0.1.8

package/README.md

@@ -4,6 +4,8 @@
 
 Orbit 将电脑连接到 [Orbit 工作台](https://orbit.cubesugar.tech)。在网页中选择电脑和会话，即可查看历史、接收实时回复、发送指令、停止任务和处理审批。桌面已加载的会话会自动热接管，沿用原会话 ID 和执行上下文。
 
+此 npm 包仅安装电脑连接器。网页在 Orbit 工作台打开，账号服务和管理后台单独部署，不包含在电脑客户端中。
+
 ## 安装与连接
 
 需要 Node.js 24+，并在电脑上安装、运行 Codex 桌面应用。
@@ -36,13 +38,18 @@ orbit login
 
 ## 会话输入
 
+- `新建会话`：会话列表右上角的加号可在指定项目目录或个人空间创建 Codex 原生会话，可选模型、普通/计划模式并发送首条消息。项目会保留原生项目归属，个人空间不绑定项目；两种会话均由本机 Codex App Server 执行并持久化。
 - `普通`：按原会话的 Codex 模型、权限和设置继续。
 - `计划`：通过 Codex App Server `turn/start.collaborationMode` 或桌面 IPC 使用原生 Plan 协作模式；不会要求切回电脑，也不会改动正在运行的轮次。
-- `目标`：通过 Codex 原生 `thread/goal/*` API 为原会话设置持久 Goal，支持预算、暂停、继续和清除；桌面 owner 模式可查看目标状态，但当前 IPC 不公开 Goal 写操作，因此需在 Codex 桌面管理。
+- `目标`：新建会话和 App Server 接续会话支持原生 Goal、预算、暂停、继续和清除。桌面热接管会话支持查看目标、编辑及暂存草稿；当前桌面 IPC 不公开 Goal 写操作，页面会明确标注保存限制。草稿保存在当前网页内存，刷新或退出后清除。
+- `人工确认`：命令/文件批准、原生问答选项、MCP 确认表单和权限请求均可在网页处理。仅展示执行器允许的批准选项，权限只能授予该请求提供的范围；已由另一端处理的请求不能再次提交。
 - `添加文件`：每次最多 5 个、每个最多 8 MiB。文件经账号设备中继传到本机，并暂存在项目内 `.orbit-attachments`；Codex 读取原路径。待发送文件 30 分钟清理，已发送文件保留最多 24 小时，任务完成后会提前删除。
-- `电脑文件`：浏览当前会话项目并下载文件；限制在项目根目录内，排除 `.git`、`.codex`、密钥/环境文件和符号链接，单文件最大 8 MiB。
 - 文件附件仅支持已登录账号、在线的自有电脑，以及已加载并已自动热接管的 Codex 桌面原会话。归档会话、子代理和独立续接不支持。
 
+## 账号设置
+
+点击工作台右上角头像，或电脑选择页的“账号设置”，可修改显示名称及密码。用户名是账号的唯一标识，注册后不可修改。修改密码需要输入当前密码和两次新密码，新密码至少 6 个字符；更新后需要重新登录，已绑定的电脑和原有会话保留。
+
 ## 常用命令
 
 | 命令 | 用途 |
@@ -50,6 +57,7 @@ orbit login
 | `orbit login` | 首次授权，或复用已有授权启动后台连接器 |
 | `orbit start` | 启动后台连接器 |
 | `orbit status` | 查看后台运行状态、云端连接状态及日志路径 |
+| `orbit check-update` | 检查电脑连接器当前版本和 npm 最新版本 |
 | `orbit stop` | 停止后台连接器，保留授权 |
 | `orbit restart` | 重启后台连接器 |
 | `orbit logout` | 停止连接并撤销这台电脑的授权 |
@@ -64,6 +72,16 @@ orbit login --server https://your-orbit-domain.com
 
 ## 更新
 
+在工作台“设备与连接”中点击“检查更新”，可以查看所选电脑的连接器版本和 npm 最新版本。发现新版后，复制页面提供的命令，在对应电脑上运行即可。已运行的新版连接器还会在启动时及每 6 小时检查一次；检查超时或网络失败不影响会话，不会自动安装或重启。
+
+也可以在电脑终端手动检查：
+
+```sh
+orbit check-update
+```
+
+检查优先显示后台正在运行的连接器版本。npm 尚未发布的本地测试版会显示“当前版本高于 npm 最新发布版本”，不会提示降级。旧连接器未提供检查接口时，网页会给出先更新连接器的指引。
+
 使用 npx 的用户重新执行安装命令即可获取最新版。全局安装的用户运行：
 
 ```sh
@@ -95,6 +113,16 @@ npx.cmd --yes --package=orbit-codex-bridge@latest orbit rebind
 
 先确认电脑开机并联网，运行 `orbit status` 查看状态。短暂断网会自动恢复；电脑重启后运行 `orbit start`。仍有问题时，按状态命令显示的路径查看 `connector.log`，或使用 `orbit login --foreground` 诊断。
 
+**云端拒绝电脑凭证**
+
+这表示云端没有接受这台电脑保存的连接凭证，电脑尚未上线。请先确认账号没有停用或到期、电脑绑定没有被移除；重复 `orbit login` 会复用原有凭证，不会重新授权。需要重新绑定时运行：
+
+```powershell
+npx.cmd --yes --package=orbit-codex-bridge@latest orbit rebind
+```
+
+网页确认后会生成新的电脑凭证，原 Codex 会话不会删除。如果提示设备额度已满，在账号的电脑列表移除不再使用的旧绑定后重试。若多台电脑在云端升级后同时被拒绝，请由运维检查服务是否仍使用原来的 Relay 数据库。
+
 **能看历史，但会话尚未连接**
 
 在 Codex 桌面打开同一条会话，再点击网页中的“重新连接”。桌面热接管依赖 Codex 内部接口，桌面版本更新后可能需要更新 Orbit。

package/cli.mjs

@@ -9,6 +9,7 @@ import { fileURLToPath } from 'node:url';
 import { createOrbitServer } from './server.mjs';
 import { createRelayAgent } from './relay-agent.mjs';
 import {connectorStatus,installConnectorRuntime,startConnector,stopConnector,superviseConnector} from './lib/connector-service.mjs';
+import {createUpdateChecker} from './lib/updates.mjs';
 
 const defaultServerUrl = 'https://orbit.cubesugar.tech';
 const packageDirectory = path.dirname(fileURLToPath(import.meta.url));
@@ -156,7 +157,7 @@ async function runComputer(config, background = false) {
   if(localUrl)console.log(`检测到本机 Orbit 已运行，将复用 ${localUrl} 并连接云端。`);
   try {
     if(!localUrl){
-      app=createOrbitServer({dataDir:configDirectory(),publicUrl:config.publicUrl});
+      app=createOrbitServer({dataDir:configDirectory(),publicUrl:config.publicUrl,clientOnly:true});
       const info=await app.listen();
       localUrl=info.url;
       console.log(`Orbit 电脑端运行中：${localUrl}`);
@@ -199,13 +200,18 @@ async function runBackground(config) {
   console.log('正在启动 Orbit 后台连接器…');
   const runtime = await installConnectorRuntime(packageDirectory,configDirectory());
   const service = await startConnector({home:configDirectory(),...runtime});
-  const label = service.status === 'online' ? '已连接云端' : service.status === 'blocked' ? service.reason : '正在自动连接云端';
+  if (service.status === 'blocked') {
+    throw new Error(`电脑“${config.deviceName}”尚未上线。${service.reason || '云端拒绝了电脑连接。'}\n诊断日志：${path.join(configDirectory(),'connector.log')}`);
+  }
+  const label = service.status === 'online' ? '已连接云端' : service.status === 'reconnecting' ? '连接暂时中断，正在自动重连' : '正在等待云端确认连接';
   console.log(`电脑“${config.deviceName}”后台运行中 · ${label}`);
   console.log(`手机工作台：${config.publicUrl}`);
   console.log('可以关闭此终端。断网自动重连，异常退出自动恢复；电脑休眠期间无法远程使用。');
   console.log('停止：orbit stop；状态：orbit status；前台诊断：orbit login --foreground');
   console.log(`诊断日志：${path.join(configDirectory(),'connector.log')}`);
-  console.log('手机登录同一 Orbit 账号，选择这台电脑即可，无需输入配对密钥。');
+  console.log(service.status === 'online'
+    ? '手机登录同一 Orbit 账号，选择这台电脑即可，无需输入配对密钥。'
+    : '电脑上线后，手机登录同一 Orbit 账号并选择这台电脑。运行 orbit status 可查看连接结果。');
 }
 
 async function revokeComputer(config) {
@@ -230,7 +236,23 @@ async function main() {
     return;
   }
   if (command === '--help' || command === '-h' || command === 'help') {
-    console.log('Orbit computer connector\n\nUsage:\n  orbit login [--name "My computer"] [--server https://orbit.example.com] [--foreground]\n  orbit start\n  orbit stop\n  orbit restart\n  orbit status\n  orbit logout\n  orbit rebind');
+    console.log('Orbit computer connector\n\nUsage:\n  orbit login [--name "My computer"] [--server https://orbit.example.com] [--foreground]\n  orbit start\n  orbit stop\n  orbit restart\n  orbit status\n  orbit check-update\n  orbit logout\n  orbit rebind');
+    return;
+  }
+  if (command === 'check-update') {
+    const service = await connectorStatus(configDirectory());
+    const currentVersion = service?.version || JSON.parse(await fs.readFile(path.join(packageDirectory,'package.json'),'utf8')).version;
+    const result = await createUpdateChecker(currentVersion).check();
+    console.log(`电脑连接器版本：${result.currentVersion}`);
+    if (result.latestVersion) console.log(`npm 最新版本：${result.latestVersion}`);
+    const messages = {
+      'update-available':'发现新版本。请在这台电脑上执行以下命令，更新后会复用现有授权：',
+      'up-to-date':'当前已是最新版本。',
+      ahead:'当前版本高于 npm 最新发布版本。',
+      unavailable:'暂时无法检查更新，请稍后重试；现有连接不受影响。'
+    };
+    console.log(messages[result.status]);
+    if (result.available) console.log(result.command);
     return;
   }
   const namedIndex = args.indexOf('--name');
@@ -254,7 +276,7 @@ async function main() {
     const service = await connectorStatus(configDirectory());
     const labels = {online:'在线',connecting:'连接中',reconnecting:'断线重连中',blocked:'连接被拒绝',starting:'启动中',restarting:'异常恢复中'};
     console.log(existing
-      ? `电脑：${existing.deviceName}\n工作台：${existing.publicUrl}\n后台服务：${service ? labels[service.status] || service.status : '未运行'}${service?.reason ? ` · ${service.reason}` : ''}\n配置文件：${configPath()}\n日志文件：${path.join(configDirectory(),'connector.log')}`
+      ? `电脑：${existing.deviceName}\n工作台：${existing.publicUrl}\n连接器版本：${service?.version || JSON.parse(await fs.readFile(path.join(packageDirectory,'package.json'),'utf8')).version}\n后台服务：${service ? labels[service.status] || service.status : '未运行'}${service?.reason ? ` · ${service.reason}` : ''}\n配置文件：${configPath()}\n日志文件：${path.join(configDirectory(),'connector.log')}`
       : '此电脑尚未连接 Orbit。运行 orbit login 完成连接。');
     return;
   }

package/lib/approvals.mjs

@@ -0,0 +1,97 @@
+import { isDeepStrictEqual } from 'node:util';
+
+const simpleDecisions = ['accept', 'acceptForSession', 'decline', 'cancel'];
+
+function userAnswers(params, body) {
+  if (body.decision !== 'answers') throw new Error('请提交问题的回答。');
+  const answers = {};
+  for (const question of params.questions || []) {
+    const value = body.answers?.[question.id];
+    if (typeof value !== 'string' || !value.trim() || value.length > 4000) throw new Error('请回答所有问题。');
+    if (question.options?.length && !question.isOther && !question.options.some(option => option.label === value)) {
+      throw new Error('请选择 Codex 提供的回答选项。');
+    }
+    Object.defineProperty(answers, question.id, { value:{ answers:[value] }, enumerable:true });
+  }
+  return { answers };
+}
+
+function permissionResponse(params, body) {
+  if (body.decision === 'decline') return { permissions:{}, scope:'turn' };
+  if (body.decision !== 'grant' || !['turn', 'session'].includes(body.scope || 'turn')) throw new Error('无效的权限决定或授权范围。');
+  const requested = params.permissions || {};
+  const granted = body.permissions;
+  if (!granted || Array.isArray(granted) || typeof granted !== 'object'
+    || Object.keys(granted).some(key => !['network', 'fileSystem'].includes(key))) throw new Error('权限超出 Codex 请求范围。');
+  const permissions = {};
+  if (granted.network !== undefined) {
+    if (requested.network?.enabled !== true || granted.network?.enabled !== true
+      || Object.keys(granted.network).some(key => key !== 'enabled')) throw new Error('网络权限超出 Codex 请求范围。');
+    permissions.network = { enabled:true };
+  }
+  if (granted.fileSystem !== undefined) {
+    const requestedFs = requested.fileSystem || {};
+    const grantedFs = granted.fileSystem;
+    if (!grantedFs || Array.isArray(grantedFs) || typeof grantedFs !== 'object'
+      || Object.keys(grantedFs).some(key => !['entries', 'read', 'write'].includes(key))) throw new Error('文件权限超出 Codex 请求范围。');
+    const fileSystem = {};
+    for (const key of ['entries', 'read', 'write']) {
+      if (grantedFs[key] === undefined) continue;
+      if (!Array.isArray(grantedFs[key]) || !Array.isArray(requestedFs[key])
+        || grantedFs[key].some(value => !requestedFs[key].some(candidate => isDeepStrictEqual(candidate, value)))) {
+        throw new Error('文件权限超出 Codex 请求范围。');
+      }
+      fileSystem[key] = grantedFs[key];
+    }
+    if (requestedFs.globScanMaxDepth !== undefined) fileSystem.globScanMaxDepth = requestedFs.globScanMaxDepth;
+    permissions.fileSystem = fileSystem;
+  }
+  return { permissions, scope:body.scope || 'turn' };
+}
+
+function elicitationResponse(params, body) {
+  if (!['accept', 'decline', 'cancel'].includes(body.decision)) throw new Error('无效的人工确认决定。');
+  if (body.decision !== 'accept') return { action:body.decision, content:null };
+  if (params.mode === 'url') return { action:'accept', content:null };
+  const schema = params.requestedSchema;
+  const content = body.content;
+  if (!schema?.properties || !content || Array.isArray(content) || typeof content !== 'object') throw new Error('人工确认表单格式无效。');
+  for (const key of schema.required || []) if (!Object.hasOwn(content, key)) throw new Error('请填写所有必填项。');
+  for (const [key, value] of Object.entries(content)) {
+    const property = schema.properties[key];
+    if (!Object.hasOwn(schema.properties, key) || !property) throw new Error('表单字段已变化，请刷新后重试。');
+    if (property.type === 'boolean' ? typeof value !== 'boolean'
+      : property.type === 'integer' ? !Number.isSafeInteger(value)
+        : property.type === 'number' ? typeof value !== 'number' || !Number.isFinite(value)
+          : typeof value !== 'string' || value.length > 4000) throw new Error('表单字段类型无效。');
+    if (Array.isArray(property.enum) && !property.enum.some(entry => isDeepStrictEqual(entry, value))) throw new Error('请选择提供的表单选项。');
+    if (typeof value === 'number' && (property.minimum !== undefined && value < property.minimum
+      || property.maximum !== undefined && value > property.maximum)) throw new Error('数值超出表单允许范围。');
+    if (typeof value === 'string' && (property.minLength !== undefined && value.length < property.minLength
+      || property.maxLength !== undefined && value.length > property.maxLength)) throw new Error('文本长度不符合表单要求。');
+  }
+  return { action:'accept', content };
+}
+
+export function approvalResponse(request, body) {
+  const params = request.params || {};
+  if (request.method === 'item/tool/requestUserInput') return userAnswers(params, body);
+  if (request.method === 'item/permissions/requestApproval') return permissionResponse(params, body);
+  if (request.method === 'mcpServer/elicitation/request') return elicitationResponse(params, body);
+  if (!['item/commandExecution/requestApproval', 'item/fileChange/requestApproval'].includes(request.method)) throw new Error('不支持的审批类型。');
+  let decision = body.decision;
+  if (params.kind === 'humanCommand' && !['accept', 'decline', 'cancel'].includes(decision)) throw new Error('此请求需要本次人工确认。');
+  if (decision === 'acceptWithExecpolicyAmendment' && request.method === 'item/commandExecution/requestApproval') {
+    const proposed = params.proposedExecpolicyAmendment;
+    if (!Array.isArray(proposed) || !proposed.length || !isDeepStrictEqual(body.execpolicyAmendment, proposed)) throw new Error('命令策略建议已变化，未应用。');
+    decision = { acceptWithExecpolicyAmendment:{ execpolicy_amendment:proposed } };
+  } else if (decision === 'applyNetworkPolicyAmendment' && request.method === 'item/commandExecution/requestApproval') {
+    const amendment = (params.proposedNetworkPolicyAmendments || []).find(entry => isDeepStrictEqual(entry, body.networkPolicyAmendment));
+    if (!amendment) throw new Error('网络策略建议已变化，未应用。');
+    decision = { applyNetworkPolicyAmendment:{ network_policy_amendment:amendment } };
+  } else if (!simpleDecisions.includes(decision)) throw new Error('无效审批决定。');
+  if (Array.isArray(params.availableDecisions) && !params.availableDecisions.some(entry => isDeepStrictEqual(entry, decision))) {
+    throw new Error('Codex 不允许此审批选项，请刷新后重试。');
+  }
+  return { decision };
+}

package/lib/client-files.mjs

@@ -0,0 +1,37 @@
+export const clientFiles = Object.freeze([
+  'cli.mjs',
+  'orbit',
+  'server.mjs',
+  'relay-agent.mjs',
+  'lib/approvals.mjs',
+  'lib/client-files.mjs',
+  'lib/connector-service.mjs',
+  'lib/desktop.mjs',
+  'lib/resume-manager.mjs',
+  'lib/rpc.mjs',
+  'lib/store.mjs',
+  'lib/updates.mjs',
+  'scripts/verify-client-package.mjs'
+]);
+
+export function clientManifest(source) {
+  if (!/^\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?$/.test(source.version) || typeof source.dependencies?.ws !== 'string') {
+    throw new Error('客户端版本或依赖配置无效。');
+  }
+  return {
+    name:'orbit-codex-bridge',
+    version:source.version,
+    type:'module',
+    description:'Connect your computer and original Codex conversations to Orbit.',
+    engines:{ node:'>=24' },
+    bin:{ orbit:'orbit' },
+    files:[...clientFiles],
+    scripts:{
+      start:'node server.mjs',
+      prepublishOnly:'node scripts/verify-client-package.mjs'
+    },
+    dependencies:{ ws:source.dependencies.ws },
+    publishConfig:{ registry:'https://registry.npmjs.org/', access:'public' },
+    orbitDistribution:'client'
+  };
+}

package/lib/connector-service.mjs

@@ -4,6 +4,7 @@ import http from 'node:http';
 import path from 'node:path';
 import {spawn} from 'node:child_process';
 import {createRequire} from 'node:module';
+import {clientFiles,clientManifest} from './client-files.mjs';
 
 const stateFile = home => path.join(home,'service.json');
 const pause = milliseconds => new Promise(resolve => setTimeout(resolve,milliseconds));
@@ -51,7 +52,7 @@ async function packageRoot(resolver, name) {
 }
 
 export async function installConnectorRuntime(source, home) {
-  const manifest = JSON.parse(await fs.readFile(path.join(source,'package.json'),'utf8'));
+  const manifest = clientManifest(JSON.parse(await fs.readFile(path.join(source,'package.json'),'utf8')));
   const target = path.join(home,'runtime',manifest.version);
   try { await fs.access(path.join(target,'ready')); return {cliPath:path.join(target,'cli.mjs'),version:manifest.version}; }
   catch {}
@@ -73,9 +74,12 @@ export async function installConnectorRuntime(source, home) {
     }
   }
   try {
-    for (const filename of ['package.json',...manifest.files]) {
-      await fs.cp(path.join(source,filename),path.join(temporary,filename),{recursive:true});
+    for (const filename of clientFiles) {
+      await fs.mkdir(path.dirname(path.join(temporary,filename)),{recursive:true});
+      await fs.copyFile(path.join(source,filename),path.join(temporary,filename));
     }
+    await fs.copyFile(path.join(source,'README.md'),path.join(temporary,'README.md'));
+    await fs.writeFile(path.join(temporary,'package.json'),`${JSON.stringify(manifest,null,2)}\n`);
     for (const name of Object.keys(manifest.dependencies || {})) await copyDependency(name,createRequire(path.join(source,'package.json')));
     await fs.writeFile(path.join(temporary,'ready'),manifest.version,{mode:0o600});
     try { await fs.rename(temporary,target); }
@@ -109,17 +113,22 @@ export async function startConnector({home,cliPath,version}) {
     });
   } finally {await diagnostic.close();}
   let exited = false;
+  let latestState = null;
   child.once('exit',() => {exited = true;});
   child.unref();
   for (let attempt = 0; attempt < 100; attempt++) {
     const current = await connectorStatus(home);
-    if (current?.version === version && current.workerReady) return current;
+    if (current?.version === version && current.workerReady) {
+      latestState = current;
+      if (['online','blocked','reconnecting'].includes(current.status)) return current;
+    }
     if (exited) {
       const diagnostic = (await fs.readFile(startupLog,'utf8').catch(() => '')).slice(-1500);
       throw new Error(`后台连接器启动失败。${diagnostic}\n诊断日志：${startupLog}`);
     }
     await pause(150);
   }
+  if (latestState) return latestState;
   throw new Error(`后台连接器未就绪。诊断日志：${path.join(home,'connector.log')}`);
 }
 

package/lib/desktop.mjs

@@ -4,14 +4,16 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { EventEmitter } from 'node:events';
 import { messageFromItem } from './store.mjs';
+import { approvalResponse } from './approvals.mjs';
 
 const maxFrame = 32 * 1024 * 1024;
-const versions = { initialize: 0, 'thread-owner-discovery': 1, 'thread-follower-read-model-settings': 1, 'thread-follower-update-thread-settings': 2, 'thread-follower-start-turn': 2, 'thread-follower-steer-turn': 1, 'thread-follower-interrupt-turn': 4, 'thread-follower-command-approval-decision': 1, 'thread-follower-file-approval-decision': 1, 'thread-follower-submit-user-input': 1, 'thread-follower-permissions-request-approval-response': 1 };
+const versions = { initialize: 0, 'thread-owner-discovery': 1, 'thread-follower-read-model-settings': 1, 'thread-follower-update-thread-settings': 2, 'thread-follower-start-turn': 2, 'thread-follower-steer-turn': 1, 'thread-follower-interrupt-turn': 4, 'thread-follower-command-approval-decision': 1, 'thread-follower-file-approval-decision': 1, 'thread-follower-submit-user-input': 1, 'thread-follower-permissions-request-approval-response': 1, 'thread-follower-submit-mcp-server-elicitation-response': 1 };
 const approvalMethods = new Map([
   ['item/commandExecution/requestApproval', 'thread-follower-command-approval-decision'],
   ['item/fileChange/requestApproval', 'thread-follower-file-approval-decision'],
   ['item/tool/requestUserInput', 'thread-follower-submit-user-input'],
-  ['item/permissions/requestApproval', 'thread-follower-permissions-request-approval-response']
+  ['item/permissions/requestApproval', 'thread-follower-permissions-request-approval-response'],
+  ['mcpServer/elicitation/request', 'thread-follower-submit-mcp-server-elicitation-response']
 ]);
 
 export class DesktopUnavailableError extends Error {
@@ -87,6 +89,7 @@ export class DesktopRpc extends EventEmitter {
     this.clientId = 'initializing-client';
     this.threads = new Map();
     this.approvals = new Map();
+    this.replyingApprovals = new Set();
     this.pending = new Map();
     this.attaching = new Map();
     this.starting = new Set();
@@ -397,28 +400,19 @@ export class DesktopRpc extends EventEmitter {
   async replyApproval(key, body) {
     const request = this.approvals.get(String(key));
     if (!request) throw new Error('审批已被桌面处理或已失效。');
-    const thread = await this.assertOwner(request.params.threadId);
-    if (this.approvals.get(String(key)) !== request) throw new Error('审批状态已变化，请刷新。');
-    let payload;
-    if (request.method === 'item/tool/requestUserInput') {
-      const answers = {};
-      for (const question of request.params.questions || []) {
-        const answer = body.answers?.[question.id];
-        if (typeof answer !== 'string' || !answer.trim() || answer.length > 4000) throw new Error('请回答所有问题。');
-        answers[question.id] = { answers: [answer] };
-      }
-      payload = { response: { answers } };
-    } else if (request.method === 'item/permissions/requestApproval') {
-      if (body.decision !== 'decline') throw new Error('扩大环境权限仍需在桌面处理。');
-      payload = { response: { permissions: {}, scope: 'turn' } };
-    } else {
-      if (!['accept', 'decline'].includes(body.decision)) throw new Error('无效审批决定。');
-      payload = { decision: body.decision };
-    }
-    await this.request(approvalMethods.get(request.method), { conversationId: request.params.threadId, requestId: request.originalId, ...payload }, thread.ownerClientId);
-    this.approvals.delete(String(key));
-    this.publish(request.params.threadId);
-    return { resolved: true };
+    if (this.replyingApprovals.has(String(key))) throw new Error('审批回复正在提交，请勿重复操作。');
+    this.replyingApprovals.add(String(key));
+    try {
+      const thread = await this.assertOwner(request.params.threadId);
+      if (this.approvals.get(String(key)) !== request) throw new Error('审批状态已变化，请刷新。');
+      const response = approvalResponse(request, body);
+      const payload = Object.hasOwn(response, 'decision') ? response : { response };
+      const params = { conversationId:request.params.threadId, requestId:request.originalId, ...payload };
+      await this.request(approvalMethods.get(request.method), params, thread.ownerClientId);
+      if (this.approvals.get(String(key)) === request) this.approvals.delete(String(key));
+      this.publish(request.params.threadId);
+      return { resolved: true };
+    } finally { this.replyingApprovals.delete(String(key)); }
   }
 
   detach(id, reason, reasonCode = 'DESKTOP_THREAD_UNAVAILABLE') {

package/lib/resume-manager.mjs

@@ -35,11 +35,11 @@ export class ResumeManager extends EventEmitter {
       threadId:id, attached:Boolean(session.rpc.connected), mode:'same-id-resume',
       ownerClientId:null, connectionId:null, turnId:thread.turnId || null, revision:null,
       permissionMode:thread.writable ? 'workspace-write' : 'read-only',
-      model:session.model || null, effort:null, collaborationMode:'default',
+      model:thread.model || session.model || null, effort:thread.effort ?? null, collaborationMode:thread.collaborationMode?.mode || 'default',
       goal:session.goal || null, context:null, messages:[],
-      approvals:[...session.rpc.approvals.values()]
-        .filter(request => request.params?.threadId === id)
-        .map(request => ({ ...request.params, requestId:String(request.id), method:request.method }))
+      approvals:[...session.rpc.approvals.entries()]
+        .filter(([,request]) => request.params?.threadId === id)
+        .map(([requestId,request]) => ({ ...request.params, requestId, method:request.method }))
     };
   }
 
@@ -83,6 +83,38 @@ export class ResumeManager extends EventEmitter {
     finally { if (this.pending.get(id) === operation) this.pending.delete(id); }
   }
 
+  async startNew({ cwd, projectId = null, model = null, text, writable = true, mode = 'default', onCreated = () => {} } = {}) {
+    const rpc = this.createRpc({ home:this.home });
+    let session;
+    try {
+      const created = await rpc.startThread({ cwd, model, projectId, writable });
+      session = {
+        id:created.threadId, rpc, model:created.model || model, goal:null,
+        releaseWhenIdle:false, closing:null, eventListener:null
+      };
+      session.eventListener = event => this.onEvent(session, event);
+      rpc.on('event', session.eventListener);
+      this.sessions.set(session.id, session);
+      onCreated(created.threadId);
+      this.emit('event', { method:'orbit/engine', params:{
+        connected:true, mode:'desktop', desktopConnected:false, resumedConnected:true
+      } });
+      try {
+        const turn = await rpc.startTurn(session.id, text, writable, model ? { model, effort:null } : null, { mode });
+        return { ...created, ...turn, mode:'same-id-resume' };
+      } catch(error) {
+        return { ...created, turnId:null, completed:true, mode:'same-id-resume', startError:error.message };
+      }
+    } catch(error) {
+      if(session) {
+        this.sessions.delete(session.id);
+        rpc.off('event',session.eventListener);
+      }
+      await rpc.close();
+      throw error;
+    }
+  }
+
   onEvent(session, event) {
     if (event.method === 'thread/goal/updated' && event.params?.threadId === session.id) {
       session.goal = event.params.goal || null;
@@ -112,8 +144,8 @@ export class ResumeManager extends EventEmitter {
       return;
     }
     this.emit('event', event);
-    if (event.method === 'turn/completed' && event.params?.threadId === session.id
-      && session.releaseWhenIdle && !session.rpc.threads.get(session.id)?.turnId) {
+    if (['turn/completed','orbit/turn-settled'].includes(event.method) && event.params?.threadId === session.id
+      && session.releaseWhenIdle && !session.rpc.threads.get(session.id)?.turnId && !session.rpc.starting?.has(session.id)) {
       void this.closeSession(session);
     }
   }
@@ -147,7 +179,7 @@ export class ResumeManager extends EventEmitter {
   async release(id) {
     const session = this.sessions.get(id);
     if (!session) return;
-    if (session.rpc.threads.get(id)?.turnId) {
+    if (session.rpc.threads.get(id)?.turnId || session.rpc.starting?.has(id)) {
       session.releaseWhenIdle = true;
       return;
     }

package/lib/rpc.mjs

@@ -3,7 +3,9 @@ import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import fs from 'node:fs';
 import path from 'node:path';
+import crypto from 'node:crypto';
 import WebSocket from 'ws';
+import { approvalResponse } from './approvals.mjs';
 
 export function findCodexBinary() {
   if (process.env.ORBIT_CODEX_BIN) return process.env.ORBIT_CODEX_BIN;
@@ -25,6 +27,7 @@ export class CodexRpc extends EventEmitter {
     this.tokenFile = tokenFile;
     this.pending = new Map();
     this.approvals = new Map();
+    this.approvalNamespace = crypto.randomUUID();
     this.threads = new Map();
     this.starting = new Set();
     this.sequence = 0;
@@ -106,16 +109,21 @@ export class CodexRpc extends EventEmitter {
       return;
     }
     if (message.id !== undefined && message.method) {
-      const supported = ['item/commandExecution/requestApproval','item/fileChange/requestApproval','item/tool/requestUserInput','item/permissions/requestApproval'];
+      const supported = ['item/commandExecution/requestApproval','item/fileChange/requestApproval','item/tool/requestUserInput','item/permissions/requestApproval','mcpServer/elicitation/request'];
       if (!supported.includes(message.method) || !this.threads.has(message.params?.threadId)) {
         this.send({ id: message.id, error: { code: -32601, message: 'This client does not implement the requested host tool.' } });
         return;
       }
-      this.approvals.set(String(message.id), message);
-      this.emit('event', { method: 'orbit/approval', params: { requestId: String(message.id), method: message.method, ...message.params } });
+      const requestId = `${this.approvalNamespace}:${message.id}`;
+      this.approvals.set(requestId, message);
+      this.emit('event', { method: 'orbit/approval', params: { ...message.params, requestId, method: message.method } });
       return;
     }
-    if (message.method === 'serverRequest/resolved') this.approvals.delete(String(message.params?.requestId));
+    if (message.method === 'serverRequest/resolved') {
+      const requestId = `${this.approvalNamespace}:${message.params?.requestId}`;
+      this.approvals.delete(requestId);
+      message = { ...message, params:{ ...message.params, requestId } };
+    }
     if (message.method === 'turn/started' && this.threads.has(message.params?.threadId)) this.threads.get(message.params.threadId).turnId = message.params.turn.id;
     if (message.method === 'turn/completed' && this.threads.has(message.params?.threadId)) {
       const thread = this.threads.get(message.params.threadId);
@@ -138,6 +146,28 @@ export class CodexRpc extends EventEmitter {
     });
   }
 
+  async startThread({ cwd, model = null, projectId = null, writable = true } = {}) {
+    await this.connect();
+    const result = await this.request('thread/start', {
+      cwd,
+      projectId,
+      approvalPolicy: 'on-request',
+      sandbox: writable ? 'workspace-write' : 'read-only',
+      ...(model ? { model } : {})
+    });
+    const thread = result?.thread;
+    if (typeof thread?.id !== 'string' || !/^[a-zA-Z0-9_-]{8,120}$/.test(thread.id)) {
+      throw new Error('Codex 未返回有效的新会话 ID。');
+    }
+    this.threads.set(thread.id, {
+      turnId:null,lastCompletedTurnId:null,writable:Boolean(writable),
+      model:result.model||thread.model||null,
+      effort:result.reasoningEffort??thread.reasoningEffort??null,
+      collaborationMode:result.collaborationMode||{mode:'default',settings:{}}
+    });
+    return { threadId:thread.id, model:result.model||thread.model||null, cwd:thread.cwd||cwd, projectId:thread.projectId||projectId };
+  }
+
   async startTurn(id, text, writable, settings = null, options = {}) {
     if (this.starting.has(id)) throw new Error('此会话正在发送，请勿并发提交。');
     this.starting.add(id);
@@ -169,7 +199,10 @@ export class CodexRpc extends EventEmitter {
       if(settings?.model)thread.model=settings.model;
       if(settings&&Object.hasOwn(settings,'effort'))thread.effort=settings.effort;
       return { threadId: id, turnId: result.turn.id, completed };
-    } finally { this.starting.delete(id); }
+    } finally {
+      this.starting.delete(id);
+      this.emit('event', { method:'orbit/turn-settled', params:{ threadId:id } });
+    }
   }
 
   async interrupt(id) {
@@ -181,24 +214,10 @@ export class CodexRpc extends EventEmitter {
   replyApproval(id, body) {
     const request = this.approvals.get(String(id));
     if (!request) throw new Error('审批已结束或不属于当前桥接实例。');
-    let result;
-    if (request.method === 'item/tool/requestUserInput') {
-      const answers = {};
-      for (const question of request.params.questions || []) {
-        const value = body.answers?.[question.id];
-        if (typeof value !== 'string' || !value.trim() || value.length > 4000) throw new Error('请回答所有问题。');
-        answers[question.id] = { answers: [value] };
-      }
-      result = { answers };
-    } else if (request.method === 'item/permissions/requestApproval') {
-      if (body.decision !== 'decline') throw new Error('首版暂不支持扩大权限，请在本机处理。');
-      result = { permissions: {}, scope: 'turn' };
-    } else {
-      if (!['accept','decline'].includes(body.decision)) throw new Error('无效审批决定。');
-      result = { decision: body.decision };
-    }
+    const result = approvalResponse(request, body);
     this.send({ id: request.id, result });
     this.approvals.delete(String(id));
+    this.emit('event', { method:'serverRequest/resolved', params:{ threadId:request.params.threadId, requestId:String(id) } });
     return { resolved: true };
   }
 

package/lib/store.mjs

@@ -92,6 +92,7 @@ export class NativeStore {
       id: row.id, title: row.name || row.title || '未命名会话',
       preview: cleanText(row.preview || row.first_user_message || '').slice(0, 220), cwd,
       projectId: row.project_id || cwd || 'ungrouped', projectName: projects.get(row.project_id)?.name || leaf,
+      nativeProjectId: row.project_id || null,
       source: row.source, provider: row.model_provider, model: row.model || null,
       archived: Boolean(row.archived), pinned: Boolean(row.is_pinned), locked: this.locked(row.id),
       createdAt: row.created_at_ms || row.created_at * 1000, updatedAt: row.updated_at_ms || row.updated_at * 1000,
@@ -103,6 +104,11 @@ export class NativeStore {
     try { projects = new Map(this.state.prepare('SELECT id,name FROM projects').all().map(project => [project.id, project])); } catch {}
     return this.state.prepare('SELECT * FROM threads ORDER BY updated_at DESC').all().map(row => this.summary(row, projects));
   }
+  projectWorkspaces() {
+    try {
+      return this.state.prepare('SELECT projects.id AS projectId,projects.name AS label,project_roots.path AS cwd FROM projects JOIN project_roots ON project_roots.project_id=projects.id ORDER BY projects.position,project_roots.position').all();
+    } catch { return []; }
+  }
   historyFor(id, before = null, limit = 60) {
     const row = this.row(id);
     if (!row) return null;