@walkhi/code-relax 0.1.0-beta.10 → 0.1.0-beta.101

package/dist/src/self-relay/connector.mjs

@@ -1,98 +1,372 @@
-import { randomUUID } from 'node:crypto';
-import { EventEmitter } from 'node:events';
-import WebSocket from 'ws';
+import { randomUUID } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs';
+import WebSocket from 'ws';
 import { decode, loopbackUrl, relayAddress, send } from './wire.mjs';
-import { createP2pProbe, validProbeSignal } from './p2p-probe.mjs';
-import { createWindowsRouteHelper } from './windows-route-helper.mjs';
-
-// Reuse the actual LAN dispatcher, including its normal/shared capability boundary.
-// The LAN token never travels to the relay. No requests are replayed after a close.
-export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken, identity, bridgeConnection, hostName = 'Codex-PC', lanCandidates = [], p2pProbe = false, iceServers = [], p2pWindowsRouteHelper = false, p2pWindowsRouteHelperToken = '' }) {
-  relayAddress(relayUrl); loopbackUrl(bridgeUrl, '/api/socket');
-  if (!bridgeToken) throw new Error('Bridge token required');
-  const events = new EventEmitter();
-  const remote = new WebSocket(relayUrl, { maxPayload: 64 * 1024 * 1024, perMessageDeflate: {
-    serverNoContextTakeover: true, clientNoContextTakeover: true,
-    threshold: 1024, zlibDeflateOptions: { level: 3 },
-  } });
-  const locals = new Map();
-  let heartbeat, operation, lastClose;
-  const alive = () => { clearTimeout(heartbeat); heartbeat = setTimeout(() => remote.terminate(), 75000); };
-  remote.on('open', alive); remote.on('ping', alive); remote.on('message', alive);
-  function dropLocal(session) {
-    const current = locals.get(session);
-    if (!current) return;
-    locals.delete(session); clearTimeout(current.timer); current.socket?.terminate();
-    current.probe?.then(probe => probe.close());
-  }
-  function dropLocals() {
-    for (const session of [...locals.keys()]) dropLocal(session);
-  }
-  const ready = new Promise((resolve, reject) => {
-    let registered = false;
-    const timer = setTimeout(() => { reject(new Error('Relay registration timeout')); remote.terminate(); }, 5000);
-    remote.on('open', () => send(remote, { type: 'host', key: hostKey, hostName, lanCandidates, p2pProbe: p2pProbe ? 1 : 0, p2pProbeRepeat: true,
-      ...(identity ? { deviceId: identity.id, deviceSecret: identity.secret } : {}) }));
-    remote.on('error', error => { reject(error); events.emit('diagnostic', error.message); });
-    remote.on('close', (code, reason) => {
-      clearTimeout(timer); clearTimeout(heartbeat); dropLocals();
-      const error = lastClose = Object.assign(new Error(`Relay closed (${code}): ${reason.toString()}`), { code });
-      if (!registered) reject(error);
-      if (operation) { clearTimeout(operation.timer); operation.reject(error); operation = undefined; }
-      events.emit('disconnected', { code, reason: reason.toString() });
-    });
-    remote.on('message', (bytes, binary) => {
-      try {
-        const message = decode(bytes, binary);
-        if (message.type === 'registered' && !registered) { registered = true; clearTimeout(timer); resolve(message); return; }
-        if (!registered) throw new Error('Relay not registered');
-        if (message.type === 'pair-code' || message.type === 'revoked' || message.type === 'status') {
-          if (operation && message.commandId === operation.id && message.type === operation.responseType) {
-            clearTimeout(operation.timer); const pending = operation; operation = undefined;
-            message.error ? pending.reject(new Error(message.error)) : pending.resolve(message);
-          }
-          return;
-        }
-        if (message.type === 'authorization-changed' && Array.isArray(message.clients) && Number.isSafeInteger(message.revision)) {
-          events.emit('authorization-changed', { clients: message.clients, revision: message.revision }); return;
-        }
-        if (message.type === 'attach') {
-          events.emit('attached', { session: message.session, clientId: message.clientId });
-          dropLocal(message.session);
-          const current = { socket: undefined, ready: false, timer: undefined, p2pProbe: p2pProbe && message.p2pProbe === 1,
-            bridgeOutbound: Promise.resolve() };
-          locals.set(message.session, current);
-          let connection;
-          try {
-            connection = bridgeConnection?.() || { url: bridgeUrl, token: bridgeToken };
-            loopbackUrl(connection.url, '/api/socket');
-          } catch {
-            send(remote, { type: 'detach', session: message.session }); dropLocal(message.session); events.emit('detached', { session: message.session });
-            events.emit('diagnostic', 'Local Bridge connection not ready'); return;
-          }
+import { routedFileBytes, parseFileBytes, sendFileFrame } from './file-wire.mjs';
+import { attachRtcFile } from './rtc-file-bridge.mjs';
+import { createP2pProbe, validProbeSignal } from './p2p-probe.mjs';
+import { createWindowsRouteHelper } from './windows-route-helper.mjs';
+
+// Reuse the actual LAN dispatcher, including its normal/shared capability boundary.
+// The LAN token never travels to the relay. No requests are replayed after a close.
+export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken, identity, bridgeConnection, usageCacheFile,
+  hostName = 'Codex-PC', lanCandidates = [], p2pProbe = false, iceServers = [], p2pWindowsRouteHelper = false, p2pWindowsRouteHelperToken = '' }) {
+  relayAddress(relayUrl); loopbackUrl(bridgeUrl, '/api/socket');
+  if (!bridgeToken) throw new Error('Desktop service credential required');
+  const events = new EventEmitter();
+  const remote = new WebSocket(relayUrl, { maxPayload: 64 * 1024 * 1024, perMessageDeflate: {
+    serverNoContextTakeover: true, clientNoContextTakeover: true,
+    threshold: 1024, zlibDeflateOptions: { level: 3 },
+  } });
+  const locals = new Map();
+  const fileLocals = new Map();
+  const activeTurns = new Map();
+  const completedTurns = new Map();
+  const trackedTurns = new Map();
+  if (usageCacheFile) {
+    try {
+      const saved = JSON.parse(fs.readFileSync(usageCacheFile, 'utf8'));
+      if (saved.version === 1 && Array.isArray(saved.turns)) {
+        for (const item of saved.turns.slice(0, 128)) {
+          if (typeof item.threadId === 'string' && item.threadId.length <= 80 &&
+              typeof item.turnId === 'string' && item.turnId.length <= 80) trackedTurns.set(item.threadId, item.turnId);
+        }
+      }
+    } catch (error) { if (error.code !== 'ENOENT') events.emit('diagnostic', `Usage task cache: ${error.message}`); }
+  }
+  function saveTrackedTurns() {
+    if (!usageCacheFile) return;
+    try {
+      const temp = `${usageCacheFile}.tmp`;
+      fs.writeFileSync(temp, JSON.stringify({ version: 1, turns: [...trackedTurns].map(([threadId, turnId]) => ({ threadId, turnId })) }), { mode: 0o600 });
+      fs.renameSync(temp, usageCacheFile);
+    } catch (error) { events.emit('diagnostic', `Usage task cache: ${error.message}`); }
+  }
+  let fileRemote, fileRetryTimer, turnLocal, turnRetryTimer, turnPulseTimer, turnObserverReady = false,
+    queueTurnResync = () => {}, verifyActiveTurns = () => {}, heartbeat, operation, lastClose, closing = false;
+  const alive = () => { clearTimeout(heartbeat); heartbeat = setTimeout(() => remote.terminate(), 75000); };
+  remote.on('open', alive); remote.on('ping', alive); remote.on('message', alive);
+  function dropLocal(session) {
+    const current = locals.get(session);
+    if (!current) return;
+    locals.delete(session); clearTimeout(current.timer);
+    if (current.ready && current.socket?.readyState === WebSocket.OPEN && current.usageRequests.size &&
+        remote.readyState === WebSocket.OPEN && !closing) {
+      // Keep only the in-flight submission receipt; no late response goes to the phone.
+      current.detached = true;
+      current.detachedTimer = setTimeout(() => current.socket?.terminate(), 35000);
+    } else current.socket?.terminate();
+    current.probe?.then(probe => probe.close());
+    current.fileProbe?.then(probe => probe.close());
+    current.diagnosticProbe?.then(probe => probe.close());
+  }
+  function dropLocals() {
+    for (const session of [...locals.keys()]) dropLocal(session);
+    for (const socket of fileLocals.values()) socket.terminate();
+    fileLocals.clear(); clearTimeout(fileRetryTimer); fileRemote?.terminate(); fileRemote = undefined;
+    clearTimeout(turnRetryTimer); clearInterval(turnPulseTimer); turnLocal?.terminate(); turnLocal = undefined;
+    turnObserverReady = false; activeTurns.clear(); completedTurns.clear(); verifyActiveTurns = () => {};
+  }
+  function startTurnReceiver() {
+    if (closing || remote.readyState !== WebSocket.OPEN) return;
+    let connection;
+    try { connection = bridgeConnection?.() || { url: bridgeUrl, token: bridgeToken }; loopbackUrl(connection.url, '/api/socket'); }
+    catch { turnRetryTimer = setTimeout(startTurnReceiver, 3000); return; }
+    const socket = turnLocal = new WebSocket(connection.url, { maxPayload: 64 * 1024, perMessageDeflate: false });
+    const resyncPending = new Map();
+    const confirmedTurns = new Map();
+    let resyncId = 2, resyncQueue = [];
+    function resyncNext() {
+      if (!turnObserverReady || turnLocal !== socket) return;
+      while (resyncPending.size < 8 && resyncQueue.length) {
+        const [threadId, turnId] = resyncQueue.shift();
+        if (trackedTurns.get(threadId) !== turnId) continue;
+        const id = ++resyncId;
+        resyncPending.set(id, { threadId, turnId });
+        send(socket, { type: 'request', id, method: 'GET', path: `/api/threads/${encodeURIComponent(threadId)}/active-turn` });
+      }
+    }
+    queueTurnResync = (threadId, turnId) => { resyncQueue.push([threadId, turnId]); resyncNext(); };
+    verifyActiveTurns = () => {
+      if (!turnObserverReady || turnLocal !== socket) return;
+      for (const [threadId, turnId] of trackedTurns) {
+        if (resyncQueue.some(([id]) => id === threadId) ||
+            [...resyncPending.values()].some(pending => pending.threadId === threadId)) continue;
+        resyncQueue.push([threadId, turnId]);
+      }
+      resyncNext();
+    };
+    function restartTurnSubscription() {
+      if (turnObserverReady) send(remote, { type: 'usage-observer-lost' });
+      turnObserverReady = false;
+      activeTurns.clear(); completedTurns.clear();
+      resyncPending.clear(); confirmedTurns.clear(); resyncQueue = [];
+      clearTimeout(turnRetryTimer);
+      turnRetryTimer = setTimeout(() => {
+        if (!closing && turnLocal === socket && socket.readyState === WebSocket.OPEN)
+          send(socket, { type: 'subscribe', id: 1, path: '/api/turn-events' });
+      }, 3000);
+    }
+    socket.on('open', () => send(socket, { type: 'auth', token: connection.token }));
+    socket.on('error', error => events.emit('diagnostic', `Local turn observer: ${error.message}`));
+    socket.on('close', () => {
+      if (turnLocal !== socket) return;
+      turnLocal = undefined;
+      send(remote, { type: 'workstation-health', health: null });
+      if (turnObserverReady) send(remote, { type: 'usage-observer-lost' });
+      turnObserverReady = false;
+      queueTurnResync = () => {};
+      verifyActiveTurns = () => {};
+      activeTurns.clear(); completedTurns.clear();
+      if (!closing && remote.readyState === WebSocket.OPEN) turnRetryTimer = setTimeout(startTurnReceiver, 3000);
+    });
+    socket.on('message', (bytes, binary) => {
+      if (binary || turnLocal !== socket) return socket.terminate();
+      try {
+        const message = decode(bytes, false);
+        if (message.type === 'ready') {
+          send(socket, { type: 'subscribe', id: 1, path: '/api/turn-events' });
+          send(socket, { type: 'subscribe', id: 2, path: '/api/health/events' }); return;
+        }
+        if (message.type === 'event' && message.id === 2 && message.event === 'health') {
+          send(remote, { type: 'workstation-health', health: message.data }); return;
+        }
+        if (message.type === 'event' && message.id === 2 && message.event === 'health-error') {
+          send(remote, { type: 'workstation-health', health: null });
+          events.emit('diagnostic', `Workstation health: ${message.data?.error || 'unavailable'}`); return;
+        }
+        if (message.type === 'subscribed' && message.id === 1) {
+          turnObserverReady = true; resyncQueue = [...trackedTurns]; resyncNext(); return;
+        }
+        if (message.type === 'response' && resyncPending.has(message.id)) {
+          const { threadId, turnId } = resyncPending.get(message.id);
+          resyncPending.delete(message.id);
+          if (trackedTurns.get(threadId) === turnId) {
+            if (message.status === 200 && message.body?.turnId === turnId) {
+              const method = confirmedTurns.get(threadId) === turnId ? 'heartbeat' : 'resume';
+              confirmedTurns.set(threadId, turnId);
+              activeTurns.set(threadId, turnId);
+              send(remote, { type: 'usage-turn', method, threadId, turnId });
+            } else if (message.status === 200 || message.status === 404) {
+              confirmedTurns.delete(threadId);
+              activeTurns.delete(threadId);
+              trackedTurns.delete(threadId); saveTrackedTurns();
+              send(remote, { type: 'usage-turn', method: 'inactive', threadId, turnId });
+            } else {
+              // Unknown activity stops billing, not the independent health stream.
+              // Retain the task for the existing ten-second metadata verification.
+              confirmedTurns.delete(threadId);
+              activeTurns.delete(threadId);
+              send(remote, { type: 'usage-turn', method: 'inactive', threadId, turnId });
+              events.emit('diagnostic', `Usage task ${threadId}: status ${message.status}: ${message.body?.error || 'activity unavailable'}`);
+            }
+          }
+          resyncNext(); return;
+        }
+        if (message.type === 'event' && message.id === 1 && message.event === 'turn') {
+          const { method, threadId, turnId } = message.data || {};
+          if (!['turn/started', 'turn/completed'].includes(method) || typeof threadId !== 'string' || typeof turnId !== 'string') return;
+          const key = `${threadId}:${turnId}`;
+          const tracked = trackedTurns.get(threadId) === turnId;
+          // Keep local event state for a phone submission receipt arriving later.
+          // Only registered usage turns need cloud updates or periodic verification.
+          if (method === 'turn/started') activeTurns.set(threadId, turnId);
+          else {
+            if (confirmedTurns.get(threadId) === turnId) confirmedTurns.delete(threadId);
+            if (activeTurns.get(threadId) === turnId) activeTurns.delete(threadId);
+            if (trackedTurns.get(threadId) === turnId) { trackedTurns.delete(threadId); saveTrackedTurns(); }
+            completedTurns.set(key, Date.now());
+            if (completedTurns.size > 100) completedTurns.delete(completedTurns.keys().next().value);
+          }
+          if (tracked) send(remote, { type: 'usage-turn', method, threadId, turnId });
+        } else if (message.type === 'end' || (message.type === 'response' && message.status >= 400 &&
+            (!Number.isSafeInteger(message.id) || message.id <= 2))) {
+          if (message.id === 1) {
+            events.emit('diagnostic', `Local turn subscription ended: ${message.body?.error || message.status || message.type}`);
+            restartTurnSubscription();
+          } else socket.close();
+        }
+      } catch (error) { events.emit('diagnostic', error.message); socket.terminate(); }
+    });
+  }
+  function startFileReceiver() {
+    if (!identity || closing || remote.readyState !== WebSocket.OPEN) return;
+    const receiver = fileRemote = new WebSocket(relayUrl, { maxPayload: 512 * 1024, perMessageDeflate: false });
+    receiver.on('open', () => send(receiver, { type: 'file-host', deviceId: identity.id, deviceSecret: identity.secret }));
+    receiver.on('error', error => events.emit('diagnostic', `File receiver: ${error.message}`));
+    receiver.on('close', () => {
+      for (const socket of fileLocals.values()) socket.terminate();
+      fileLocals.clear();
+      if (fileRemote === receiver) {
+        fileRemote = undefined;
+        if (!closing && remote.readyState === WebSocket.OPEN) fileRetryTimer = setTimeout(startFileReceiver, 3000);
+      }
+    });
+    receiver.on('message', (bytes, binary) => {
+      try {
+        if (binary) {
+          const { session, data } = parseFileBytes(bytes);
+          const socket = fileLocals.get(session);
+          if (socket?.readyState === WebSocket.OPEN) {
+            if (socket.bufferedAmount > 1024 * 1024) { socket.close(1013, 'File receiver too slow'); return; }
+            socket.send(data);
+          }
+          return;
+        }
+        const message = decode(bytes, binary);
+        if (message.type === 'file-host-ready') return;
+        if (message.type === 'file-open') {
+          if (typeof message.clientId !== 'string' || !/^[\w-]{16,128}$/.test(message.clientId)) throw new Error('Invalid file client identity');
+          const connection = bridgeConnection?.() || { url: bridgeUrl, token: bridgeToken };
+          const url = new URL(connection.url); url.pathname = '/api/file-transfer';
+          loopbackUrl(url.href, '/api/file-transfer');
+          const socket = new WebSocket(url.href, { maxPayload: 512 * 1024, perMessageDeflate: false });
+          fileLocals.set(message.session, socket);
+          socket.on('open', () => send(socket, { type: 'auth', token: connection.token, purpose: message.purpose,
+            uploadSessionId: message.uploadSessionId, resumeUpload: message.resumeUpload,
+            relayClientId: message.clientId, fileRelay: true }));
+          socket.on('error', error => events.emit('diagnostic', `Local file receiver: ${error.message}`));
+          socket.on('close', () => {
+            if (fileLocals.get(message.session) !== socket) return;
+            fileLocals.delete(message.session);
+            sendFileFrame(receiver, { type: 'file-close', session: message.session });
+          });
+          socket.on('message', (data, isBinary) => {
+            if (fileLocals.get(message.session) !== socket) return socket.terminate();
+            if (receiver.readyState !== WebSocket.OPEN) return socket.close(1011, 'File receiver unavailable');
+            if (isBinary) sendFileFrame(receiver, routedFileBytes(message.session, data));
+            else sendFileFrame(receiver, { type: 'file-frame', session: message.session, payload: data.toString() });
+          });
+        } else if (message.type === 'file-frame') {
+          const socket = fileLocals.get(message.session);
+          if (socket?.readyState === WebSocket.OPEN) {
+            if (socket.bufferedAmount > 1024 * 1024) { socket.close(1013, 'File receiver too slow'); return; }
+            socket.send(message.payload);
+          }
+        } else if (message.type === 'file-close') fileLocals.get(message.session)?.terminate();
+        else throw new Error('Invalid file receiver frame');
+      } catch (error) { events.emit('diagnostic', error.message); receiver.close(1008, 'Invalid file frame'); }
+    });
+  }
+  const ready = new Promise((resolve, reject) => {
+    let registered = false;
+    const timer = setTimeout(() => { reject(new Error('Relay registration timeout')); remote.terminate(); }, 5000);
+    remote.on('open', () => send(remote, { type: 'host', key: hostKey, hostName, lanCandidates, p2pProbe: p2pProbe ? 1 : 0, p2pProbeRepeat: true,
+      ...(identity ? { deviceId: identity.id, deviceSecret: identity.secret } : {}) }));
+    remote.on('error', error => { reject(error); events.emit('diagnostic', error.message); });
+    remote.on('close', (code, reason) => {
+      clearTimeout(timer); clearTimeout(heartbeat); dropLocals();
+      const error = lastClose = Object.assign(new Error(`Relay closed (${code}): ${reason.toString()}`), { code });
+      if (!registered) reject(error);
+      if (operation) { clearTimeout(operation.timer); operation.reject(error); operation = undefined; }
+      events.emit('disconnected', { code, reason: reason.toString() });
+    });
+    remote.on('message', (bytes, binary) => {
+      try {
+        const message = decode(bytes, binary);
+        if (message.type === 'registered' && !registered) {
+          registered = true; clearTimeout(timer); startFileReceiver(); startTurnReceiver();
+          turnPulseTimer = setInterval(() => {
+            verifyActiveTurns();
+          }, 10000);
+          resolve(message); return;
+        }
+        if (!registered) throw new Error('Relay not registered');
+        if (message.type === 'phone-connection-ack') { events.emit('phone-connection-ack', message.id); return; }
+        if (['pair-code', 'revoked', 'status', 'invite-create', 'invite-list', 'invite-revoke', 'devices-list', 'device-revoke'].includes(message.type)) {
+          if (operation && message.commandId === operation.id && message.type === operation.responseType) {
+            clearTimeout(operation.timer); const pending = operation; operation = undefined;
+            message.error ? pending.reject(new Error(message.error)) : pending.resolve(message);
+          }
+          return;
+        }
+        if (message.type === 'authorization-changed' && Array.isArray(message.clients) && Number.isSafeInteger(message.revision)) {
+          events.emit('authorization-changed', { clients: message.clients, revision: message.revision }); return;
+        }
+        if (message.type === 'attach') {
+          events.emit('attached', { session: message.session, clientId: message.clientId });
+          dropLocal(message.session);
+          const current = { clientId: message.clientId, socket: undefined, ready: false, timer: undefined, p2pProbe: p2pProbe && message.p2pProbe === 1,
+            bridgeOutbound: Promise.resolve(), healthRequests: new Set(), usageRequests: new Map(), detached: false, detachedTimer: undefined };
+          locals.set(message.session, current);
+          let connection;
+          try {
+            connection = bridgeConnection?.() || { url: bridgeUrl, token: bridgeToken };
+            loopbackUrl(connection.url, '/api/socket');
+          } catch {
+            send(remote, { type: 'detach', session: message.session }); dropLocal(message.session); events.emit('detached', { session: message.session });
+            events.emit('diagnostic', 'Local desktop service connection not ready'); return;
+          }
           const socket = current.socket = new WebSocket(connection.url, { maxPayload: 64 * 1024 * 1024, perMessageDeflate: false });
           current.forwardToBridge = payload => {
-            if (locals.get(message.session) !== current || !current.ready) throw new Error('Local Bridge connection not ready');
+            if (locals.get(message.session) !== current || !current.ready) throw new Error('Local desktop service connection not ready');
             const request = decode(payload, false);
-            if (!['request', 'subscribe', 'unsubscribe'].includes(request.type)) throw new Error('Unsupported LAN message');
+            if (!['request', 'subscribe', 'unsubscribe', 'response-ack', 'cancel'].includes(request.type)) throw new Error('Unsupported LAN message');
+            if (request.type === 'request' && request.method === 'GET' && request.path === '/api/health' && Number.isSafeInteger(request.id)) {
+              current.healthRequests.add(request.id);
+            }
+            if (request.type === 'cancel') current.healthRequests.delete(request.id);
+            if (request.type === 'request' && request.method === 'POST' && Number.isSafeInteger(request.id)) {
+              const path = (request.path || '').split('?')[0];
+              const existing = /^\/api\/threads\/([^/?]+)\/(?:messages|queue)$/.exec(path);
+              const created = /^\/api\/projects\/[^/?]+\/threads$/.test(path);
+              if (existing || created) {
+                const threadId = existing ? decodeURIComponent(existing[1]) : null;
+                const messageKey = typeof request.body?.clientUserMessageId === 'string' && request.body.clientUserMessageId.length <= 64
+                  ? request.body.clientUserMessageId : `${message.session}:${request.id}`;
+                current.usageRequests.set(request.id, { threadId, messageKey, created });
+                send(remote, { type: 'usage-arm', session: message.session, requestId: request.id, threadId });
+              }
+            }
             send(socket, request);
           };
-          current.timer = setTimeout(() => socket.terminate(), 5000);
-          socket.on('open', () => send(socket, { type: 'auth', token: connection.token }));
-          socket.on('error', error => events.emit('diagnostic', `Local Bridge: ${error.message}`));
-          socket.on('close', () => {
-            if (locals.get(message.session)?.socket !== socket) return;
-            send(remote, { type: 'detach', session: message.session }); dropLocal(message.session); events.emit('detached', { session: message.session });
-          });
-          socket.on('message', (data, isBinary) => {
-            if (locals.get(message.session)?.socket !== socket) return;
-            try {
-              const response = decode(data, isBinary);
-              if (!current.ready) {
-                if (response.type !== 'ready') throw new Error('Local Bridge authentication failed');
-                clearTimeout(current.timer); current.ready = true; send(remote, { type: 'ready', session: message.session });
+          current.timer = setTimeout(() => socket.terminate(), 5000);
+          socket.on('open', () => send(socket, { type: 'auth', token: connection.token,
+            ...(message.chat === true ? { relayClientId: message.clientId } : {}) }));
+          socket.on('error', error => events.emit('diagnostic', `Local desktop service: ${error.message}`));
+          socket.on('close', () => {
+            clearTimeout(current.detachedTimer);
+            if (locals.get(message.session)?.socket !== socket) return;
+            send(remote, { type: 'detach', session: message.session }); dropLocal(message.session); events.emit('detached', { session: message.session });
+          });
+          socket.on('message', (data, isBinary) => {
+            if (locals.get(message.session)?.socket !== socket && !current.detached) return;
+            try {
+              const response = decode(data, isBinary);
+              if (!current.ready) {
+                if (response.type !== 'ready') throw new Error('Local desktop service authentication failed');
+                clearTimeout(current.timer); current.ready = true; send(remote, { type: 'ready', session: message.session });
               } else {
+                const usage = response.type === 'response' ? current.usageRequests.get(response.id) : null;
+                if (usage) {
+                  current.usageRequests.delete(response.id);
+                  const threadId = usage.threadId || response.body?.threadId;
+                  if (response.status >= 200 && response.status < 300 && typeof threadId === 'string') {
+                    const turnId = usage.created ? response.body?.turnId : response.body?.usage?.turnId;
+                    const turnKind = usage.created ? 'start' : response.body?.usage?.kind;
+                    send(remote, { type: 'usage-message', session: message.session, requestId: response.id,
+                      threadId, messageKey: usage.messageKey, turnId, turnKind,
+                      completed: completedTurns.has(`${threadId}:${turnId}`), observerReady: turnObserverReady,
+                      active: activeTurns.get(threadId) === turnId });
+                    if (['start', 'steer'].includes(turnKind) && typeof turnId === 'string' &&
+                        !completedTurns.has(`${threadId}:${turnId}`)) {
+                      trackedTurns.set(threadId, turnId); saveTrackedTurns();
+                      if (turnObserverReady && !activeTurns.has(threadId)) queueTurnResync(threadId, turnId);
+                    }
+                  } else send(remote, { type: 'usage-cancel', session: message.session, requestId: response.id });
+                }
+                if (current.detached) {
+                  if (!current.usageRequests.size) socket.terminate();
+                  return;
+                }
                 const payload = data.toString();
+                // Native health probes use the relay socket. Keep their replies on that
+                // route, outside the RTC queue shared by chat and file downloads.
+                if (response.type === 'response' && current.healthRequests.delete(response.id)) {
+                  send(remote, { type: 'data', session: message.session, payload });
+                  return;
+                }
                 current.bridgeOutbound = current.bridgeOutbound.then(async () => {
                   const probe = await current.probe;
                   if (locals.get(message.session) !== current || !current.ready) return;
@@ -100,63 +374,100 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
                 });
                 void current.bridgeOutbound.catch(error => { events.emit('diagnostic', error.message); socket.terminate(); });
               }
-            } catch (error) { events.emit('diagnostic', error.message); socket.terminate(); }
-          });
-        } else if (message.type === 'p2p-probe' && locals.has(message.session)) {
-          const current = locals.get(message.session);
-          if (!current.ready || !current.p2pProbe || !validProbeSignal(message)) throw new Error('Invalid probe signal');
-          if (message.kind === 'start' && current.probeId !== message.probeId) {
-            void current.probe?.then(probe => probe.close());
-            current.probeId = message.probeId;
-            current.routeSignals = Promise.resolve();
-            const probeId = message.probeId;
-            current.routeHelper = createWindowsRouteHelper({ enabled: p2pWindowsRouteHelper, token: p2pWindowsRouteHelperToken, iceServers,
-              report: (event, details) => events.emit('diagnostic', `${event};count=${details.count}`) });
-            current.probe = current.routeHelper.prepare().then(() => createP2pProbe({ iceServers,
-              signal: signal => {
-                if (locals.get(message.session) === current && current.probeId === probeId) send(remote, { type: 'p2p-probe', session: message.session,
-                  version: 1, probeId, ...signal });
+            } catch (error) { events.emit('diagnostic', error.message); socket.terminate(); }
+          });
+        } else if (message.type === 'p2p-probe' && locals.has(message.session)) {
+          const current = locals.get(message.session);
+          if (!current.ready || !current.p2pProbe || !validProbeSignal(message)) throw new Error('Invalid probe signal');
+          if (message.purpose === 'diagnostic') {
+            if (message.kind === 'start' && current.diagnosticProbeId !== message.probeId) {
+              void current.diagnosticProbe?.then(probe => probe.close());
+              current.diagnosticProbeId = message.probeId;
+              const probeId = message.probeId;
+              current.diagnosticProbe = createP2pProbe({ iceServers,
+                signal: signal => {
+                  if (locals.get(message.session) === current && current.diagnosticProbeId === probeId) {
+                    send(remote, { type: 'p2p-probe', purpose: 'diagnostic', session: message.session,
+                      version: 1, probeId, ...signal });
+                  }
+                },
+                report: (state, diagnostic) => events.emit('p2p-probe', { state, diagnostic })
+              }).catch(() => {
+                if (locals.get(message.session) === current && current.diagnosticProbeId === probeId) {
+                  send(remote, { type: 'p2p-probe', purpose: 'diagnostic', session: message.session,
+                    version: 1, probeId, kind: 'close' });
+                }
+                return { receive() {}, close() {} };
+              });
+            } else if (current.diagnosticProbe && current.diagnosticProbeId === message.probeId) {
+              void current.diagnosticProbe.then(probe => probe.receive(message));
+            }
+            return;
+          }
+          if (message.purpose && message.purpose !== 'file') throw new Error('Invalid probe purpose');
+          const file = message.purpose === 'file';
+          const probeField = file ? 'fileProbe' : 'probe', idField = file ? 'fileProbeId' : 'probeId';
+          const signalsField = file ? 'fileRouteSignals' : 'routeSignals', helperField = file ? 'fileRouteHelper' : 'routeHelper';
+          if (message.kind === 'start' && current[idField] !== message.probeId) {
+            void current[probeField]?.then(probe => probe.close());
+            current[idField] = message.probeId;
+            current[signalsField] = Promise.resolve();
+            const probeId = message.probeId;
+            current[helperField] = createWindowsRouteHelper({ enabled: p2pWindowsRouteHelper, token: p2pWindowsRouteHelperToken, iceServers,
+              report: (event, details) => events.emit('diagnostic', `${event};count=${details.count}`) });
+            current[probeField] = current[helperField].prepare().then(() => createP2pProbe({ iceServers, purpose: file ? 'file' : '',
+              signal: signal => {
+                if (locals.get(message.session) === current && current[idField] === probeId) send(remote, { type: 'p2p-probe', session: message.session, ...(file ? { purpose: 'file' } : {}),
+                  version: 1, probeId, ...signal });
               },
-              onData: payload => current.forwardToBridge(payload),
-              report: (state, diagnostic) => events.emit('p2p-probe', { state, diagnostic })
-            })).catch(() => {
-              events.emit('diagnostic', p2pWindowsRouteHelper ? 'Windows RTC 路由辅助不可用' : 'WebRTC probe initialization failed');
-              return { receive() {}, close() {} };
-            });
-          } else if (current.probe && current.probeId === message.probeId) {
-            const pending = current.probe;
-            current.routeSignals ||= Promise.resolve();
-            current.routeSignals = current.routeSignals.then(async () => {
-              await current.routeHelper?.include(message);
-              const probe = await pending;
-              if (locals.get(message.session) === current && current.probeId === message.probeId) probe.receive(message);
-            });
-            void current.routeSignals
-              .catch(() => { events.emit('diagnostic', 'WebRTC probe negotiation failed'); void pending.then(probe => probe.close()); });
-          }
-        } else if (message.type === 'detach' && locals.has(message.session)) { dropLocal(message.session); events.emit('detached', { session: message.session }); }
-        else if (message.type === 'data' && locals.has(message.session)) {
-          const current = locals.get(message.session);
-          if (!current.ready) { send(remote, { type: 'detach', session: message.session }); dropLocal(message.session); return; }
+              onData: file ? undefined : payload => current.forwardToBridge(payload),
+              onFileChannel: file ? channel => attachRtcFile(channel, bridgeConnection?.() || { url: bridgeUrl, token: bridgeToken },
+                () => locals.get(message.session) === current && current.ready && current[idField] === probeId && remote.readyState === WebSocket.OPEN,
+                current.clientId) : undefined,
+              report: (state, diagnostic) => events.emit('p2p-probe', { state, diagnostic, purpose: file ? 'file' : 'chat' })
+            })).catch(() => {
+              events.emit('diagnostic', p2pWindowsRouteHelper ? 'Windows RTC 路由辅助不可用' : 'WebRTC probe initialization failed');
+              if (locals.get(message.session) === current && current[idField] === probeId) send(remote, {
+                type: 'p2p-probe', session: message.session, version: 1, probeId, ...(file ? { purpose: 'file' } : {}), kind: 'close' });
+              return { receive() {}, close() {} };
+            });
+          } else if (current[probeField] && current[idField] === message.probeId) {
+            const pending = current[probeField];
+            current[signalsField] ||= Promise.resolve();
+            current[signalsField] = current[signalsField].then(async () => {
+              await current[helperField]?.include(message);
+              const probe = await pending;
+              if (locals.get(message.session) === current && current[idField] === message.probeId) probe.receive(message);
+            });
+            void current[signalsField]
+              .catch(() => { events.emit('diagnostic', 'WebRTC probe negotiation failed'); void pending.then(probe => probe.close()); });
+          }
+        } else if (message.type === 'detach' && locals.has(message.session)) { dropLocal(message.session); events.emit('detached', { session: message.session }); }
+        else if (message.type === 'data' && locals.has(message.session)) {
+          const current = locals.get(message.session);
+          if (!current.ready) { send(remote, { type: 'detach', session: message.session }); dropLocal(message.session); return; }
           current.forwardToBridge(message.payload);
-        }
-      } catch (error) { events.emit('diagnostic', error.message); remote.close(1008, 'Invalid relay message'); }
-    });
-  });
-  return { ready, events,
-    assertConnected() { if (remote.readyState !== WebSocket.OPEN) throw lastClose || new Error('Relay disconnected during registration'); },
-    command(type, details = {}) {
-      if (operation) return Promise.reject(new Error('已有设备管理操作正在执行'));
-      return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => { operation = undefined; reject(new Error('设备管理请求超时，结果未确认；未自动重发')); }, 7000);
-        const id = randomUUID();
-        operation = { resolve, reject, timer, id, responseType: type === 'revoke' ? 'revoked' : type };
-        if (!send(remote, { type, commandId: id, ...details })) { clearTimeout(timer); operation = undefined; reject(new Error('中继未连接')); }
-      });
-    },
-    updateLanCandidates(candidates) {
-      if (!send(remote, { type: 'lan-candidates', candidates })) throw new Error('中继未连接');
-    },
-    close() { clearTimeout(heartbeat); dropLocals(); remote.terminate(); }
-  };
-}
+        }
+      } catch (error) { events.emit('diagnostic', error.message); remote.close(1008, 'Invalid relay message'); }
+    });
+  });
+  return { ready, events,
+    assertConnected() { if (remote.readyState !== WebSocket.OPEN) throw lastClose || new Error('Relay disconnected during registration'); },
+    reportDeviceConnection(info) { return send(remote, { ...info, type: 'device-connected' }); },
+    reportPhoneConnection(event) { return send(remote, { type: 'phone-connection', event }); },
+    reportPhoneConnections(active) { return send(remote, { type: 'phone-connections', active }); },
+    command(type, details = {}) {
+      if (operation) return Promise.reject(new Error('已有设备管理操作正在执行'));
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => { operation = undefined; reject(new Error('设备管理请求超时，结果未确认；未自动重发')); }, 7000);
+        const id = randomUUID();
+        operation = { resolve, reject, timer, id, responseType: type === 'revoke' ? 'revoked' : type };
+        if (!send(remote, { type, commandId: id, ...details })) { clearTimeout(timer); operation = undefined; reject(new Error('中继未连接')); }
+      });
+    },
+    updateLanCandidates(candidates) {
+      if (!send(remote, { type: 'lan-candidates', candidates })) throw new Error('中继未连接');
+    },
+    close() { closing = true; clearTimeout(heartbeat); dropLocals(); remote.terminate(); }
+  };
+}