@walkhi/code-relax 0.1.0-beta.22 → 0.1.0-beta.24

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

@@ -1,204 +1,208 @@
-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 { 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, usageCacheFile,
-  hostName = 'Codex-PC', lanCandidates = [], p2pProbe = false, iceServers = [], p2pWindowsRouteHelper = false, p2pWindowsRouteHelperToken = '' }) {
+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');
+  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 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.diagnosticProbe?.then(probe => probe.close());
+  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.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 pulsePending = new Map();
+    let resyncId = 1, 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 (activeTurns.get(threadId) !== turnId) continue;
+        if (pulsePending.size >= 8) break;
+        if ([...pulsePending.values()].some(pending => pending.threadId === threadId)) continue;
+        const id = ++resyncId;
+        pulsePending.set(id, { threadId, turnId });
+        send(socket, { type: 'request', id, method: 'GET', path: `/api/threads/${encodeURIComponent(threadId)}/active-turn` });
+      }
+    };
+    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;
+      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' }); return; }
+        if (message.type === 'subscribed' && message.id === 1) {
+          turnObserverReady = true; resyncQueue = [...trackedTurns]; resyncNext(); return;
+        }
+        if (message.type === 'response' && pulsePending.has(message.id)) {
+          const { threadId, turnId } = pulsePending.get(message.id);
+          pulsePending.delete(message.id);
+          if (trackedTurns.get(threadId) !== turnId || activeTurns.get(threadId) !== turnId) return;
+          if (message.status === 200 && message.body?.turnId === turnId) {
+            send(remote, { type: 'usage-turn', method: 'heartbeat', threadId, turnId });
+          } else if (message.status === 200 || message.status === 404) {
+            activeTurns.delete(threadId);
+            if (trackedTurns.get(threadId) === turnId) { trackedTurns.delete(threadId); saveTrackedTurns(); }
+            send(remote, { type: 'usage-turn', method: 'inactive', threadId, turnId });
+          } else socket.close();
+          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) {
+              activeTurns.set(threadId, turnId);
+              send(remote, { type: 'usage-turn', method: 'resume', threadId, turnId });
+            } else if (message.status === 200 || message.status === 404) {
+              trackedTurns.delete(threadId); saveTrackedTurns();
+            } else { socket.close(); return; }
+          }
+          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 (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)) 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 {
+        const message = decode(bytes, binary);
+        if (message.type === 'file-host-ready') return;
+        if (message.type === 'file-open') {
+          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 }));
+          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);
+            send(receiver, { type: 'file-close', session: message.session });
+          });
+          socket.on('message', (data, isBinary) => {
+            if (isBinary || fileLocals.get(message.session) !== socket) return socket.terminate();
+            send(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) 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'); }
+    });
   }
-  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 pulsePending = new Map();
-    let resyncId = 1, 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 activeTurns) {
-        if (pulsePending.size >= 8) break;
-        if ([...pulsePending.values()].some(pending => pending.threadId === threadId)) continue;
-        const id = ++resyncId;
-        pulsePending.set(id, { threadId, turnId });
-        send(socket, { type: 'request', id, method: 'GET', path: `/api/threads/${encodeURIComponent(threadId)}/active-turn` });
-      }
-    };
-    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;
-      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' }); return; }
-        if (message.type === 'subscribed' && message.id === 1) {
-          turnObserverReady = true; resyncQueue = [...trackedTurns]; resyncNext(); return;
-        }
-        if (message.type === 'response' && pulsePending.has(message.id)) {
-          const { threadId, turnId } = pulsePending.get(message.id);
-          pulsePending.delete(message.id);
-          if (activeTurns.get(threadId) !== turnId) return;
-          if (message.status === 200 && message.body?.turnId === turnId) {
-            send(remote, { type: 'usage-turn', method: 'heartbeat', threadId, turnId });
-          } else if (message.status === 200 || message.status === 404) {
-            activeTurns.delete(threadId);
-            if (trackedTurns.get(threadId) === turnId) { trackedTurns.delete(threadId); saveTrackedTurns(); }
-            send(remote, { type: 'usage-turn', method: 'inactive', threadId, turnId });
-          } else socket.close();
-          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) {
-              activeTurns.set(threadId, turnId);
-              send(remote, { type: 'usage-turn', method: 'resume', threadId, turnId });
-            } else if (message.status === 200 || message.status === 404) {
-              trackedTurns.delete(threadId); saveTrackedTurns();
-            } else { socket.close(); return; }
-          }
-          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}`;
-          if (method === 'turn/started') activeTurns.set(threadId, turnId);
-          else {
-            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);
-          }
-          send(remote, { type: 'usage-turn', method, threadId, turnId });
-        } else if (message.type === 'end' || (message.type === 'response' && message.status >= 400)) 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 {
-        const message = decode(bytes, binary);
-        if (message.type === 'file-host-ready') return;
-        if (message.type === 'file-open') {
-          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 }));
-          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);
-            send(receiver, { type: 'file-close', session: message.session });
-          });
-          socket.on('message', (data, isBinary) => {
-            if (isBinary || fileLocals.get(message.session) !== socket) return socket.terminate();
-            send(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) 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);
@@ -215,13 +219,13 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
     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 (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 === 'pair-code' || message.type === 'revoked' || message.type === 'status') {
           if (operation && message.commandId === operation.id && message.type === operation.responseType) {
@@ -236,8 +240,8 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
         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(), usageRequests: new Map(), detached: false, detachedTimer: undefined };
+          const current = { socket: undefined, ready: false, timer: undefined, p2pProbe: p2pProbe && message.p2pProbe === 1,
+            bridgeOutbound: Promise.resolve(), usageRequests: new Map(), detached: false, detachedTimer: undefined };
           locals.set(message.session, current);
           let connection;
           try {
@@ -245,105 +249,105 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, 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;
+            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 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.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);
-          };
+          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 desktop service connection not ready');
+            const request = decode(payload, false);
+            if (!['request', 'subscribe', 'unsubscribe', 'response-ack', 'cancel'].includes(request.type)) throw new Error('Unsupported LAN message');
+            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 desktop service: ${error.message}`));
-          socket.on('close', () => {
-            clearTimeout(current.detachedTimer);
-            if (locals.get(message.session)?.socket !== socket) return;
+          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;
+          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');
+                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();
-                current.bridgeOutbound = current.bridgeOutbound.then(async () => {
-                  const probe = await current.probe;
-                  if (locals.get(message.session) !== current || !current.ready) return;
-                  if (!probe?.send?.(payload)) send(remote, { type: 'data', session: message.session, payload });
-                });
-                void current.bridgeOutbound.catch(error => { events.emit('diagnostic', error.message); socket.terminate(); });
-              }
+              } 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();
+                current.bridgeOutbound = current.bridgeOutbound.then(async () => {
+                  const probe = await current.probe;
+                  if (locals.get(message.session) !== current || !current.ready) return;
+                  if (!probe?.send?.(payload)) send(remote, { type: 'data', session: message.session, payload });
+                });
+                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.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) throw new Error('Invalid probe purpose');
-          if (message.kind === 'start' && current.probeId !== message.probeId) {
+        } 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) throw new Error('Invalid probe purpose');
+          if (message.kind === 'start' && current.probeId !== message.probeId) {
             void current.probe?.then(probe => probe.close());
             current.probeId = message.probeId;
             current.routeSignals = Promise.resolve();
@@ -354,9 +358,9 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
               signal: signal => {
                 if (locals.get(message.session) === current && current.probeId === probeId) send(remote, { type: 'p2p-probe', session: message.session,
                   version: 1, probeId, ...signal });
-              },
-              onData: payload => current.forwardToBridge(payload),
-              report: (state, diagnostic) => events.emit('p2p-probe', { state, diagnostic })
+              },
+              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() {} };
@@ -376,7 +380,7 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
         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);
+          current.forwardToBridge(message.payload);
         }
       } catch (error) { events.emit('diagnostic', error.message); remote.close(1008, 'Invalid relay message'); }
     });
@@ -395,6 +399,6 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
     updateLanCandidates(candidates) {
       if (!send(remote, { type: 'lan-candidates', candidates })) throw new Error('中继未连接');
     },
-    close() { closing = true; clearTimeout(heartbeat); dropLocals(); remote.terminate(); }
+    close() { closing = true; clearTimeout(heartbeat); dropLocals(); remote.terminate(); }
   };
 }