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

package/dist/web/p2p-probe.js

@@ -1,123 +0,0 @@
-(function (root) {
-  const HIGH_WATER = 1024 * 1024;
-  const LOW_WATER = 512 * 1024;
-  const MAX_QUEUED = 16 * 1024 * 1024;
-
-  root.CodeRelaxP2pProbe = class {
-    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) {
-        this.close('unsupported'); return;
-      }
-      this.id = Array.from(crypto.getRandomValues(new Uint8Array(16)), n => n.toString(16).padStart(2, '0')).join('');
-      this.nonce = this.id;
-      this.timer = setTimeout(() => this.close('timeout'), 15000);
-      this.report('negotiating'); this.signal({ kind: 'start' });
-    }
-    createPeer(iceServers) {
-      const peer = this.peer = new RTCPeerConnection({ iceServers });
-      peer.onicecandidate = event => {
-        if (event.candidate && !this.closed) this.signal({ kind: 'candidate', candidate: event.candidate.candidate, mid: event.candidate.sdpMid || '0' });
-        if (event.candidate && !this.closed) this.diagnostics.candidate('local', event.candidate.candidate);
-      };
-      peer.oniceconnectionstatechange = () => { if (!this.closed) this.diagnostics.ice = peer.iceConnectionState; };
-      peer.onicegatheringstatechange = () => { if (!this.closed) this.diagnostics.gathering = peer.iceGatheringState; };
-      peer.onicecandidateerror = () => { if (!this.closed) this.diagnostics.error = 'stun'; };
-      peer.onconnectionstatechange = () => {
-        if (['failed', 'closed', 'disconnected'].includes(peer.connectionState)) this.close('failed');
-      };
-      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.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');
-        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.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;
-          const answer = await this.peer.createAnswer();
-          if (this.closed) return;
-          await this.peer.setLocalDescription(answer);
-          this.diagnostics.answer = true;
-          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 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', silent = false) {
-      if (this.closed) return;
-      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 (!silent) this.report(state, this.diagnostics.snapshot(state));
-    }
-  };
-})(globalThis);

package/dist/web/page-resume.js

@@ -1,28 +0,0 @@
-(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

@@ -1,108 +0,0 @@
-(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

@@ -1,82 +0,0 @@
-(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 +0,0 @@
-["server-requests.js","approval-ui.js","chat.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","timeline-formatters.js","timeline-scroll-controller.js","timeline-renderer.js","chat.js"]

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

@@ -1,129 +0,0 @@
-(function (root) {
-  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; 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 === '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);
-    }
-    startProbe() {
-      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'); }
-    }
-    send(value) {
-      const frame = JSON.parse(value);
-      if (frame.type === 'data') root.codexNative.computerTransport(JSON.stringify({ type: 'send', key: this.key, payload: frame.payload }));
-      else root.codexNative.computerTransport(JSON.stringify({ type: 'attach', key: this.key }));
-    }
-    close() {
-      this.probe?.close();
-      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.
-  root.CodexSelfRelaySession = class extends root.CodexLanSession {
-    constructor() { super(''); this.config = root.codexSelfRelayConfig; }
-    createSocket() { return root.codexNative?.computerTransport ? new NativeView() : super.createSocket(); }
-    connect() { return this.terminalError ? Promise.reject(this.terminalError) : super.connect(); }
-    socketUrl() {
-      const url = new URL(this.config.url);
-      if ((url.protocol !== 'wss:' && !(url.protocol === 'ws:' && url.hostname === '127.0.0.1')) ||
-          url.pathname !== '/relay' || url.search || url.hash || url.username || url.password) throw new Error('无效的Code Relax 中继地址');
-      return url.href;
-    }
-    authenticationMessage() {
-      const { room, code, credential, clientId } = this.config;
-      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: '工作站暂时离线，正在等待恢复，设备授权仍保留',
-        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, 4428, 4429].includes(event.code)) this.terminalError = error;
-      return error;
-    }
-    encodeMessage(message) {
-      const frame = { type: 'data', payload: JSON.stringify(message) };
-      if (new TextEncoder().encode(JSON.stringify(frame)).length > 8 * 1024 * 1024) throw new Error('Code Relax 中继私测消息超过 8 MiB，请减少图片或内容');
-      return frame;
-    }
-    async pause() {
-      const socket = this.socket;
-      if (!socket || socket.readyState === 3) return super.pause();
-      const closed = new Promise(resolve => socket.addEventListener('close', resolve, { once: true }));
-      await super.pause(); await closed;
-    }
-    decodeMessage(message) {
-      if (message.type === 'paired') {
-        if (message.room !== this.config.room) throw new Error('配对工作站不匹配');
-        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('设备凭据与已保存身份不一致');
-        if (message.credential) this.config.credential = message.credential;
-        if (Number.isSafeInteger(message.revision) && message.revision >= 0) {
-          if (this.config.revision !== undefined && this.config.revision !== message.revision) root.codexHistoryCache?.clear().catch(() => {});
-          this.config.revision = message.revision;
-        }
-        delete this.config.code;
-        root.codexNative?.selfRelayPaired?.(message.room, this.config.credential, this.config.revision || 0);
-        return null;
-      }
-      if (message.type === 'lan-candidates' && Array.isArray(message.candidates)) {
-        root.codexNative?.selfRelayLanCandidates?.(JSON.stringify(message.candidates));
-        return null;
-      }
-      if (message.type === 'computer-info' && typeof message.hostName === 'string') {
-        root.codexNative?.selfRelayComputerInfo?.(message.hostName);
-        return null;
-      }
-      if (message.type === 'ready') return message;
-      if (message.type === 'data' && typeof message.payload === 'string') {
-        const started = performance.now();
-        const decoded = JSON.parse(message.payload);
-        const path = this.pending.get(decoded.id)?.path || '';
-        const route = /\/timeline(?:\?|$)/.test(path) ? 'timeline' : /\/history\?/.test(path) ? 'history'
-          : /^\/api\/threads\?/.test(path) ? 'list' : '';
-        if (route && root.codexNative?.reportSyncMetric) {
-          root.codexNative.reportSyncMetric(`stage=parse;route=${route};ms=${Math.round(performance.now() - started)};chars=${message.payload.length}`);
-        }
-        return decoded;
-      }
-      throw new Error('无效的Code Relax 中继消息');
-    }
-  };
-})(globalThis);

package/dist/web/server-requests.js

@@ -1,67 +0,0 @@
-(function (root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory();
-  else root.CodexServerRequests = factory();
-})(globalThis, function () {
-  const command = 'item/commandExecution/requestApproval';
-  const file = 'item/fileChange/requestApproval';
-  const input = 'item/tool/requestUserInput';
-  const equal = (a, b) => JSON.stringify(a) === JSON.stringify(b);
-  function decisions(request) {
-    if (request.method === command) return request.params.availableDecisions ?? ['accept', 'acceptForSession', 'decline', 'cancel'];
-    if (request.method === file) return ['accept', 'acceptForSession', 'decline', 'cancel'];
-    return [];
-  }
-  function validate(request, result) {
-    if ([command, file].includes(request.method)) {
-      if (!result || Object.keys(result).length !== 1 || !decisions(request).some(value => equal(value, result.decision))) throw new Error('审批选项不属于当前请求');
-      return;
-    }
-    if (request.method === input) {
-      const questions = request.params.questions || [];
-      if (!result?.answers || Object.keys(result).length !== 1 || Object.keys(result.answers).length !== questions.length
-        || questions.some(q => !Array.isArray(result.answers[q.id]?.answers) || result.answers[q.id].answers.some(a => typeof a !== 'string'))) throw new Error('回答格式无效');
-      return;
-    }
-    throw new Error('此类请求需在工作站处理');
-  }
-  class Store {
-    constructor(epoch, changed = () => {}) { this.epoch = epoch; this.changed = changed; this.requests = new Map(); }
-    list(threadId) { return [...this.requests.values()].filter(r => r.params.threadId === threadId).map(r => ({ ...r })); }
-    receive(message) {
-      if (!['string', 'number'].includes(typeof message.id) || !message.params?.threadId || this.requests.has(message.id)) return;
-      const request = { id: message.id, method: message.method, params: message.params, epoch: this.epoch, status: 'pending' };
-      this.requests.set(message.id, request); this.changed(request.params.threadId);
-    }
-    notification(method, params) {
-      if (method === 'serverRequest/resolved') {
-        const request = this.requests.get(params.requestId);
-        if (request?.params.threadId === params.threadId) { this.requests.delete(params.requestId); this.changed(params.threadId); }
-      } else if (method === 'turn/completed' || method === 'thread/closed') {
-        for (const [id, r] of this.requests) if (r.params.threadId === params.threadId && (method === 'thread/closed' || r.params.turnId === params.turn?.id)) this.requests.delete(id);
-        this.changed(params.threadId);
-      }
-    }
-    forget(threadId) {
-      for (const [id, request] of this.requests) if (request.params.threadId === threadId) this.requests.delete(id);
-      this.changed(threadId);
-    }
-    reset(epoch) {
-      const threads = new Set([...this.requests.values()].map(r => r.params.threadId));
-      this.requests.clear(); this.epoch = epoch; for (const id of threads) this.changed(id);
-    }
-    async respond(threadId, { id, epoch, result }, send) {
-      const request = this.requests.get(id);
-      if (!request || epoch !== this.epoch || request.params.threadId !== threadId) throw new Error('审批已处理或连接已变化，请等待同步');
-      if (request.status !== 'pending') throw new Error('决定已提交，正在等待工作站确认，请勿重复提交');
-      validate(request, result);
-      request.status = 'submitted'; this.changed(threadId);
-      try { await send({ id: request.id, result }); }
-      catch (error) {
-        if (this.requests.get(id) === request) { request.status = 'unknown'; this.changed(threadId); }
-        throw new Error('审批发送结果未确认，请检查工作站；不会自动重发。' + error.message);
-      }
-      return { submitted: true };
-    }
-  }
-  return { Store, decisions, validate, command, file, input };
-});

package/dist/web/station-connection-controller.js

@@ -1,75 +0,0 @@
-(function (root) {
-  function createStationConnectionController(options) {
-    let recoveryTask = null;
-    let epoch = 0;
-    let paused = false;
-
-    function isCurrent(value) {
-      return !paused && value === epoch;
-    }
-
-    function suspend() {
-      paused = true;
-      epoch++;
-      recoveryTask = null;
-      options.onSuspend?.();
-    }
-
-    function activate() {
-      paused = false;
-    }
-
-    function recover() {
-      if (paused) return Promise.resolve();
-      if (recoveryTask) return recoveryTask;
-      const recoveryEpoch = ++epoch;
-      recoveryTask = Promise.resolve().then(async () => {
-        let attempts = 0;
-        options.onStarted?.();
-        while (isCurrent(recoveryEpoch)) {
-          options.onAttempt?.();
-          try {
-            await options.connect();
-            if (!isCurrent(recoveryEpoch)) return;
-            try { await options.restore(); }
-            catch (error) {
-              if (!isCurrent(recoveryEpoch)) return;
-              if (options.isConnected?.()) {
-                options.onRestoreFailure?.(error);
-                return;
-              }
-              throw error;
-            }
-            if (!isCurrent(recoveryEpoch)) return;
-            options.onRecovered?.(attempts + 1);
-            return;
-          } catch (error) {
-            if (!isCurrent(recoveryEpoch)) return;
-            if (options.isTerminal(error)) {
-              options.onTerminal?.(error);
-              return;
-            }
-            options.onRetry?.(error, attempts + 1);
-            const delay = Math.min(1000 * 2 ** Math.min(attempts++, 5), 30000) * (0.8 + Math.random() * 0.2);
-            await new Promise(resolve => setTimeout(resolve, delay));
-          }
-        }
-      }).finally(() => {
-        if (recoveryEpoch === epoch) recoveryTask = null;
-      });
-      return recoveryTask;
-    }
-
-    return Object.freeze({
-      recover,
-      suspend,
-      activate,
-      isPaused: () => paused,
-      isRecovering: () => Boolean(recoveryTask),
-      generation: () => epoch,
-      isCurrent,
-    });
-  }
-
-  root.createStationConnectionController = createStationConnectionController;
-})(globalThis);