@walkhi/code-relax 0.1.0-beta.1 → 0.1.0-beta.3

package/dist/web/message-view.js

@@ -0,0 +1,98 @@
+(function (root) {
+  'use strict';
+
+  function parseQuestionReply(text) {
+    const match = /^\s*<send_user_message_question_reply>\s*([\s\S]*?)\s*<\/send_user_message_question_reply>\s*$/.exec(text);
+    if (!match) return null;
+    let replies;
+    try {
+      replies = JSON.parse(match[1]);
+    } catch {
+      return null;
+    }
+    if (!Array.isArray(replies) || !replies.length || !replies.every(reply =>
+      reply && typeof reply.question === 'string' && typeof reply.answer === 'string')) return null;
+    return replies;
+  }
+
+  function stripInternalMessageMetadata(text) {
+    if (typeof text !== 'string') return '';
+    return text.replace(/(?:^|\r?\n)[ \t]*<oai-mem-citation\b[\s\S]*?(?:<\/oai-mem-citation>[ \t]*(?=\r?\n|$)|$)/gi, '').trimEnd();
+  }
+
+  function visibleMessageText(kind, text) {
+    return kind === 'agent' ? stripInternalMessageMetadata(text) : text;
+  }
+
+  function createMessageView(options) {
+    const {
+      document,
+      markdown,
+      enhanceCodeBlocks,
+      remoteImageElement,
+      openImageViewer,
+      linkActions,
+      isEmbedded,
+      scrollTimelineToBottom,
+    } = options;
+
+    function render(kind, text, role, imageAssets = {}, fileAssets = {}) {
+      const element = document.createElement('div');
+      element.className = `message ${kind}`;
+      const roleElement = document.createElement('span');
+      roleElement.className = 'role';
+      roleElement.textContent = role;
+      const content = document.createElement('div');
+      content.className = 'message-body';
+      const visibleText = visibleMessageText(kind, text);
+      const replies = kind === 'user' ? parseQuestionReply(visibleText) : null;
+      if (replies) {
+        for (const reply of replies) {
+          const item = document.createElement('div');
+          item.className = 'question-reply';
+          const question = document.createElement('div');
+          question.className = 'question-reply-question';
+          question.textContent = reply.question;
+          const answer = document.createElement('div');
+          answer.className = 'question-reply-answer';
+          answer.textContent = reply.answer;
+          item.append(question, answer);
+          content.append(item);
+        }
+      } else {
+        content.innerHTML = visibleText
+          ? markdown.render(visibleText, { imageAssets, fileAssets, allowRemoteFiles: kind === 'agent' })
+          : '';
+        enhanceCodeBlocks(content, visibleText);
+      }
+      for (const placeholder of content.querySelectorAll('[data-relay-image]')) {
+        placeholder.replaceWith(remoteImageElement(
+          imageAssets[placeholder.dataset.relayImage],
+          true,
+          placeholder.dataset.imageAlt,
+        ));
+      }
+      const showImage = event => {
+        const target = event.target.closest('[data-full-image]');
+        if (!target) return;
+        event.preventDefault();
+        const preview = target.currentSrc || target.src || target.dataset.fullImage;
+        openImageViewer(preview, target.alt || target.textContent || '图片', () => target.dataset.fullImage);
+      };
+      content.addEventListener('click', showImage);
+      content.addEventListener('click', event => linkActions.handleContentClick(event, isEmbedded()));
+      content.addEventListener('keydown', event => {
+        if (event.target.matches('img[data-full-image]') && ['Enter', ' '].includes(event.key)) showImage(event);
+      });
+      for (const image of content.querySelectorAll('img[data-full-image]')) {
+        image.addEventListener('load', () => scrollTimelineToBottom(), { once: true });
+      }
+      element.append(roleElement, content);
+      return element;
+    }
+
+    return { render };
+  }
+
+  root.CodexMessageView = Object.freeze({ createMessageView, parseQuestionReply, visibleMessageText });
+})(globalThis);

package/dist/web/p2p-data-channel.js

@@ -0,0 +1,50 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodeRelaxP2pDataFramer = factory();
+})(globalThis, () => {
+  const CHUNK_CHARS = 12000;
+  const MAX_MESSAGE_BYTES = 8 * 1024 * 1024;
+  const MAX_PARTS = 1024;
+  const byteLength = value => new TextEncoder().encode(value).length;
+
+  return class {
+    constructor() { this.inbound = undefined; }
+    create(payload, id) {
+      if (typeof payload !== 'string' || !/^[a-f0-9]{32}-[0-9]{1,10}$/.test(id)) throw new Error('Invalid P2P payload');
+      const bytes = byteLength(payload);
+      if (bytes > MAX_MESSAGE_BYTES) throw new Error('Code Relax 直连消息超过 8 MiB');
+      const total = Math.max(1, Math.ceil(payload.length / CHUNK_CHARS));
+      if (total > MAX_PARTS) throw new Error('Code Relax 直连消息分片过多');
+      return { id, payload, bytes, index: 0, total };
+    }
+    frame(item) {
+      if (!item || item.index >= item.total) return undefined;
+      const start = item.index * CHUNK_CHARS;
+      return JSON.stringify({ type: 'data', id: item.id, index: item.index, total: item.total,
+        payload: item.payload.slice(start, start + CHUNK_CHARS) });
+    }
+    commit(item) { item.index++; return item.index >= item.total; }
+    accept(message) {
+      if (!message || message.type !== 'data') return { handled: false };
+      if (!/^[a-f0-9]{32}-[0-9]{1,10}$/.test(message.id || '') || !Number.isSafeInteger(message.index) ||
+          !Number.isSafeInteger(message.total) || message.total < 1 || message.total > MAX_PARTS ||
+          message.index < 0 || message.index >= message.total || typeof message.payload !== 'string' ||
+          message.payload.length > CHUNK_CHARS) throw new Error('Invalid P2P data frame');
+      if (!this.inbound) {
+        if (message.index !== 0) throw new Error('Invalid P2P data order');
+        this.inbound = { id: message.id, total: message.total, next: 0, bytes: 0, parts: [] };
+      }
+      const current = this.inbound;
+      if (current.id !== message.id || current.total !== message.total || current.next !== message.index) {
+        throw new Error('Invalid P2P data order');
+      }
+      current.bytes += byteLength(message.payload);
+      if (current.bytes > MAX_MESSAGE_BYTES) throw new Error('P2P data message too large');
+      current.parts.push(message.payload); current.next++;
+      if (current.next !== current.total) return { handled: true, complete: false };
+      this.inbound = undefined;
+      return { handled: true, complete: true, payload: current.parts.join('') };
+    }
+    reset() { this.inbound = undefined; }
+  };
+});

package/dist/web/p2p-probe.js

@@ -1,9 +1,14 @@
 (function (root) {
-  // Runs only a bounded connectivity probe. Business frames stay on native WSS.
+  const HIGH_WATER = 1024 * 1024;
+  const LOW_WATER = 512 * 1024;
+  const MAX_QUEUED = 16 * 1024 * 1024;
+
   root.CodeRelaxP2pProbe = class {
-    constructor(send, report) {
-      this.send = send; this.report = report; this.closed = false; this.queue = Promise.resolve();
+    constructor(send, report, receiveData = () => {}) {
+      this.send = send; this.report = report; this.receiveData = receiveData;
+      this.closed = false; this.queue = Promise.resolve(); this.outbound = []; this.queuedBytes = 0; this.dataSerial = 0;
       this.diagnostics = new root.CodeRelaxP2pDiagnostics();
+      this.framer = new root.CodeRelaxP2pDataFramer();
     }
     start() {
       if (typeof root.RTCPeerConnection !== 'function' || !root.crypto?.getRandomValues) {
@@ -29,35 +34,68 @@
       peer.ondatachannel = event => {
         if (this.channel || event.channel.label !== 'code-relax-probe-v1') { event.channel.close(); this.close('failed'); return; }
         const channel = this.channel = event.channel;
-        channel.onopen = () => { if (!this.closed) { this.diagnostics.open = true; channel.send(JSON.stringify({ type: 'ping', nonce: this.nonce })); } };
+        channel.bufferedAmountLowThreshold = LOW_WATER;
+        channel.onbufferedamountlow = () => this.pump();
+        channel.onopen = () => {
+          if (!this.closed) { this.diagnostics.open = true; channel.send(JSON.stringify({ type: 'ping', nonce: this.nonce })); }
+        };
         channel.onerror = () => { this.diagnostics.error = 'channel'; this.close('failed'); };
         channel.onclose = () => this.close('closed');
-        let received = 0;
-        channel.onmessage = event => {
-          if (this.closed) return;
-          try {
-            if (typeof event.data !== 'string' || event.data.length > 4096 || ++received > 4) throw new Error();
-            const message = JSON.parse(event.data);
-            if (message.type === 'ping' && /^[\w-]{16,128}$/.test(message.nonce)) {
-              channel.send(JSON.stringify({ type: 'pong', nonce: message.nonce })); this.pingReceived = true; this.diagnostics.ping = true;
-            } else if (message.type === 'pong' && message.nonce === this.nonce) { this.pongReceived = true; this.diagnostics.pong = true; }
-            else throw new Error();
-            if (this.pingReceived && this.pongReceived) {
-              this.report('verified', this.diagnostics.snapshot('verified')); clearTimeout(this.timer);
-              // Allow the remote peer to receive the final pong before closing.
-              this.timer = setTimeout(() => this.close('complete'), 1000);
-            }
-          } catch { this.diagnostics.error = 'frame'; this.close('failed'); }
-        };
+        channel.onmessage = event => this.receiveChannelMessage(event.data);
       };
     }
+    receiveChannelMessage(value) {
+      if (this.closed) return;
+      try {
+        if (typeof value !== 'string' || value.length > 65536) throw new Error();
+        const message = JSON.parse(value);
+        const data = this.framer.accept(message);
+        if (data.handled) {
+          if (!this.transportActive) throw new Error();
+          if (data.complete) this.receiveData(data.payload);
+          return;
+        }
+        if (message.type === 'ping' && /^[\w-]{16,128}$/.test(message.nonce)) {
+          this.channel.send(JSON.stringify({ type: 'pong', nonce: message.nonce }));
+          this.pingReceived = true; this.diagnostics.ping = true;
+        } else if (message.type === 'pong' && message.nonce === this.nonce) {
+          this.pongReceived = true; this.diagnostics.pong = true;
+        } else throw new Error();
+        this.verify();
+      } catch { this.diagnostics.error = 'frame'; this.close('failed'); }
+    }
+    verify() {
+      if (this.verified || !this.pingReceived || !this.pongReceived) return;
+      this.verified = true; this.transportActive = this.remoteDirect;
+      clearTimeout(this.timer);
+      this.report(this.transportActive ? 'direct' : 'verified', this.diagnostics.snapshot('verified'));
+      this.pump();
+    }
+    sendData(payload) {
+      if (!this.transportActive || this.closed || this.channel?.readyState !== 'open') return false;
+      let item;
+      try { item = this.framer.create(payload, `${this.id}-${++this.dataSerial}`); }
+      catch { return false; }
+      if (this.queuedBytes + item.bytes > MAX_QUEUED) return false;
+      this.outbound.push(item); this.queuedBytes += item.bytes; this.pump(); return true;
+    }
+    pump() {
+      if (!this.transportActive || this.closed || this.channel?.readyState !== 'open') return;
+      try {
+        while (this.outbound.length && this.channel.bufferedAmount < HIGH_WATER) {
+          const item = this.outbound[0], frame = this.framer.frame(item);
+          this.channel.send(frame);
+          if (this.framer.commit(item)) { this.outbound.shift(); this.queuedBytes -= item.bytes; }
+        }
+      } catch { this.diagnostics.error = 'channel'; this.close('failed'); }
+    }
     signal(value) { this.send({ type: 'p2p-probe', version: 1, probeId: this.id, ...value }); }
     receive(message) {
       if (this.closed || message.probeId !== this.id || message.version !== 1) return;
       this.queue = this.queue.then(async () => {
         if (this.closed) return;
         if (message.kind === 'offer' && !this.offerReceived) {
-          this.offerReceived = true;
+          this.offerReceived = true; this.remoteDirect = message.direct === 1;
           this.createPeer((message.iceServers || []).map(url => ({ urls: url })));
           await this.peer.setRemoteDescription({ type: 'offer', sdp: message.sdp });
           this.diagnostics.offer = true;
@@ -65,19 +103,21 @@
           if (this.closed) return;
           await this.peer.setLocalDescription(answer);
           this.diagnostics.answer = true;
-          if (!this.closed) this.signal({ kind: 'answer', sdp: answer.sdp });
+          if (!this.closed) this.signal({ kind: 'answer', sdp: answer.sdp, direct: 1 });
         } else if (message.kind === 'candidate') {
           this.diagnostics.candidate('remote', message.candidate);
           await this.peer.addIceCandidate({ candidate: message.candidate, sdpMid: message.mid });
-        } else this.close('failed');
+        } else if (message.kind === 'close') this.close('closed');
+        else this.close('failed');
       }).catch(() => { this.diagnostics.error = message.kind === 'candidate' ? 'candidate' : 'description'; this.close('failed'); });
     }
-    close(state = 'closed') {
+    close(state = 'closed', silent = false) {
       if (this.closed) return;
-      this.closed = true; clearTimeout(this.timer);
+      this.closed = true; this.transportActive = false; clearTimeout(this.timer);
+      this.outbound = []; this.queuedBytes = 0; this.framer.reset();
       this.channel?.close(); this.peer?.close();
       if (this.id) this.signal({ kind: 'close' });
-      if (!(this.pingReceived && this.pongReceived)) this.report(state, this.diagnostics.snapshot(state));
+      if (!silent) this.report(state, this.diagnostics.snapshot(state));
     }
   };
 })(globalThis);

package/dist/web/page-resume.js

@@ -0,0 +1,28 @@
+(function (root) {
+  function preferredThreadId(options) {
+    const { pageResume, resumeConfig, saved, visited } = options;
+    return pageResume ? (resumeConfig?.resumeThreadId || saved?.selectedId || '') : (visited?.id || '');
+  }
+
+  async function resolveConversation(options) {
+    const { pageResume, resumeConfig, saved, threads, visited, readCached, readLastCached, onCacheError } = options;
+    const requestedThreadId = preferredThreadId({ pageResume, resumeConfig, saved, visited });
+    const requestedThread = requestedThreadId
+      ? saved?.selectedThread || threads.find(thread => thread.id === requestedThreadId)
+        || (visited?.id === requestedThreadId ? visited : { id: requestedThreadId })
+      : null;
+    let cached = saved?.timeline || null;
+    if (requestedThreadId && cached?.thread?.id !== requestedThreadId) cached = null;
+    if (!cached && requestedThread) {
+      cached = await readCached(requestedThreadId, requestedThread).catch(error => {
+        onCacheError(error);
+        return null;
+      }) || { thread: requestedThread, turns: [] };
+    }
+    if (!cached && !pageResume) cached = await readLastCached();
+    if (!cached?.thread || (requestedThreadId && cached.thread.id !== requestedThreadId)) return null;
+    return cached;
+  }
+
+  root.CodexPageResume = Object.freeze({ preferredThreadId, resolveConversation });
+})(globalThis);

package/dist/web/pending-message-store.js

@@ -0,0 +1,108 @@
+(function (root) {
+  function createPendingMessageStore() {
+    const messagesByThread = new Map();
+    const clientId = item => item?.clientId || item?.clientUserMessageId;
+    const normalizeText = text => (text || '').replace(/\r\n?/g, '\n').trim();
+    const isImage = attachment => attachment && (attachment.type === 'image' || attachment.type === 'localImage');
+
+    function entries(timeline) {
+      return (timeline?.turns || []).flatMap(turn => (turn.entries || [])
+        .map(entry => ({ ...entry, turnId: turn.id, key: `${turn.id}/${entry.id}` })));
+    }
+
+    function baseline(timeline) {
+      return new Set(entries(timeline).map(entry => entry.key));
+    }
+
+    function get(threadId) {
+      return messagesByThread.get(threadId) || [];
+    }
+
+    function set(threadId, messages) {
+      if (messages?.length) messagesByThread.set(threadId, messages);
+      else messagesByThread.delete(threadId);
+    }
+
+    function has(threadId, message) {
+      return get(threadId).includes(message);
+    }
+
+    function retainImagePreviews(threadId, data) {
+      if (!data || data.cached) return;
+      const messages = get(threadId);
+      if (!messages.length) return;
+      const candidates = entries(data);
+      const consumed = new Set();
+      for (const message of messages) {
+        let match;
+        if (message.clientUserMessageId) {
+          match = candidates.find(candidate => candidate.role === 'user' && !consumed.has(candidate.key)
+            && clientId(candidate) === message.clientUserMessageId);
+        }
+        match ||= candidates.find(candidate => candidate.role === 'user' && !consumed.has(candidate.key)
+          && !message.baseline.has(candidate.key)
+          && !(clientId(candidate) && message.baselineClientIds?.has(clientId(candidate)))
+          && !(message.clientUserMessageId && clientId(candidate))
+          && (!message.turnId || candidate.turnId === message.turnId || (message.settled && !message.status))
+          && normalizeText(candidate.text) === normalizeText(message.text)
+          && (candidate.attachments || []).length === message.attachments.length);
+        if (!match) continue;
+        consumed.add(match.key);
+        const previews = (message.attachments || []).filter(isImage);
+        const attachments = (match.attachments || []).filter(isImage);
+        attachments.forEach((attachment, index) => {
+          const preview = previews[index];
+          const url = preview?.url || preview?.thumbnailUrl;
+          if (!attachment.url && url) Object.assign(attachment, {
+            available: true,
+            url,
+            thumbnailUrl: preview.thumbnailUrl || url,
+          });
+        });
+      }
+    }
+
+    function reconcile(threadId, timeline) {
+      const messages = get(threadId);
+      const candidates = entries(timeline);
+      const consumed = new Set();
+      const matches = new Map();
+      if (!timeline?.cached) for (const message of messages) {
+        if (!message.clientUserMessageId) continue;
+        const match = candidates.find(entry => entry.role === 'user' && !consumed.has(entry.key)
+          && clientId(entry) === message.clientUserMessageId);
+        if (match) {
+          matches.set(message, match);
+          consumed.add(match.key);
+        }
+      }
+      let interruptedUnconfirmed = 0;
+      const remaining = messages.filter(message => {
+        const match = matches.get(message) || (!timeline?.cached && candidates.find(entry => entry.role === 'user'
+          && !message.baseline.has(entry.key) && !consumed.has(entry.key)
+          && !(clientId(entry) && message.baselineClientIds?.has(clientId(entry)))
+          && !(message.clientUserMessageId && clientId(entry))
+          && (!message.turnId || entry.turnId === message.turnId || (message.settled && !message.status))
+          && normalizeText(entry.text) === normalizeText(message.text)
+          && (entry.attachments || []).length === message.attachments.length));
+        if (match) consumed.add(match.key);
+        if (!match && !timeline?.cached && message.settled && !message.status && message.turnId
+          && timeline?.turns?.some(turn => turn.id === message.turnId && turn.status === 'interrupted')) {
+          interruptedUnconfirmed++;
+          return false;
+        }
+        return !match;
+      });
+      for (const message of remaining) for (const entry of candidates) if (consumed.has(entry.key)) {
+        message.baseline.add(entry.key);
+        if (clientId(entry)) (message.baselineClientIds ||= new Set()).add(clientId(entry));
+      }
+      set(threadId, remaining);
+      return { remaining, interruptedUnconfirmed };
+    }
+
+    return Object.freeze({ baseline, get, has, reconcile, retainImagePreviews, set });
+  }
+
+  root.createPendingMessageStore = createPendingMessageStore;
+})(globalThis);

package/dist/web/queue-controller.js

@@ -0,0 +1,82 @@
+(function (root) {
+  function createQueueController(options) {
+    const {
+      document, el, api, state, pendingMessages,
+      isComposerActive, isConnectionBlocked, isThreadReadOnly,
+      renderPendingMessages, scrollTimelineToBottom, showToast,
+    } = options;
+    const steering = new Set();
+
+    function render(items) {
+      const panel = el('queuePanel');
+      panel.replaceChildren();
+      for (const item of items) {
+        const row = document.createElement('div');
+        row.className = 'queued-message';
+        const text = document.createElement('span');
+        text.className = `queued-text${item.error ? ' queued-error' : ''}`;
+        text.textContent = item.error ? `${item.prompt} · ${item.error}` : item.prompt;
+        text.title = text.textContent;
+        const steerButton = document.createElement('button');
+        steerButton.className = 'queue-action';
+        steerButton.type = 'button';
+        steerButton.textContent = '↪ 引导';
+        steerButton.onclick = () => steer(item);
+        const removeButton = document.createElement('button');
+        removeButton.className = 'queue-action';
+        removeButton.type = 'button';
+        removeButton.textContent = '删除';
+        removeButton.onclick = () => remove(item.id);
+        const key = `${state.selectedId}/${item.id}`;
+        steerButton.disabled = removeButton.disabled = isConnectionBlocked() || isThreadReadOnly() || steering.has(key);
+        row.append(text, steerButton, removeButton);
+        panel.append(row);
+      }
+      panel.hidden = !items.length;
+    }
+
+    async function steer(item) {
+      const threadId = state.selectedId;
+      const key = `${threadId}/${item.id}`;
+      if (!threadId || isConnectionBlocked() || steering.has(key)) return;
+      steering.add(key);
+      const message = {
+        queueItemId: item.id,
+        clientUserMessageId: item.clientUserMessageId,
+        text: item.text ?? item.prompt,
+        attachments: item.attachments || [],
+        status: '',
+        turnId: isComposerActive() ? state.timeline?.turns?.at(-1)?.id : null,
+        settled: false,
+        baseline: pendingMessages.baseline(state.timeline),
+      };
+      pendingMessages.set(threadId, [...pendingMessages.get(threadId), message]);
+      renderPendingMessages();
+      scrollTimelineToBottom(true);
+      try {
+        const result = await api(`/api/threads/${encodeURIComponent(threadId)}/queue/${item.id}/steer`, { method: 'POST' });
+        if (state.selectedId === threadId) render(result.items || []);
+      } catch (error) {
+        message.status = '发送未确认，收到正式消息后会自动合并';
+        showToast(`插队失败：${error.message}`);
+      } finally {
+        message.settled = true;
+        steering.delete(key);
+        if (state.selectedId === threadId) renderPendingMessages();
+      }
+    }
+
+    async function remove(itemId) {
+      try {
+        const result = await api(`/api/threads/${encodeURIComponent(state.selectedId)}/queue/${itemId}`, { method: 'DELETE' });
+        render(result.items || []);
+      } catch (error) {
+        showToast(`删除失败：${error.message}`);
+      }
+    }
+
+    return Object.freeze({ render });
+  }
+
+  root.createQueueController = createQueueController;
+})(globalThis);

package/dist/web/resources.json

@@ -1 +1 @@
-["server-requests.js","approval-ui.js","chat.css","highlight.min.js","highlight-powershell.min.js","capabilities.js","timeline-sync.js","harmony-platform.js","client-platform.js","lan-session.js","history-cache.js","p2p-diagnostics.js","p2p-probe.js","self-relay-session.js","chat-transport.js","chat.js"]
+["server-requests.js","approval-ui.js","chat.css","community.css","highlight.min.js","highlight-powershell.min.js","capabilities.js","timeline-sync.js","timeline-reducer.js","harmony-platform.js","client-platform.js","lan-session.js","history-cache.js","p2p-diagnostics.js","p2p-data-channel.js","p2p-probe.js","self-relay-session.js","chat-transport.js","page-resume.js","conversation-controller.js","history-controller.js","usage-controller.js","task-list-view.js","draft-controller.js","thread-attention-controller.js","thread-title-controller.js","thread-list-controller.js","thread-list-sync.js","station-connection-controller.js","disclosure-state-controller.js","pending-message-store.js","queue-controller.js","thread-context-controller.js","composer-controller.js","message-send-controller.js","link-action-controller.js","message-view.js","activity-view.js","community-view.js","timeline-formatters.js","timeline-scroll-controller.js","timeline-renderer.js","chat.js"]

package/dist/web/self-relay-session.js

@@ -2,31 +2,40 @@
   let socketSerial = 0;
   const nativeViews = new Map();
   root.computerConnectionEvent = (key, event, value) => nativeViews.get(key)?.emit(event, JSON.parse(value));
-  class NativeView extends EventTarget {
-    constructor() {
-      super(); this.key = `${Date.now()}-${++socketSerial}`; this.readyState = 0; nativeViews.set(this.key, this);
-      queueMicrotask(() => { if (this.readyState === 0) { this.readyState = 1; this.emit('open', {}); } });
-    }
+  class NativeView extends EventTarget {
+    constructor() {
+      super(); this.key = `${Date.now()}-${++socketSerial}`; this.readyState = 0; this.autoProbeStarted = false; nativeViews.set(this.key, this);
+      queueMicrotask(() => { if (this.readyState === 0) { this.readyState = 1; this.emit('open', {}); } });
+    }
     emit(type, value) {
       if (this.readyState === 3) return;
       if (type === 'message' && value.type === 'p2p-probe') { this.probe?.receive(value); return; }
       if (type === 'message' && value.type === 'p2p-restart') { this.startProbe(); return; }
-      if (type === 'close') this.probe?.close();
-      if (type === 'close') { this.readyState = 3; nativeViews.delete(this.key); }
+      if (type === 'message' && value.type === 'p2p-data-out') {
+        const sent = typeof value.payload === 'string' && this.probe?.sendData(value.payload) === true;
+        root.codexNative.computerTransport(JSON.stringify({ type: 'p2p-data-result', key: this.key,
+          payload: JSON.stringify({ token: value.token, sent }) }));
+        return;
+      }
+      if (type === 'close') { this.probe?.close(); this.readyState = 3; nativeViews.delete(this.key); }
+      this.dispatch(type, value);
+      if (type === 'message' && value.type === 'ready' && value.p2pProbe === 1 && !this.autoProbeStarted) {
+        this.autoProbeStarted = true; queueMicrotask(() => { if (this.readyState !== 3) this.startProbe(); });
+      }
+    }
+    dispatch(type, value) {
       const event = type === 'message' ? new MessageEvent(type, { data: JSON.stringify(value) }) : new Event(type);
       if (type === 'close') Object.defineProperty(event, 'code', { value: value.code });
       this.dispatchEvent(event); this[`on${type}`]?.(event);
     }
-    // WebRTC is diagnostic-only. Never start it on connection readiness; the
-    // native diagnostics dialog explicitly emits p2p-restart for one test.
     startProbe() {
-      this.probe?.close('replaced');
+      this.probe?.close('replaced', true);
       this.probe = new root.CodeRelaxP2pProbe(
         signal => root.codexNative.computerTransport(JSON.stringify({ type: 'p2p-probe', key: this.key, payload: JSON.stringify(signal) })),
         (state, diagnostic) => {
           if (diagnostic) root.codexNative.computerTransport(JSON.stringify({ type: 'p2p-diagnostic', key: this.key, payload: diagnostic }));
           root.codexNative.computerTransport(JSON.stringify({ type: 'p2p-status', key: this.key, payload: state }));
-        });
+        }, payload => root.codexNative.computerTransport(JSON.stringify({ type: 'p2p-data-in', key: this.key, payload })));
       try { this.probe.start(); }
       catch { this.probe.diagnostics.error = 'initialization'; this.probe.close('failed'); }
     }
@@ -37,8 +46,8 @@
     }
     close() {
       this.probe?.close();
-      root.codexNative.computerTransport(JSON.stringify({ type: 'detach', key: this.key }));
-      this.emit('close', { code: 1000 });
+      root.codexNative.computerTransport(JSON.stringify({ type: 'detach', key: this.key }));
+      this.emit('close', { code: 1000 });
     }
   }
   // Reuse LAN request, subscription and disconnect semantics; replace only the envelope.
@@ -57,13 +66,14 @@
       return code ? { type: 'pair', room, code, clientId, ...(credential ? { credential } : {}) } : { type: 'resume', room, credential, clientId };
     }
     closeError(event) {
-      const reasons = { 4401: '设备授权不存在或已撤销，请重新扫码授权', 4408: '配对码已过期或使用，请生成新的首次授权码',
-        4406: 'Code Relax 中继协议需要升级，请更新工作站和手机', 4409: '连接已由同一设备的新连接接替', 4410: '工作站暂时离线，正在等待恢复，设备授权仍保留',
-        1011: '工作站 Bridge 暂时不可用，正在恢复连接' };
+      const reasons = { 4401: '设备授权不存在或已撤销，请重新扫码授权', 4408: '配对码已过期或使用，请生成新的首次授权码',
+        4406: 'Code Relax 中继协议需要升级，请更新工作站和手机', 4409: '连接已由同一设备的新连接接替', 4410: '工作站暂时离线，正在等待恢复，设备授权仍保留',
+        4428: '当前服务器压力较大，请稍后再试',
+        1011: '工作站 Bridge 暂时不可用，正在恢复连接' };
       const error = new TypeError(reasons[event.code] || `Code Relax 中继连接已断开（${event.code}），正在恢复`);
       error.code = event.code;
       if (event.code === 4401) root.codexHistoryCache?.clear().catch(() => {});
-      if ([1008, 4401, 4406, 4408, 4409, 4429].includes(event.code)) this.terminalError = error;
+      if ([1008, 4401, 4406, 4408, 4409, 4428, 4429].includes(event.code)) this.terminalError = error;
       return error;
     }
     encodeMessage(message) {
@@ -80,7 +90,7 @@
     decodeMessage(message) {
       if (message.type === 'paired') {
         if (message.room !== this.config.room) throw new Error('配对工作站不匹配');
-        if (this.config.clientId && message.protocolVersion !== 3) {
+        if (this.config.clientId && message.protocolVersion !== 7) {
           this.terminalError = Object.assign(new TypeError('Code Relax 中继协议需要升级'), { code: 4406 }); throw this.terminalError;
         }
         if (message.credential && this.config.credential && message.credential !== this.config.credential) throw new Error('设备凭据与已保存身份不一致');