orbit-codex-bridge 0.0.0-stage → 0.1.1

package/relay-agent.mjs

@@ -0,0 +1,218 @@
+import http from 'node:http';
+import https from 'node:https';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import WebSocket from 'ws';
+
+const maxBody = 12 * 1024 * 1024;
+const isLoopback = url => ['localhost','127.0.0.1','[::1]'].includes(url.hostname);
+
+export function createRelayAgent(options = {}) {
+  const relay = new URL(options.relayUrl || process.env.ORBIT_RELAY_URL || '');
+  const local = new URL(options.localUrl || process.env.ORBIT_LOCAL_URL || 'http://127.0.0.1:4318');
+  const token = options.agentToken || process.env.ORBIT_RELAY_AGENT_TOKEN || '';
+  const deviceId = options.deviceId || process.env.ORBIT_RELAY_DEVICE_ID || '';
+  const onReady = options.onReady || (() => {});
+  const onError = options.onError || (() => {});
+  const onState = options.onState || (() => {});
+  const heartbeatInterval = options.heartbeatInterval ?? 15000;
+  const heartbeatTimeout = options.heartbeatTimeout ?? 45000;
+  const reconnectDelay = options.reconnectDelay ?? 1000;
+  if (heartbeatInterval <= 0 || heartbeatTimeout <= heartbeatInterval || reconnectDelay < 0) throw new Error('连接心跳参数无效。');
+  if (relay.username || relay.password || relay.search || relay.hash || relay.pathname !== '/agent'
+    || !(relay.protocol === 'wss:' || relay.protocol === 'ws:' && isLoopback(relay))) {
+    throw new Error('ORBIT_RELAY_URL 必须为 wss://域名/agent；仅本地测试允许 ws。');
+  }
+  if (!isLoopback(local) || !['http:','https:'].includes(local.protocol) || local.username || local.password
+    || local.pathname !== '/' || local.search || local.hash) throw new Error('ORBIT_LOCAL_URL 必须指向本机 Orbit 根地址。');
+  if (!/^[a-zA-Z0-9_-]{32,100}$/.test(token) || !/^[a-zA-Z0-9_-]{8,100}$/.test(deviceId)) {
+    throw new Error('请从管理后台签发并配置此电脑的设备 ID 和独立代理 Token。');
+  }
+  let socket = null;
+  let stopped = true;
+  let reconnectTimer;
+  let readyTimer;
+  let heartbeatTimer;
+  let retry = 0;
+  const bridges = new Map();
+  const requests = new Set();
+
+  function send(packet) {
+    if (socket?.readyState === WebSocket.OPEN) socket.send(JSON.stringify(packet));
+  }
+
+  function clearLocalConnections() {
+    for (const bridge of bridges.values()) bridge.socket.terminate();
+    bridges.clear();
+    for (const request of requests) request.destroy(new Error('云端连接已断开，未自动重发。'));
+    requests.clear();
+  }
+
+  function localRequest(message, cloudSocket) {
+    if (typeof message.path !== 'string' || !message.path.startsWith('/api/') || message.path.startsWith('//')
+      || !['GET','POST'].includes(message.method)) return cloudSocket.close(1008,'Invalid local target');
+    const target = new URL(message.path,local);
+    if (target.origin !== local.origin) return cloudSocket.close(1008,'Invalid local target');
+    const body = Buffer.from(message.body || '', 'base64');
+    if (body.length > maxBody || requests.size >= 100) return;
+    const transport = target.protocol === 'https:' ? https : http;
+    let finished = false;
+    const respond = (statusCode,headers,responseBody) => {
+      if (finished) return;
+      finished = true;
+      if (socket === cloudSocket && cloudSocket.readyState === WebSocket.OPEN) {
+        cloudSocket.send(JSON.stringify({type:'http-response',requestId:message.requestId,statusCode,headers,body:responseBody.toString('base64')}));
+      }
+    };
+    const headers = {};
+    for (const name of ['accept','content-type','cookie','user-agent']) {
+      const value = message.headers?.[name];
+      if (typeof value === 'string') headers[name] = value;
+    }
+    headers.host = local.host;
+    headers.origin = local.origin;
+    const request = transport.request(target,{method:message.method,headers,timeout:25000},response => {
+      const chunks = [];
+      let size = 0;
+      response.on('data',chunk => {
+        size += chunk.length;
+        if (size > maxBody) request.destroy(new Error('本机响应过大。'));
+        else chunks.push(chunk);
+      });
+      response.on('error',error => request.destroy(error));
+      response.on('end',() => {
+        requests.delete(request);
+        respond(response.statusCode || 502,{
+          'content-type':response.headers['content-type'] || 'application/json',
+          ...(response.headers['set-cookie'] ? {'set-cookie':response.headers['set-cookie']} : {})
+        },Buffer.concat(chunks));
+      });
+    });
+    requests.add(request);
+    request.on('timeout',() => request.destroy(new Error('本机 Orbit 响应超时。')));
+    request.on('error',error => {
+      requests.delete(request);
+      respond(502,{'content-type':'application/json'},Buffer.from(JSON.stringify({error:error.message})));
+    });
+    request.end(body);
+  }
+
+  function openLocalSocket(message, cloudSocket) {
+    if (message.path !== '/socket' || typeof message.bridgeId !== 'string' || bridges.size >= 100) return;
+    const target = new URL('/socket',local);
+    target.protocol = target.protocol === 'https:' ? 'wss:' : 'ws:';
+    const localSocket = new WebSocket(target,{
+      headers:{
+        Cookie:message.headers?.cookie || '', Origin:local.origin,
+        Host:local.host
+      },
+      maxPayload:maxBody,handshakeTimeout:8000
+    });
+    const bridge = {socket:localSocket,queue:[],queuedBytes:0};
+    bridges.set(message.bridgeId,bridge);
+    const emit = (type,extra={}) => {
+      if (socket === cloudSocket && cloudSocket.readyState === WebSocket.OPEN) send({type,bridgeId:message.bridgeId,...extra});
+    };
+    localSocket.on('open',() => {
+      emit('ws-opened');
+      for (const packet of bridge.queue) localSocket.send(packet.data,{binary:packet.binary});
+      bridge.queue = []; bridge.queuedBytes = 0;
+    });
+    localSocket.on('message',(data,isBinary) => emit('ws-data',{dataType:isBinary?'binary':'text',data:Buffer.from(data).toString('base64')}));
+    localSocket.on('error',() => emit('ws-error'));
+    localSocket.on('close',() => {
+      if (bridges.get(message.bridgeId) === bridge) bridges.delete(message.bridgeId);
+      emit('ws-close',{code:1000,reason:'Local socket closed'});
+    });
+  }
+
+  function connect() {
+    if (stopped) return;
+    const cloudSocket = new WebSocket(relay,{maxPayload:18*1024*1024,handshakeTimeout:10000});
+    socket = cloudSocket;
+    onState({status:'connecting'});
+    readyTimer = setTimeout(() => cloudSocket.terminate(),15000);
+    let pendingPing = null;
+    let pingSentAt = 0;
+    cloudSocket.on('open',() => {
+      cloudSocket.send(JSON.stringify({type:'agent-auth',token,deviceId}));
+      heartbeatTimer = setInterval(() => {
+        if (socket !== cloudSocket || cloudSocket.readyState !== WebSocket.OPEN) return;
+        if (pendingPing !== null) {
+          if (Date.now() - pingSentAt >= heartbeatTimeout) {
+            onError(new Error('云端心跳超时，正在自动重连。'));
+            cloudSocket.terminate();
+          }
+          return;
+        }
+        pendingPing = `${Date.now()}`;
+        pingSentAt = Date.now();
+        cloudSocket.ping(pendingPing);
+      },heartbeatInterval);
+    });
+    cloudSocket.on('pong',data => {
+      if (data.toString() === pendingPing) pendingPing = null;
+    });
+    cloudSocket.on('error',error => { if (!stopped) onError(error); });
+    cloudSocket.on('message',raw => {
+      if (socket !== cloudSocket) return;
+      let message;
+      try { message = JSON.parse(raw.toString()); } catch { cloudSocket.close(1003,'Invalid relay message'); return; }
+      if (!message || typeof message !== 'object') return;
+      if (message.type === 'agent-ready') {
+        clearTimeout(readyTimer);retry = 0;onState({status:'online'});onReady(message);return;
+      }
+      if (message.type === 'http-request') return localRequest(message,cloudSocket);
+      if (message.type === 'ws-open') return openLocalSocket(message,cloudSocket);
+      const bridge = bridges.get(message.bridgeId);
+      if (!bridge) return;
+      if (message.type === 'ws-data' && typeof message.data === 'string') {
+        const packet = {data:Buffer.from(message.data,'base64'),binary:message.dataType === 'binary'};
+        if (bridge.socket.readyState === WebSocket.OPEN) bridge.socket.send(packet.data,{binary:packet.binary});
+        else if (bridge.socket.readyState === WebSocket.CONNECTING) {
+          bridge.queuedBytes += packet.data.length;
+          if (bridge.queuedBytes > 1024*1024) bridge.socket.terminate();
+          else bridge.queue.push(packet);
+        }
+      } else if (message.type === 'ws-close') {
+        bridges.delete(message.bridgeId);
+        if (bridge.socket.readyState === WebSocket.OPEN) bridge.socket.close(1000,'Cloud connection closed');
+        else bridge.socket.terminate();
+      }
+    });
+    cloudSocket.on('close',(code,reason) => {
+      if (socket !== cloudSocket) return;
+      socket = null;clearTimeout(readyTimer);clearInterval(heartbeatTimer);clearLocalConnections();
+      if (!stopped) {
+        if (code === 1008 || code === 1012 && reason.toString() === 'Replaced by a newer agent') {
+          stopped = true;
+          const detail = code === 1008 ? '电脑凭证被拒绝，请检查账号或重新登录。' : '连接已由另一个 Orbit 实例接管。';
+          onState({status:'blocked',reason:detail});
+          onError(new Error(detail));
+          return;
+        }
+        const delay = Math.min(30000,reconnectDelay * 2 ** Math.min(5,retry++));
+        onState({status:'reconnecting',retryIn:delay,reason:reason.toString() || `连接断开 (${code})`});
+        reconnectTimer = setTimeout(connect,delay);
+      }
+    });
+  }
+
+  return {
+    start() { if (!stopped) return; stopped = false;connect(); },
+    stop() {
+      stopped = true;clearTimeout(reconnectTimer);clearTimeout(readyTimer);clearInterval(heartbeatTimer);
+      const previous = socket;socket = null;previous?.terminate();clearLocalConnections();
+    }
+  };
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const agent = createRelayAgent({
+    onReady:message => console.log(`Orbit agent connected: ${message.deviceId}`),
+    onError:error => console.error(`Orbit agent connection: ${error.message}`)
+  });
+  agent.start();
+  process.once('SIGINT',() => agent.stop());
+  process.once('SIGTERM',() => agent.stop());
+}