orbit-codex-bridge 0.0.0-stage → 0.1.1

package/server.mjs

@@ -0,0 +1,491 @@
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { WebSocketServer, WebSocket } from 'ws';
+import QRCode from 'qrcode';
+import { NativeStore } from './lib/store.mjs';
+import { CodexRpc } from './lib/rpc.mjs';
+import { DesktopRpc } from './lib/desktop.mjs';
+
+const root = path.dirname(fileURLToPath(import.meta.url));
+const packageVersion = JSON.parse(fs.readFileSync(path.join(root,'package.json'),'utf8')).version;
+const sessionLifetime = 12 * 60 * 60 * 1000;
+const safeError = error => String(error.message || error).replace(/Bearer\s+\S+/gi, 'Bearer [REDACTED]').replace(/(?:sk-|sk_)[\w-]{12,}/g, '[REDACTED]').slice(0, 700);
+
+export function lanAddresses() {
+  return Object.values(os.networkInterfaces()).flat().filter(address => address && address.family === 'IPv4' && !address.internal).map(address => address.address);
+}
+
+export function createOrbitServer(options = {}) {
+  const home = options.home || process.env.ORBIT_CODEX_HOME || process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+  const dataDir = options.dataDir || path.join(root, '.runtime');
+  fs.mkdirSync(dataDir, { recursive: true, mode: 0o700 });
+  const credentialPath = path.join(dataDir, 'pairing-key');
+  let pairingKey = fs.existsSync(credentialPath) ? fs.readFileSync(credentialPath, 'utf8').trim() : crypto.randomBytes(24).toString('base64url');
+  fs.writeFileSync(credentialPath, pairingKey, { mode: 0o600 });
+  const store = options.store || new NativeStore(home);
+  const endpoint = options.endpoint ?? process.env.ORBIT_APP_SERVER_URL ?? '';
+  const rpc = options.rpc || options.desktopRpc || (endpoint ? new CodexRpc({ home, endpoint, tokenFile: process.env.ORBIT_APP_SERVER_TOKEN_FILE }) : new DesktopRpc());
+  const executionMode = rpc.mode || (endpoint ? 'endpoint' : 'cold-resume');
+  const listModels = options.listModels || (async () => {
+    const catalogRpc = new CodexRpc({ home, endpoint, tokenFile: process.env.ORBIT_APP_SERVER_TOKEN_FILE });
+    try {
+      await catalogRpc.connect();
+      const models = [];
+      let cursor = null;
+      for (let page = 0; page < 5; page++) {
+        const result = await catalogRpc.request('model/list', { limit: 100, includeHidden: false, ...(cursor ? { cursor } : {}) }, 12000);
+        if (!Array.isArray(result.data)) throw new Error('模型目录格式不兼容。');
+        models.push(...result.data);
+        cursor = result.nextCursor;
+        if (!cursor) return models;
+      }
+      throw new Error('模型目录未加载完整，未开放参数切换。');
+    } finally { catalogRpc.close(); }
+  });
+  let modelCache = null;
+  let modelCacheAt = 0;
+  let modelLoading = null;
+  async function modelCatalog() {
+    if (modelCache && Date.now() - modelCacheAt < 120000) return modelCache;
+    if (!modelLoading) modelLoading = Promise.resolve().then(listModels).then(data => {
+      if (!Array.isArray(data)) throw new Error('模型目录格式不兼容。');
+      modelCache = data.filter(model => model && !model.hidden && typeof (model.model || model.id) === 'string' && (model.model || model.id).length <= 180).map(model => ({
+        model: model.model || model.id, displayName: model.displayName || model.model || model.id,
+        isDefault: model.isDefault === true, defaultReasoningEffort: model.defaultReasoningEffort || null,
+        supportedReasoningEfforts: (Array.isArray(model.supportedReasoningEfforts) ? model.supportedReasoningEfforts : [])
+          .map(effort => typeof effort === 'string' ? effort : effort?.reasoningEffort).filter(effort => typeof effort === 'string' && effort.length < 30)
+      }));
+      modelCacheAt = Date.now();
+      return modelCache;
+    }).finally(() => { modelLoading = null; });
+    return modelLoading;
+  }
+  const publicUrl = options.publicUrl || process.env.ORBIT_PUBLIC_URL || '';
+  if (publicUrl && new URL(publicUrl).protocol !== 'https:') throw new Error('ORBIT_PUBLIC_URL 必须使用 HTTPS。');
+  const host = options.host || process.env.ORBIT_HOST || '127.0.0.1';
+  const sessions = new Map();
+  const attempts = new Map();
+  const dedup = new Map();
+  const sockets = new Set();
+  const desktopWatchers = new Map();
+  const queuedSettingsInFlight = new Set();
+  const allowedHosts = new Set(['localhost','127.0.0.1','[::1]',...lanAddresses(), ...(publicUrl ? [new URL(publicUrl).hostname] : [])]);
+  let port = Number(options.port ?? process.env.ORBIT_PORT ?? 4318);
+  let revision = store.revision();
+  let timer;
+  let lastDesktopConnect = 0;
+
+  function requestOrigin(request) {
+    const hostname = new URL(`http://${request.headers.host || 'invalid'}`).hostname;
+    if (!allowedHosts.has(hostname)) throw new Error('不允许的主机名。');
+    const origin = `http://${request.headers.host}`;
+    return publicUrl && request.headers.host === new URL(publicUrl).host ? new URL(publicUrl).origin : origin;
+  }
+
+  function checkOrigin(request, required = true) {
+    try { return (!request.headers.origin && !required) || request.headers.origin === requestOrigin(request); }
+    catch { return false; }
+  }
+
+  function sessionFor(request) {
+    const cookie = (request.headers.cookie || '').split(';').map(part => part.trim()).find(part => part.startsWith('orbit_session='));
+    const key = cookie?.slice('orbit_session='.length);
+    const session = sessions.get(key);
+    if (!session || session.expires < Date.now()) { if (key) sessions.delete(key); return null; }
+    return { ...session, key };
+  }
+
+  function json(response, status, body, extra = {}) {
+    response.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8', ...extra });
+    response.end(JSON.stringify(body));
+  }
+
+  async function readBody(request) {
+    let length = 0;
+    const chunks = [];
+    for await (const chunk of request) {
+      length += chunk.length;
+      if (length > 65536) throw new Error('请求过大。');
+      chunks.push(chunk);
+    }
+    return JSON.parse(Buffer.concat(chunks).toString() || '{}');
+  }
+
+  function status(session) {
+    const threads = store.list();
+    for (const id of session.enabled.keys()) controlFor(session, id);
+    return {
+      product: 'Orbit', version: packageVersion, device: os.hostname(), platform: process.platform, home,
+      threadCount: threads.length, projectCount: new Set(threads.map(thread => thread.projectId)).size,
+      archivedCount: threads.filter(thread => thread.archived).length, lockedCount: threads.filter(thread => thread.locked).length,
+      bridge: 'connected', transport: 'websocket', readOnlyMirror: true,
+      desktopHotAttachReady: executionMode === 'desktop' && rpc.connected,
+      desktopHotAttachVerified: executionMode === 'desktop' && [...rpc.threads.values()].some(thread => thread.state),
+      execution: { connected: rpc.connected, mode: executionMode, enabled: [...session.enabled.keys()], grants: Object.fromEntries(session.enabled), owned: [...rpc.threads.keys()] },
+      connectionUrls: [publicUrl || `http://127.0.0.1:${port}`, ...(host === '0.0.0.0' ? lanAddresses().map(address => `http://${address}:${port}`) : [])],
+      secureTransport: Boolean(publicUrl), lanEnabled: host === '0.0.0.0'
+    };
+  }
+
+  function controlFor(session, id) {
+    const control = session.enabled.get(id);
+    if (control && control.expires <= Date.now()) { session.enabled.delete(id); return null; }
+    return control || null;
+  }
+
+  function sendSessionEvent(sessionKey, event) {
+    for (const socket of sockets) {
+      if (socket.sessionKey === sessionKey && socket.readyState === WebSocket.OPEN) socket.send(JSON.stringify(event));
+    }
+  }
+
+  async function applyQueuedDesktopSettings(id, runtime) {
+    if (!runtime?.attached || runtime.turnId || queuedSettingsInFlight.has(id)) return;
+    queuedSettingsInFlight.add(id);
+    try {
+      for (const [sessionKey,session] of sessions) {
+        const queued = session.preferences.get(id);
+        if (!queued?.pending) continue;
+        if (!controlFor(session, id)) {
+          session.preferences.delete(id);
+          sendSessionEvent(sessionKey, { method:'orbit/settings-error',params:{ threadId:id,error:'授权已失效；下一轮模型参数未应用。' } });
+          continue;
+        }
+        try {
+          const model = runtime.model || null;
+          const effort = runtime.effort ?? null;
+          if (model === queued.model && effort === queued.effort) {
+            session.preferences.set(id,{ model:queued.model,effort:queued.effort,pending:false });
+          } else {
+            if (model !== queued.expectedModel || effort !== queued.expectedEffort) throw new Error('桌面模型设置已变化，请重新选择。');
+            const result = await rpc.updateThreadSettings(id,queued.model,queued.effort,queued.expectedModel,queued.expectedEffort);
+            session.preferences.set(id,{ model:result.model,effort:result.effort,pending:false });
+          }
+          sendSessionEvent(sessionKey,{ method:'orbit/settings-applied',params:{ threadId:id,model:queued.model,effort:queued.effort } });
+        } catch (error) {
+          session.preferences.delete(id);
+          sendSessionEvent(sessionKey,{ method:'orbit/settings-error',params:{ threadId:id,error:safeError(error) } });
+        }
+      }
+    } finally { queuedSettingsInFlight.delete(id); }
+  }
+
+  function unwatchDesktop(socket) {
+    const id = socket.desktopSubscription;
+    if (!id) return;
+    socket.desktopSubscription = null;
+    const count = desktopWatchers.get(id) || 0;
+    if (count > 1) desktopWatchers.set(id, count - 1);
+    else {
+      desktopWatchers.delete(id);
+      rpc.detach(id, '已取消实时跟随。');
+    }
+  }
+
+  function tryDesktopConnect() {
+    if (executionMode !== 'desktop' || rpc.connected || Date.now() - lastDesktopConnect < 5000) return;
+    lastDesktopConnect = Date.now();
+    rpc.connect().catch(() => {});
+  }
+
+  const vendor = new Map([
+    ['/vendor/marked.js', ['node_modules/marked/lib/marked.umd.js','text/javascript']],
+    ['/vendor/purify.js', ['node_modules/dompurify/dist/purify.min.js','text/javascript']]
+  ]);
+
+  const server = http.createServer(async (request, response) => {
+    response.setHeader('Cache-Control', 'no-store');
+    response.setHeader('X-Content-Type-Options', 'nosniff');
+    response.setHeader('Referrer-Policy', 'no-referrer');
+    response.setHeader('X-Frame-Options', 'DENY');
+    response.setHeader('Content-Security-Policy', "default-src 'self'; script-src 'self'; style-src 'self'; img-src 'self' data:; connect-src 'self'; object-src 'none'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'");
+    try {
+      requestOrigin(request);
+      const url = new URL(request.url, `http://${request.headers.host}`);
+      if (request.method === 'GET' && url.pathname === '/healthz') return json(response, 200, { ok: true });
+      if (request.method === 'GET' && url.pathname.startsWith('/api/cloud/')) return json(response, 404, { error:'当前运行的是本地工作站，不是云端控制平面。' });
+      if (request.method === 'POST' && !checkOrigin(request)) return json(response, 403, { error: '来源校验失败。' });
+      if (url.pathname === '/api/pair' && request.method === 'POST') {
+        const address = request.socket.remoteAddress;
+        const previous = attempts.get(address) || { count: 0, reset: Date.now() + 300000 };
+        if (previous.reset < Date.now()) { previous.count = 0; previous.reset = Date.now() + 300000; }
+        attempts.set(address, previous);
+        if (previous.count >= 8) return json(response, 429, { error: '尝试过多，请五分钟后重试。' });
+        previous.count++;
+        const body = await readBody(request);
+        const value = Buffer.from(typeof body.code === 'string' ? body.code.trim() : '');
+        const expected = Buffer.from(pairingKey);
+        if (value.length !== expected.length || !crypto.timingSafeEqual(value, expected)) return json(response, 401, { error: '配对密钥不正确。请在运行电脑上查看。' });
+        previous.count = 0;
+        if (sessions.size >= 64) return json(response, 429, { error: '已连接设备过多，请重启桥接服务后重新配对。' });
+        const key = crypto.randomBytes(32).toString('base64url');
+        sessions.set(key, { expires: Date.now() + sessionLifetime, enabled: new Map(), preferences: new Map() });
+        const secure = publicUrl ? '; Secure' : '';
+        return json(response, 200, { ok: true }, { 'Set-Cookie': `orbit_session=${key}; HttpOnly; SameSite=Strict; Path=/; Max-Age=43200${secure}` });
+      }
+      if (url.pathname.startsWith('/api/')) {
+        const session = sessionFor(request);
+        if (!session) return json(response, 401, { error: '请先配对这台电脑。' });
+        if (request.method === 'GET' && url.pathname === '/api/status') return json(response, 200, status(session));
+        if (request.method === 'GET' && url.pathname === '/api/threads') return json(response, 200, { threads: store.list(), revision });
+        if (request.method === 'GET' && url.pathname === '/api/models') return json(response, 200, { models: await modelCatalog() });
+        if (request.method === 'POST' && url.pathname === '/api/logout') {
+          sessions.delete(session.key);
+          for (const socket of sockets) if (socket.sessionKey === session.key) socket.close(1008, 'Logged out');
+          return json(response, 200, { ok: true }, { 'Set-Cookie': 'orbit_session=; HttpOnly; SameSite=Strict; Path=/; Max-Age=0' });
+        }
+        if (request.method === 'POST' && url.pathname === '/api/pair/qr') {
+          const body = await readBody(request);
+          const connection = status(session).connectionUrls.find(value => value === body.url);
+          if (!connection) return json(response, 400, { error: '请选择桥接服务提供的连接地址。' });
+          return json(response, 200, { image: await QRCode.toDataURL(`${connection}/#pair=${encodeURIComponent(pairingKey)}`, { width: 280, margin: 2 }), warning: '扫码者将能查看本机会话。仅向可信设备展示。' });
+        }
+        const match = url.pathname.match(/^\/api\/threads\/([a-zA-Z0-9_-]{8,120})\/messages$/);
+        if (request.method === 'GET' && match) {
+          const history = store.historyFor(match[1], url.searchParams.get('before'), url.searchParams.get('limit') || 60);
+          return history ? json(response, 200, history) : json(response, 404, { error: '会话不存在。' });
+        }
+        return json(response, 404, { error: '接口不存在。' });
+      }
+      if (request.method !== 'GET' && request.method !== 'HEAD') return json(response, 405, { error: '不支持的方法。' });
+      let file;
+      let type;
+      if (vendor.has(url.pathname)) {
+        const [relative, mime] = vendor.get(url.pathname);
+        file = path.join(root, relative);
+        type = mime;
+      } else {
+        const files = { '/': ['index.html','text/html'], '/app.js': ['app.js','text/javascript'], '/style.css': ['style.css','text/css'], '/layout.css': ['layout.css','text/css'], '/icon.svg': ['icon.svg','image/svg+xml'], '/manifest.webmanifest': ['manifest.webmanifest','application/manifest+json'] };
+        if (!files[url.pathname]) return json(response, 404, { error: '页面不存在。' });
+        const [name, mime] = files[url.pathname]; file = path.join(root, 'public', name); type = mime;
+      }
+      response.writeHead(200, { 'Content-Type': `${type}; charset=utf-8` });
+      if (request.method === 'HEAD') response.end(); else fs.createReadStream(file).pipe(response);
+    } catch (error) { if (!response.headersSent) json(response, 400, { error: safeError(error) }); else response.end(); }
+  });
+
+  const wss = new WebSocketServer({ noServer: true, maxPayload: 65536 });
+  server.on('upgrade', (request, socket, head) => {
+    const session = sessionFor(request);
+    if (request.url !== '/socket' || !session || !checkOrigin(request)) { socket.end('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n'); return; }
+    wss.handleUpgrade(request, socket, head, websocket => {
+      websocket.sessionKey = session.key;
+      websocket.alive = true;
+      websocket.subscription = null;
+      websocket.desktopSubscription = null;
+      sockets.add(websocket);
+      websocket.on('pong', () => { websocket.alive = true; });
+      websocket.on('close', () => { sockets.delete(websocket); unwatchDesktop(websocket); });
+      websocket.on('error', () => {});
+      websocket.send(JSON.stringify({ method: 'bridge/ready', params: { revision } }));
+      websocket.on('message', async raw => {
+        let message;
+        try {
+          const current = sessions.get(websocket.sessionKey);
+          if (!current || current.expires < Date.now()) { websocket.close(1008, 'Session expired'); return; }
+          message = JSON.parse(raw);
+          if (typeof message.id !== 'string' || message.id.length > 100) throw new Error('缺少请求 ID。');
+          const key = `${websocket.sessionKey}:${message.id}`;
+          const fingerprint = crypto.createHash('sha256').update(JSON.stringify([message.method, message.params])).digest('hex');
+          let entry = dedup.get(key);
+          if (entry && entry.fingerprint !== fingerprint) throw new Error('请求 ID 已用于其他操作。');
+          if (!entry) {
+            if (dedup.size > 1000) throw new Error('请求过多，请稍后重试。');
+            entry = { fingerprint, created: Date.now(), promise: command(websocket, current, message).then(result => ({ id: message.id, result }), error => ({ id: message.id, error: safeError(error), code: error.code || null })) };
+            dedup.set(key, entry);
+          }
+          const result = await entry.promise;
+          if (websocket.readyState === WebSocket.OPEN) websocket.send(JSON.stringify(result));
+        } catch (error) { if (websocket.readyState === WebSocket.OPEN) websocket.send(JSON.stringify({ id: message?.id || null, error: safeError(error), code: error.code || null })); }
+      });
+    });
+  });
+
+  async function command(socket, session, message) {
+    const body = message.params || {};
+    const id = body.threadId;
+    if (message.method === 'thread.subscribe') {
+      const row = id ? store.row(id) : null;
+      if (id && !row) throw new Error('会话不存在。');
+      if (socket.desktopSubscription && socket.desktopSubscription !== (id || null)) unwatchDesktop(socket);
+      socket.subscription = id || null;
+      let runtime = null;
+      if (executionMode === 'desktop' && id) {
+        if (socket.desktopSubscription !== id) {
+          socket.desktopSubscription = id;
+          desktopWatchers.set(id, (desktopWatchers.get(id) || 0) + 1);
+        }
+        try { runtime = await rpc.attach(id); }
+        catch (error) {
+          unwatchDesktop(socket);
+          lostListener(id,error.message,error.code);
+          runtime = {
+            threadId:id,mode:'desktop',attached:false,turnId:null,messages:[],approvals:[],
+            reason:safeError(error),reasonCode:error.code || 'DESKTOP_NOT_READY'
+          };
+        }
+      }
+      if (executionMode === 'desktop' && runtime?.attached && body.autoControl === true
+        && !row.archived && !String(row.source).startsWith('{')) {
+        session.enabled.set(id, {sharedExecution:true,desktop:true,writable:false,expires:Date.now() + 1800000});
+      }
+      const control = controlFor(session, id);
+      const approvals = control ? (executionMode === 'desktop' ? runtime?.approvals || [] : [...rpc.approvals.values()].filter(request => request.params.threadId === id).map(request => ({ ...request.params, requestId: String(request.id), method: request.method }))) : [];
+      return { subscribed: id || null, control, runtime, settings: control ? session.preferences.get(id) || null : null, turnId: runtime?.turnId || rpc.threads.get(id)?.turnId || null, approvals };
+    }
+    if (message.method === 'thread.enable') {
+      const row = store.row(id);
+      if (!row || row.archived) throw new Error('归档或不存在的会话不能直接接续。');
+      if (String(row.source).startsWith('{')) throw new Error('子代理不能独立接续，请打开其父会话。');
+      if (body.confirm !== true) throw new Error('必须明确确认接续方式。');
+      if (executionMode === 'desktop') {
+        let runtime;
+        try { runtime = await rpc.attach(id); }
+        catch (error) { lostListener(id,error.message,error.code); throw error; }
+        if (!runtime.attached) throw new Error('桌面实时快照未就绪，未授权控制。');
+        const control = { sharedExecution: true, desktop: true, writable: false, expires: Date.now() + 1800000 };
+        session.enabled.set(id, control);
+        return { threadId: id, ...control, mode: 'desktop', turnId: runtime.turnId };
+      }
+      let sharedExecution = false;
+      if (endpoint) {
+        await rpc.connect();
+        const result = await rpc.request('thread/loaded/list', {});
+        sharedExecution = (result.data || result.threadIds || []).includes(id);
+      }
+      if (!sharedExecution && !rpc.threads.has(id) && store.locked(id)) throw new Error('会话由桌面或其他进程持有。首版不会强行抢占，请先在原客户端释放该会话。');
+      const control = { sharedExecution, writable: body.writable === true, expires: Date.now() + 1800000 };
+      session.enabled.set(id, control);
+      return { threadId: id, ...control, mode: endpoint ? 'endpoint' : 'cold-resume' };
+    }
+    if (message.method === 'turn.start') {
+      const approval = controlFor(session, id);
+      if (!approval) throw new Error('请先确认这条会话的接续方式。');
+      if (typeof body.text !== 'string' || !body.text.trim() || body.text.length > 20000) throw new Error('消息必须为 1–20000 个字符。');
+      if (executionMode === 'desktop') return rpc.startTurn(id, body.text.trim());
+      if (!rpc.threads.has(id) && !endpoint && store.locked(id)) throw new Error('会话已被其他进程占用，未发送消息。');
+      return rpc.startTurn(id, body.text.trim(), approval.writable, session.preferences.get(id) || null);
+    }
+    if (message.method === 'thread.settings') {
+      if (!controlFor(session, id) || !store.row(id)) throw new Error('没有此会话的控制授权。');
+      if (typeof body.model !== 'string' || !body.model || body.model.length > 180 || (body.effort !== null && typeof body.effort !== 'string')) throw new Error('模型参数无效。');
+      const model = (await modelCatalog()).find(entry => entry.model === body.model);
+      if (!model || (body.effort !== null && !model.supportedReasoningEfforts.includes(body.effort))) throw new Error('所选模型或推理级别不可用，请重新加载目录。');
+      if (executionMode === 'desktop') {
+        if (typeof body.expectedModel !== 'string' || !Object.hasOwn(body, 'expectedEffort')) throw new Error('缺少当前模型版本，请刷新会话。');
+        const runtime = rpc.runtime(id);
+        if (!runtime.attached) throw new Error('桌面实时快照未就绪，请重新连接会话。');
+        if (runtime.model !== body.expectedModel || runtime.effort !== body.expectedEffort) throw new Error('模型设置已变化，请刷新后重试。');
+        if (runtime.turnId) {
+          session.preferences.set(id,{
+            model:body.model,effort:body.effort,pending:true,
+            expectedModel:runtime.model,expectedEffort:runtime.effort
+          });
+          return { model:body.model,effort:body.effort,queued:true,applied:false };
+        }
+        const result = await rpc.updateThreadSettings(id,body.model,body.effort,body.expectedModel,body.expectedEffort);
+        session.preferences.set(id,{ model:result.model,effort:result.effort,pending:false });
+        return result;
+      }
+      if (rpc.threads.get(id)?.turnId) throw new Error('当前任务正在执行，请完成后再切换模型参数。');
+      const settings = { model: body.model, effort: body.effort };
+      session.preferences.set(id, settings);
+      return { ...settings, applied: true, mode: 'next-turn' };
+    }
+    if (message.method === 'turn.steer') {
+      if (!controlFor(session, id)) throw new Error('没有此会话的控制授权。');
+      if (executionMode !== 'desktop') throw new Error('当前执行通道不支持向桌面任务追加指令。');
+      if (typeof body.text !== 'string' || !body.text.trim() || body.text.length > 20000) throw new Error('消息必须为 1–20000 个字符。');
+      if (typeof body.turnId !== 'string' || !body.turnId) throw new Error('缺少当前任务标识，请刷新后重试。');
+      return rpc.steer(id, body.text.trim(), body.turnId);
+    }
+    if (message.method === 'turn.interrupt') {
+      if (!controlFor(session, id)) throw new Error('没有此会话的控制授权。');
+      if (executionMode === 'desktop') return rpc.interrupt(id, body.turnId);
+      return rpc.interrupt(id);
+    }
+    if (message.method === 'approval.reply') {
+      const approval = rpc.approvals.get(String(body.requestId));
+      if (!approval || !controlFor(session, approval.params.threadId)) throw new Error('没有此审批的控制授权。');
+      return rpc.replyApproval(body.requestId, body);
+    }
+    throw new Error('不支持的操作。');
+  }
+
+  const eventListener = event => {
+    if (!/^(item\/|turn\/|thread\/status|orbit\/|serverRequest\/resolved|error$)/.test(event.method)) return;
+    if (event.method === 'orbit/desktop' && event.params?.threadId) void applyQueuedDesktopSettings(event.params.threadId,event.params);
+    for (const socket of sockets) {
+      const threadId = event.params?.threadId;
+      if ((!threadId || socket.subscription === threadId) && socket.readyState === WebSocket.OPEN) socket.send(JSON.stringify(event));
+    }
+  };
+  const lostListener = (threadId, reason, reasonCode) => {
+    for (const session of sessions.values()) {
+      session.enabled.delete(threadId);
+      session.preferences.delete(threadId);
+    }
+    for (const socket of sockets) {
+      if (socket.subscription === threadId && socket.readyState === WebSocket.OPEN) {
+        socket.send(JSON.stringify({ method: 'orbit/control-revoked', params: {
+          threadId,reason:reason ? safeError(new Error(reason)) : '桌面会话连接已变化，请重新连接并授权。',
+          reasonCode:reasonCode || 'DESKTOP_THREAD_UNAVAILABLE'
+        } }));
+      }
+    }
+  };
+  rpc.on('event', eventListener);
+  rpc.on('lost', lostListener);
+  async function listen() {
+    await new Promise((resolve, reject) => { server.once('error', reject); server.listen(port, host, resolve); });
+    port = server.address().port;
+    timer = setInterval(() => {
+      try {
+        tryDesktopConnect();
+        const next = store.revision();
+        if (next !== revision) {
+          revision = next;
+          for (const socket of sockets) if (socket.readyState === WebSocket.OPEN) socket.send(JSON.stringify({ method: 'store/changed', params: { revision } }));
+        }
+        for (const [key, value] of dedup) if (Date.now() - value.created > 300000) dedup.delete(key);
+        for (const [key, value] of attempts) if (value.reset < Date.now()) attempts.delete(key);
+        for (const [key, value] of sessions) if (value.expires < Date.now()) sessions.delete(key);
+      } catch {}
+    }, 1200);
+    timer.unref();
+    return { port, url: `http://127.0.0.1:${port}`, credentialPath };
+  }
+  const heartbeat = setInterval(() => {
+    for (const socket of sockets) {
+      if (!socket.alive || !sessions.has(socket.sessionKey)) { socket.terminate(); continue; }
+      socket.alive = false; socket.ping();
+    }
+  }, 30000);
+  heartbeat.unref();
+  async function close() {
+    clearInterval(timer); clearInterval(heartbeat);
+    for (const socket of sockets) unwatchDesktop(socket);
+    for (const socket of sockets) socket.terminate();
+    rpc.off('event', eventListener); rpc.off('lost', lostListener); rpc.close();
+    await new Promise(resolve => wss.close(resolve));
+    server.closeAllConnections();
+    await new Promise(resolve => server.close(resolve));
+    store.close();
+  }
+  return { listen, close, server, store, rpc, credentialPath, pairingKey, status };
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const app = createOrbitServer();
+  const info = await app.listen();
+  console.log(`Orbit ${packageVersion} · ${info.url}`);
+  console.log(`Native conversations: ${app.store.list().length} · default read-only`);
+  console.log(`Pairing key file: ${info.credentialPath}`);
+  console.log(`Execution channel: ${app.rpc.mode || 'cold-resume'} · desktop chats support automatic hot attach.`);
+  const shutdown = async () => { await app.close(); process.exit(0); };
+  process.once('SIGINT', shutdown); process.once('SIGTERM', shutdown);
+}