orbit-codex-bridge 0.1.2 → 0.1.6

package/README.md

@@ -30,9 +30,18 @@ orbit login
 1. 命令会打开电脑授权页面，登录或注册 Orbit 账号，确认添加这台电脑。
 2. 手机打开 [orbit.cubesugar.tech](https://orbit.cubesugar.tech)，登录同一账号。
 3. 登录后选择这台电脑；账号会自动完成安全配对，无需扫码或输入本机密钥。
-4. 选择原有会话，开始使用。尚未加载的会话可先在 Codex 桌面打开，再点“重新连接”。
+4. 选择任意普通原有会话即可连接。Orbit 优先接入 Codex 桌面当前执行者；桌面未加载时尝试由 Codex App Server 按原会话 ID 接续，不会新建对话。若该会话仍被其他执行者占用，会明确提示并拒绝重复写入。
 
-授权信息保存在电脑本地，下次启动会自动复用。连接器默认在当前用户的后台运行，可以关闭安装终端；断网后自动重连，工作进程异常退出后自动恢复。电脑需要保持开机、联网，Codex 桌面需要保持运行。电脑重启后运行 `orbit start` 恢复连接。
+授权信息保存在电脑本地，下次启动会自动复用。连接器默认在当前用户的后台运行，可以关闭安装终端；断网后自动重连，工作进程异常退出后自动恢复。电脑需要保持开机、联网。桌面热接管需 Codex 桌面运行；若会话未由桌面持有，则尝试通过 Codex App Server 按原 ID 接续。电脑重启后运行 `orbit start` 恢复连接。
+
+## 会话输入
+
+- `普通`：按原会话的 Codex 模型、权限和设置继续。
+- `计划`：通过 Codex App Server `turn/start.collaborationMode` 或桌面 IPC 使用原生 Plan 协作模式；不会要求切回电脑，也不会改动正在运行的轮次。
+- `目标`：通过 Codex 原生 `thread/goal/*` API 为原会话设置持久 Goal，支持预算、暂停、继续和清除；桌面 owner 模式可查看目标状态，但当前 IPC 不公开 Goal 写操作，因此需在 Codex 桌面管理。
+- `添加文件`：每次最多 5 个、每个最多 8 MiB。文件经账号设备中继传到本机，并暂存在项目内 `.orbit-attachments`；Codex 读取原路径。待发送文件 30 分钟清理，已发送文件保留最多 24 小时，任务完成后会提前删除。
+- `电脑文件`：浏览当前会话项目并下载文件；限制在项目根目录内，排除 `.git`、`.codex`、密钥/环境文件和符号链接，单文件最大 8 MiB。
+- 文件附件仅支持已登录账号、在线的自有电脑，以及已加载并已自动热接管的 Codex 桌面原会话。归档会话、子代理和独立续接不支持。
 
 ## 常用命令
 

package/lib/desktop.mjs

@@ -1,5 +1,7 @@
 import net from 'node:net';
 import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
 import { EventEmitter } from 'node:events';
 import { messageFromItem } from './store.mjs';
 
@@ -231,7 +233,16 @@ export class DesktopRpc extends EventEmitter {
     }
     if (this.attaching.has(id)) return this.attaching.get(id);
     const operation = (async () => {
-      const owner = await this.request('thread-owner-discovery', { conversationId: id, hostId: 'local' });
+      let owner=null;
+      for(let attempt=0;attempt<2;attempt++){
+        try{
+          owner=await this.request('thread-owner-discovery',{conversationId:id,hostId:'local'});
+        }catch(error){
+          if(error.code!=='DESKTOP_THREAD_UNAVAILABLE'||attempt===1)throw error;
+        }
+        if(owner?.ownerClientId)break;
+        if(attempt===0)await new Promise(resolve=>setTimeout(resolve,180));
+      }
       if (!owner.ownerClientId) throw new DesktopUnavailableError('这条原会话尚未在 Codex 桌面加载。请在电脑上打开它，再点击“重新连接”。');
       const result = await this.request('thread-follower-read-model-settings', { conversationId: id }, owner.ownerClientId);
       if (result.settings?.resumeState !== 'resumed') throw new Error('桌面会话尚未就绪，请先在 Codex 中打开。');
@@ -261,6 +272,13 @@ export class DesktopRpc extends EventEmitter {
       permissionMode: state?.currentPermissions?.sandboxPolicy?.type || state?.latestThreadSettings?.sandboxPolicy?.type || 'desktop-inherited',
       model: state?.latestThreadSettings?.model || state?.latestModel || null,
       effort: state?.latestThreadSettings?.effort ?? state?.latestReasoningEffort ?? null,
+      collaborationMode:state?.latestCollaborationMode?.mode||'default',
+      goal:state?.threadGoal?{
+        objective:state.threadGoal.objective,
+        status:state.threadGoal.status,
+        tokenBudget:state.threadGoal.tokenBudget??null,
+        tokensUsed:state.threadGoal.tokensUsed??0
+      }:null,
       context: desktopContext(state),
       messages: state ? desktopMessages(state) : [],
       approvals: [...this.approvals.values()].filter(request => request.params.threadId === id).map(request => ({ ...request.params, requestId: String(request.id), method: request.method }))
@@ -297,8 +315,8 @@ export class DesktopRpc extends EventEmitter {
     return thread;
   }
 
-  async startTurn(id, text) { return this.writeMessage(id, text, false); }
-  async steer(id, text, expectedTurnId) { return this.writeMessage(id, text, true, expectedTurnId); }
+  async startTurn(id, text, options = {}) { return this.writeMessage(id, text, false, null, options); }
+  async steer(id, text, expectedTurnId, options = {}) { return this.writeMessage(id, text, true, expectedTurnId, options); }
 
   async updateThreadSettings(id, model, effort, expectedModel, expectedEffort) {
     if (this.starting.has(id) || this.updatingSettings.has(id)) throw new Error('会话正在处理另一项操作，请稍后重试。');
@@ -322,21 +340,50 @@ export class DesktopRpc extends EventEmitter {
     } finally { this.updatingSettings.delete(id); }
   }
 
-  async writeMessage(id, text, steering, expectedTurnId) {
+  async writeMessage(id, text, steering, expectedTurnId, options = {}) {
     if (this.starting.has(id) || this.updatingSettings.has(id)) throw new Error('此会话正在处理其他操作，请勿并发提交。');
     this.starting.add(id);
     try {
       const thread = await this.assertOwner(id);
       if (steering ? !expectedTurnId || thread.turnId !== expectedTurnId : Boolean(thread.turnId)) throw new Error('任务状态已变化，请刷新后选择续聊或追加指令。');
+      const mode=options.mode||'default';
+      if(!['default','plan','goal'].includes(mode))throw new Error('Codex 轮次模式无效。');
+      const attachments=Array.isArray(options.attachments)?options.attachments:[];
+      if(attachments.length>5||attachments.some(file=>{
+        if(!file||typeof file.label!=='string'||typeof file.path!=='string'||!path.isAbsolute(file.path)||file.fsPath!==file.path||!thread.state.cwd)return true;
+        try{
+          const workspace=fs.realpathSync(thread.state.cwd);
+          const filename=path.resolve(file.path);
+          const relative=path.relative(workspace,filename);
+          const attachmentRoot=path.join(workspace,'.orbit-attachments');
+          const resolved=fs.realpathSync(filename);
+          const stat=fs.lstatSync(filename);
+          return !relative||relative==='..'||relative.startsWith(`..${path.sep}`)||path.isAbsolute(relative)
+            ||path.dirname(filename)!==attachmentRoot||resolved!==filename||stat.isSymbolicLink()||!stat.isFile()||stat.size>8*1024*1024;
+        }catch{return true}
+      }))throw new Error('文件附件无效、位于工作区外或数量超限。');
+      const baseMode=thread.state.latestCollaborationMode||{mode:'default',settings:{}};
+      const selectedMode=mode==='plan'?'plan':baseMode.mode==='plan'?'default':baseMode.mode||'default';
+      const developerInstructions=baseMode.settings?.developer_instructions??null;
+      const collaborationMode={
+        mode:selectedMode,
+        settings:{
+          ...baseMode.settings,
+          model:baseMode.settings?.model||thread.state.latestThreadSettings?.model||thread.state.latestModel||'',
+          reasoning_effort:baseMode.settings?.reasoning_effort??thread.state.latestThreadSettings?.effort??thread.state.latestReasoningEffort??null,
+          developer_instructions:developerInstructions
+        }
+      };
       const messageId = crypto.randomUUID();
       const input = [{ type: 'text', text, text_elements: [] }];
-      const restoreMessage = { id: messageId, text, cwd: thread.state.cwd, createdAt: Date.now(), context: { prompt: text, addedFiles: [], fileAttachments: [], imageAttachments: [], ideContext: null, workspaceRoots: [thread.state.cwd] } };
+      const fileAttachments=attachments.map(({label,path:filename})=>({label,path:filename,fsPath:filename}));
+      const restoreMessage = { id: messageId, text, cwd: thread.state.cwd, createdAt: Date.now(), context: { prompt: text, addedFiles: [], fileAttachments, uploadedFileAttachments:[], imageAttachments: [], ideContext: null, workspaceRoots: [thread.state.cwd] } };
       let result;
-      if (steering) result = await this.request('thread-follower-steer-turn', { conversationId: id, input, restoreMessage, clientUserMessageId: messageId, attachments: [] }, thread.ownerClientId);
-      else result = await this.request('thread-follower-start-turn', { conversationId: id, turnStart: { request: { threadId: id, input, clientUserMessageId: messageId, turnTrigger: 'composer' }, context: { restoreMessage } } }, thread.ownerClientId);
+      if (steering) result = await this.request('thread-follower-steer-turn', { conversationId: id, input, restoreMessage, clientUserMessageId: messageId, attachments:fileAttachments }, thread.ownerClientId);
+      else result = await this.request('thread-follower-start-turn', { conversationId: id, turnStart: { request: { threadId: id, input, clientUserMessageId: messageId, turnTrigger: 'composer',collaborationMode }, context: { restoreMessage,attachments:fileAttachments,collaborationMode } } }, thread.ownerClientId);
       const response = result.result || result;
       const turnId = response.turnId || response.turn?.id || this.threads.get(id)?.turnId || null;
-      return { threadId: id, turnId, completed: typeof response.completed === 'boolean' ? response.completed : Boolean(!steering && !turnId), steering, sharedExecution: true };
+      return { threadId:id,turnId,completed:typeof response.completed==='boolean'?response.completed:Boolean(!steering&&!turnId),steering,sharedExecution:true,mode,attachments:attachments.map(file=>file.label) };
     } finally { this.starting.delete(id); }
   }
 

package/lib/resume-manager.mjs

@@ -0,0 +1,177 @@
+import { EventEmitter } from 'node:events';
+import { CodexRpc } from './rpc.mjs';
+
+export class ResumeManager extends EventEmitter {
+  constructor({ home, createRpc = () => new CodexRpc({ home }) } = {}) {
+    super();
+    this.home = home;
+    this.createRpc = createRpc;
+    this.sessions = new Map();
+    this.pending = new Map();
+  }
+
+  has(id) {
+    return this.sessions.has(id);
+  }
+
+  ids() {
+    return [...this.sessions.keys()];
+  }
+
+  rpcFor(id) {
+    return this.sessions.get(id)?.rpc || null;
+  }
+
+  rpcForApproval(requestId) {
+    for (const { rpc } of this.sessions.values()) if (rpc.approvals.has(String(requestId))) return rpc;
+    return null;
+  }
+
+  runtime(id) {
+    const session = this.sessions.get(id);
+    const thread = session?.rpc.threads.get(id);
+    if (!session || !thread) return null;
+    return {
+      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',
+      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 }))
+    };
+  }
+
+  async resume(id, { model = null } = {}) {
+    const current = this.sessions.get(id);
+    if (current) {
+      if (!current.closing) {
+        current.releaseWhenIdle = false;
+        return this.runtime(id);
+      }
+      await current.closing;
+    }
+    const pending = this.pending.get(id);
+    if (pending) return pending;
+
+    const operation = (async () => {
+      const rpc = this.createRpc({ home:this.home, threadId:id });
+      try {
+        await rpc.resume(id, true);
+        const goalResult = typeof rpc.request === 'function'
+          ? await rpc.request('thread/goal/get', { threadId:id }).catch(() => ({ goal:null }))
+          : { goal:null };
+        const session = { id, rpc, model, goal:goalResult.goal || null, releaseWhenIdle:false, closing:null, eventListener:null };
+        session.eventListener = event => this.onEvent(session, event);
+        rpc.on('event', session.eventListener);
+        this.sessions.set(id, session);
+        this.emit('event', { method:'orbit/engine', params:{
+          connected:true, mode:'desktop', desktopConnected:false, resumedConnected:true
+        } });
+        return this.runtime(id);
+      } catch (error) {
+        await rpc.close();
+        if (/already has an active writer/i.test(error.message)) {
+          throw Object.assign(new Error('这条原会话仍由 Codex 桌面或其他执行器占用；未启动第二个执行器。请稍后重试。'), { code:'DESKTOP_THREAD_BUSY' });
+        }
+        throw error;
+      }
+    })();
+    this.pending.set(id, operation);
+    try { return await operation; }
+    finally { if (this.pending.get(id) === operation) this.pending.delete(id); }
+  }
+
+  onEvent(session, event) {
+    if (event.method === 'thread/goal/updated' && event.params?.threadId === session.id) {
+      session.goal = event.params.goal || null;
+      this.emit('event', event);
+      return;
+    }
+    if (event.method === 'thread/goal/cleared' && event.params?.threadId === session.id) {
+      session.goal = null;
+      this.emit('event', event);
+      return;
+    }
+    if (event.method === 'orbit/engine') {
+      if (!event.params?.connected && !session.closing) {
+        this.sessions.delete(session.id);
+        this.emit('released', session.id);
+        this.emit('lost', session.id, '本机 Codex App Server 已断开；请重新连接这条原会话。', 'APP_SERVER_DISCONNECTED');
+        this.emit('event', { method:'orbit/desktop', params:{
+          threadId:session.id, mode:'same-id-resume', attached:false, turnId:null,
+          reason:'本机 Codex App Server 已断开；请重新连接这条原会话。',
+          reasonCode:'APP_SERVER_DISCONNECTED'
+        } });
+        this.emit('event', { method:'orbit/engine', params:{
+          connected:this.sessions.size>0, mode:'desktop', desktopConnected:false,
+          resumedConnected:this.sessions.size>0
+        } });
+      }
+      return;
+    }
+    this.emit('event', event);
+    if (event.method === 'turn/completed' && event.params?.threadId === session.id
+      && session.releaseWhenIdle && !session.rpc.threads.get(session.id)?.turnId) {
+      void this.closeSession(session);
+    }
+  }
+
+  async setGoal(id, { objective, tokenBudget = null }) {
+    const session = this.sessions.get(id);
+    if (!session || session.closing) throw new Error('原会话 App Server 接续已失效，请重新连接。');
+    const result = await session.rpc.request('thread/goal/set', {
+      threadId:id, origin:'user', objective, status:'active', tokenBudget
+    });
+    session.goal = result.goal;
+    return result.goal;
+  }
+
+  async setGoalStatus(id, status) {
+    const session = this.sessions.get(id);
+    if (!session || session.closing) throw new Error('原会话 App Server 接续已失效，请重新连接。');
+    const result = await session.rpc.request('thread/goal/set', { threadId:id, origin:'user', status });
+    session.goal = result.goal;
+    return result.goal;
+  }
+
+  async clearGoal(id) {
+    const session = this.sessions.get(id);
+    if (!session || session.closing) throw new Error('原会话 App Server 接续已失效，请重新连接。');
+    const result = await session.rpc.request('thread/goal/clear', { threadId:id, origin:'user' });
+    if (result.cleared) session.goal = null;
+    return result;
+  }
+
+  async release(id) {
+    const session = this.sessions.get(id);
+    if (!session) return;
+    if (session.rpc.threads.get(id)?.turnId) {
+      session.releaseWhenIdle = true;
+      return;
+    }
+    await this.closeSession(session);
+  }
+
+  async closeSession(session) {
+    if (session.closing) return session.closing;
+    session.closing = (async () => {
+      await session.rpc.close();
+      session.rpc.off('event', session.eventListener);
+      if (this.sessions.get(session.id) === session) this.sessions.delete(session.id);
+      this.emit('released', session.id);
+      this.emit('event', { method:'orbit/engine', params:{
+        connected:this.sessions.size>0, mode:'desktop', desktopConnected:false,
+        resumedConnected:this.sessions.size>0
+      } });
+    })();
+    return session.closing;
+  }
+
+  async close() {
+    const sessions = [...this.sessions.values()];
+    await Promise.all(sessions.map(session => this.closeSession(session)));
+    this.sessions.clear();
+  }
+}

package/lib/rpc.mjs

@@ -130,23 +130,44 @@ export class CodexRpc extends EventEmitter {
     if (this.threads.has(id)) return;
     const result = await this.request('thread/resume', { threadId: id, excludeTurns: true, sandbox: writable ? 'workspace-write' : 'read-only', approvalPolicy: 'on-request' });
     if (result.thread.id !== id) throw new Error('返回的会话 ID 不一致，已拒绝发送消息。');
-    this.threads.set(id, { turnId: null, lastCompletedTurnId: null });
+    this.threads.set(id, {
+      turnId:null,lastCompletedTurnId:null,writable:Boolean(writable),
+      model:result.model||result.thread.model||null,
+      effort:result.reasoningEffort??result.thread.reasoningEffort??null,
+      collaborationMode:result.collaborationMode||{mode:'default',settings:{}}
+    });
   }
 
-  async startTurn(id, text, writable, settings = null) {
+  async startTurn(id, text, writable, settings = null, options = {}) {
     if (this.starting.has(id)) throw new Error('此会话正在发送，请勿并发提交。');
     this.starting.add(id);
     try {
       await this.resume(id, writable);
       const thread = this.threads.get(id);
       if (thread.turnId) throw new Error('此会话仍在执行，请等待完成或停止后再发送。');
+      const baseMode=thread.collaborationMode||{mode:'default',settings:{}};
+      const collaborationMode={
+        mode:options.mode==='plan'?'plan':baseMode.mode==='plan'?'default':baseMode.mode||'default',
+        settings:{
+          ...baseMode.settings,
+          model:settings?.model||baseMode.settings?.model||thread.model||'',
+          reasoning_effort:settings?.effort??baseMode.settings?.reasoning_effort??thread.effort??null,
+          developer_instructions:options.mode==='plan'||baseMode.mode==='plan'
+            ? null
+            : baseMode.settings?.developer_instructions??null
+        }
+      };
       const result = await this.request('turn/start', {
         threadId: id, input: [{ type: 'text', text }], approvalPolicy: 'on-request',
         sandboxPolicy: writable ? { type: 'workspaceWrite', networkAccess: false, excludeTmpdirEnvVar: true, excludeSlashTmp: true } : { type: 'readOnly' },
+        collaborationMode,
         ...(settings ? { model: settings.model, effort: settings.effort } : {})
       });
       const completed = thread.lastCompletedTurnId === result.turn.id;
       thread.turnId = completed ? null : result.turn.id;
+      thread.collaborationMode=collaborationMode;
+      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); }
   }
@@ -198,6 +219,11 @@ export class CodexRpc extends EventEmitter {
   }
 
   close() {
+    const child = this.child;
+    const exited = !child || child.exitCode !== null || child.signalCode !== null
+      ? Promise.resolve()
+      : new Promise(resolve => child.once('exit', resolve));
     this.disconnect(new Error('服务已停止。'));
+    return exited;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orbit-codex-bridge",
-  "version": "0.1.2",
+  "version": "0.1.6",
   "type": "module",
   "description": "Connect your original Codex desktop conversations to Orbit on the web.",
   "engines": {
@@ -27,7 +27,7 @@
     "test": "node --test test/*.test.mjs",
     "test:browser": "node --test test/browser/*.test.mjs",
     "test:native": "node test/native-smoke.mjs",
-    "check": "node --check cli.mjs && node --check server.mjs && node --check lib/store.mjs && node --check lib/rpc.mjs && node --check lib/desktop.mjs && node --check lib/device-auth.mjs && node --check lib/connector-service.mjs && node --check public/app.js && node --check public/connect.js && node --check relay-server.mjs && node --check relay-store.mjs && node --check relay-agent.mjs && node --check public/admin.js"
+    "check": "node --check cli.mjs && node --check server.mjs && node --check lib/store.mjs && node --check lib/rpc.mjs && node --check lib/desktop.mjs && node --check lib/resume-manager.mjs && node --check lib/device-auth.mjs && node --check lib/connector-service.mjs && node --check public/app.js && node --check public/connect.js && node --check relay-server.mjs && node --check relay-store.mjs && node --check relay-agent.mjs && node --check public/admin.js"
   },
   "dependencies": {
     "dompurify": "^3.3.0",