@walkhi/code-relax 0.1.0-beta.1

package/dist/web/chat-transport.js

@@ -0,0 +1,196 @@
+(function (root) {
+  const capabilities = root.CodexCapabilities;
+  const selfRelay = root.codexSelfRelayConfig;
+  const lanOrigin = selfRelay ? new URL(selfRelay.url).origin.replace(/^wss:/, 'https:').replace(/^ws:/, 'http:') : root.codexLanConfig?.address || root.location?.origin;
+  const workstationScope = selfRelay
+    ? JSON.stringify([selfRelay.url, selfRelay.room, selfRelay.clientId])
+    : root.codexLanConfig?.workstationScope || '';
+
+  class LanTransport extends (selfRelay ? root.CodexSelfRelaySession : root.CodexLanSession) {
+    constructor(token) { super(token); this.mode = root.codexLanConfig?.transportMode || 'lan-legacy'; }
+    connectionState() { return this.ready ? 'connected' : 'disconnected'; }
+    async api(path, options = {}) {
+      const body = await this.request(path, options);
+      if (path.startsWith('/api/health')) {
+        this.mode = body.transportMode || 'lan-legacy';
+        this.recoveryAvailable = body.sharedRecoveryAvailable === true;
+        this.execution = body.execution;
+        this.managedAppServer = body.managedAppServer;
+        this.desktop = body.desktop;
+        this.desktopRestartRecommended = body.desktopRestartRecommended === true;
+      }
+      return body;
+    }
+    events(thread, sync, known) {
+      const query = new URLSearchParams();
+      if (thread.hostId) query.set('hostId', thread.hostId);
+      if (sync?.id && sync.epoch && Number.isSafeInteger(sync.seq)) {
+        query.set('syncId', sync.id); query.set('syncEpoch', sync.epoch); query.set('afterSeq', String(sync.seq));
+      }
+      const knownUpdatedAt = Number(known?.thread?.updatedAt) || 0;
+      const knownTurn = known?.turns?.at(-1);
+      if (knownUpdatedAt > 0 && knownTurn?.id) {
+        query.set('knownUpdatedAt', knownUpdatedAt.toString());
+        query.set('knownTurnId', knownTurn.id);
+        if (knownTurn.status) query.set('knownTurnStatus', knownTurn.status);
+      }
+      return this.subscribe(`/api/threads/${encodeURIComponent(thread.id)}/events?${query}`);
+    }
+    async cacheScope() {
+      if (workstationScope) return `workstation-v1:${workstationScope}`;
+      if (!selfRelay) return root.codexLanConfig?.cacheScope ? `${root.codexLanConfig.cacheScope}:${this.mode}` : null;
+      const identity = [selfRelay.url, selfRelay.room, selfRelay.clientId, selfRelay.revision, selfRelay.credential].join('\0');
+      const bytes = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(identity));
+      return `self-relay-v1:${[...new Uint8Array(bytes)].map(byte => byte.toString(16).padStart(2, '0')).join('')}`;
+    }
+    async cacheHash(value) {
+      if (!selfRelay) return [...crypto.getRandomValues(new Uint8Array(24))].map(byte => byte.toString(16).padStart(2, '0')).join('');
+      const bytes = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(value));
+      return [...new Uint8Array(bytes)].map(byte => byte.toString(16).padStart(2, '0')).join('');
+    }
+    async readCached(id, thread) {
+      const scope = await this.cacheScope();
+      return scope ? root.codexHistoryCache?.get(scope, (workstationScope || selfRelay) ? id : JSON.stringify([thread?.hostId || 'local', id])) : null;
+    }
+    async readLastCached() {
+      const scope = await this.cacheScope();
+      return scope ? root.codexHistoryCache?.latest(scope) : null;
+    }
+    async saveCached(data) {
+      const scope = await this.cacheScope();
+      if (scope) return root.codexHistoryCache?.save(scope, data, value => this.cacheHash(value), (workstationScope || selfRelay) ? data.thread.id : JSON.stringify([data.thread.hostId || 'local', data.thread.id]));
+    }
+    async addImage(blob) {
+      if (!['image/jpeg', 'image/png', 'image/webp'].includes(blob.type) || !blob.size || blob.size > 8 * 1024 * 1024) throw new Error('请选择不超过 8 MiB 的 JPEG、PNG 或 WebP 图片');
+      const bytes = new Uint8Array(await blob.arrayBuffer()); let binary = '';
+      for (let i = 0; i < bytes.length; i += 16384) binary += String.fromCharCode(...bytes.subarray(i, i + 16384));
+      const url = `data:${blob.type};base64,${btoa(binary)}`;
+      return { id: url, url, thumbnailUrl: url };
+    }
+    assetUrl(value) {
+      if (!value) return '';
+      if (/^data:image\/(?:png|jpeg|webp|gif|bmp);base64,/i.test(value)) return value;
+      if (selfRelay) return '';
+      const url = new URL(value, lanOrigin);
+      if (url.origin !== new URL(lanOrigin).origin) return '';
+      if (this.token) url.searchParams.set('token', this.token);
+      return url.href;
+    }
+    async readImage(_threadId, id) {
+      if (!/^[a-f0-9]{64}$/.test(id)) throw new Error('无效的图片标识');
+      return (await this.api(`/api/images/${id}`)).url;
+    }
+    async readFile(_threadId, id) {
+      if (!/^[a-f0-9]{64}$/.test(id)) throw new Error('无效的文件标识');
+      return this.api(`/api/files/${id}`);
+    }
+  }
+
+  // Relay owns login, device pairing, chunking, reconnection and phone cache.
+  // The LAN adapter owns the authenticated WebSocket; both expose the same UI operations.
+  root.createChatTransport = function ({ token, currentThread, relay = root.codexTransport }) {
+    const adapter = relay || new LanTransport(token);
+    const modeFor = thread => {
+      if (relay) return 'relay';
+      if (thread?.transport === 'app-server') return 'app-server';
+      if (thread?.hostId && thread.hostId !== 'local') return 'lan-legacy';
+      return adapter.mode;
+    };
+    const mode = () => modeFor(currentThread());
+    const serviceAdvisory = () => {
+      if (relay) return null;
+      const managed = adapter.managedAppServer;
+      if (managed?.state === 'restarting' || managed?.restart?.status === 'running') return {
+        kind: 'restarting', title: 'Codex 内核正在重启',
+        detail: '工作站连接保持在线；任务操作暂不可用，恢复后不会自动重发。'
+      };
+      if (managed?.ready && managed.updatePending) return {
+        kind: 'update-pending', title: 'Codex 内核有更新',
+        detail: '当前任务不受影响；点击查看状态，并选择何时重启更新。'
+      };
+      if (adapter.execution && (!adapter.execution.ready || adapter.execution.state === 'recovering')) return {
+        kind: 'execution-unavailable',
+        title: adapter.execution.state === 'recovering' ? 'Codex 内核正在恢复' : 'Codex 内核暂不可用',
+        detail: '工作站连接正常；点击查看当前状况、影响和可执行操作。'
+      };
+      if (adapter.mode === 'lan-legacy') return {
+        kind: 'basic', title: '当前为基础控制',
+        detail: '部分实时控制不可用；点击查看影响和恢复完整控制。'
+      };
+      return null;
+    };
+    return {
+      mode,
+      transportMode: () => relay ? 'relay' : adapter.mode,
+      recoverySupported: () => !relay && adapter.recoveryAvailable,
+      recoveryEvents: () => {
+        if (relay) throw new Error('请通过工作站管理连接查看切换进度');
+        return adapter.subscribe('/api/shared-recovery/events');
+      },
+      recoveryStatus: () => {
+        if (relay) throw new Error('OpenAI 官方中继不支持从手机启用完整控制');
+        return adapter.api('/api/shared-recovery');
+      },
+      recoverShared: operationId => {
+        if (relay) throw new Error('请通过局域网或Code Relax 中继切换工作站执行模式');
+        if (!adapter.recoveryAvailable) throw new Error('工作站端尚未支持恢复功能，请更新 Bridge');
+        return adapter.api('/api/shared-recovery', { method: 'POST', body: { confirmed: true, operationId } });
+      },
+      sharedServiceNotice: serviceAdvisory,
+      connectionLabel: (compact = false) => {
+        if (relay) return compact ? 'OpenAI中继' : 'OpenAI 中继';
+        const network = selfRelay ? compact ? 'CodeRelax中继' : 'Code Relax 中继' : '局域网';
+        return serviceAdvisory() ? network : `${network} · ${adapter.mode === 'lan-shared' ? '完整控制' : '基础控制'}`;
+      },
+      draftScope: () => relay ? adapter.draftScope() : workstationScope || (selfRelay ? `${lanOrigin}/${selfRelay.room}` : lanOrigin),
+      capabilities: () => capabilities.describe(mode()),
+      has: name => (name === 'historyCache' && Boolean(selfRelay || root.codexLanConfig?.cacheScope)) || capabilities.has(mode(), name),
+      supports: (name, thread) => capabilities.has(modeFor(thread), name),
+      actionState: (action, context) => capabilities.actionState(mode(), action, {
+        ...context, writable: context?.writable !== false && (relay || adapter.execution?.canWrite !== false)
+      }),
+      api(path, options) {
+        if (!relay && /^\/api\/(threads\/|models)/.test(path)) {
+          const hostId = currentThread()?.hostId;
+          if (hostId) {
+            const url = new URL(path, lanOrigin);
+            if (!url.searchParams.has('hostId')) url.searchParams.set('hostId', hostId);
+            path = url.pathname + url.search;
+          }
+        }
+        return adapter.api(path, options);
+      },
+      events: (thread, sync, known) => relay ? adapter.events(thread.id) : adapter.events(thread, sync, known),
+      respondApproval: (thread, request, result) => {
+        const body = { id: request.id, epoch: request.epoch, result };
+        if (relay) return adapter.respondApproval(thread.id, body);
+        const query = new URLSearchParams({ hostId: thread.hostId || 'local' });
+        return adapter.api(`/api/threads/${encodeURIComponent(thread.id)}/approvals?${query}`, { method: 'POST', body });
+      },
+      addImage: blob => adapter.addImage(blob),
+      removeImage: id => adapter.removeImage?.(id),
+      clearImages: () => adapter.clearImages?.(),
+      readImage: (id, path) => adapter.readImage(id, path),
+      readFile: (id, path) => adapter.readFile(id, path),
+      readCached: async (id, thread) => adapter.readCached?.(id, thread),
+      readLastCached: async () => adapter.readLastCached?.(),
+      saveCached: async timeline => adapter.saveCached?.(timeline),
+      diagnostics: () => adapter.diagnostics?.(),
+      pause: async () => adapter.pause?.(),
+      resume: async () => adapter.resume?.(),
+      checkConnection: () => relay ? adapter.checkConnection() : adapter.api('/api/health', { timeoutMs: 5000 }),
+      connectionState: () => adapter.connectionState?.(),
+      onConnectionChange: callback => { if (!relay) adapter.onConnectionChange = callback; },
+      usageEvents: () => {
+        if (relay) return adapter.usageEvents();
+        if (adapter.mode !== 'lan-shared') return null;
+        return adapter.subscribe('/api/usage-events');
+      },
+      assetUrl(value) {
+        if (!relay) return adapter.assetUrl(value);
+        if (/^data:image\/(?:png|jpeg|webp|gif);base64,/i.test(value) || /^blob:/i.test(value)) return value;
+        const url = new URL(value, location.origin); return url.protocol === 'https:' ? url.href : '';
+      },
+    };
+  };
+})(globalThis);