@ganglion/xacpx-relay 0.14.7 → 0.14.9-beta.0

package/dist/cli.js

@@ -7251,11 +7251,15 @@ import { dirname as dirname3, join as join2, resolve } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/relay/src/server.ts
+import { createServer } from "node:http";
 import { serve } from "@hono/node-server";
 import { WebSocketServer } from "ws";
 import {
+  DESKTOP_TICKET_TTL_MS as DESKTOP_TICKET_TTL_MS2,
+  DESKTOP_WS_MAX_PAYLOAD_BYTES as DESKTOP_WS_MAX_PAYLOAD_BYTES2,
+  MAX_DESKTOP_TICKET_LENGTH as MAX_DESKTOP_TICKET_LENGTH2,
   MAX_TOOL_STEPS,
-  MSG as MSG4,
+  MSG as MSG5,
   REASONING_CAP,
   STATE_SYNC_PARTS_CAP,
   STATE_SYNC_TEXT_CAP,
@@ -8175,9 +8179,141 @@ import {
   decodeEnvelope,
   encodeEnvelope,
   errorPayload,
-  normalizeCapabilities
+  normalizeCapabilities,
+  validateInteractionRequest,
+  validateInteractionWithdraw
 } from "@ganglion/xacpx-relay-protocol";
 
+// packages/relay/src/interaction-registry.ts
+function interactionResultForBrowser(result, accountId) {
+  if (typeof result !== "object" || result === null) {
+    return { responded: false, reason: "aborted" };
+  }
+  const outcome = result;
+  if (outcome.responded !== true) {
+    const reason = typeof outcome.reason === "string" ? outcome.reason : "aborted";
+    return {
+      responded: false,
+      reason: reason === "timeout" || reason === "aborted" || reason === "shutdown" || reason === "unsupported" || reason === "channel-missing" ? reason : "aborted"
+    };
+  }
+  const response = outcome.response;
+  if (typeof response !== "object" || response === null) {
+    return { responded: false, reason: "aborted" };
+  }
+  const decision = response;
+  return {
+    responded: true,
+    response: { ...decision, responderId: accountId }
+  };
+}
+
+class InteractionRegistry {
+  logger;
+  pending = new Map;
+  closedListeners = new Set;
+  constructor(logger) {
+    this.logger = logger;
+  }
+  onClose(listener) {
+    this.closedListeners.add(listener);
+    return () => {
+      this.closedListeners.delete(listener);
+    };
+  }
+  get size() {
+    return this.pending.size;
+  }
+  open(entry) {
+    const withTimer = { ...entry, closed: false };
+    withTimer.timer = setTimeout(() => {
+      this.close(entry.requestId, "expired");
+    }, Math.max(0, entry.answerWindowMs));
+    if (typeof withTimer.timer.unref === "function")
+      withTimer.timer.unref();
+    this.pending.set(entry.requestId, withTimer);
+    this.logger.debug("relay.interaction.opened", "interaction opened", {
+      requestId: entry.requestId,
+      instanceId: entry.instanceId,
+      kind: entry.kind
+    });
+  }
+  answer(requestId, decision) {
+    const entry = this.pending.get(requestId);
+    if (!entry || entry.closed)
+      return null;
+    if (entry.kind !== decision.kind) {
+      return null;
+    }
+    if (Date.now() >= entry.expiresAt) {
+      this.close(requestId, "expired");
+      return null;
+    }
+    this.finish(entry, "resolved", decision.action);
+    entry.resolve(decision);
+    return entry;
+  }
+  close(requestId, reason) {
+    const entry = this.pending.get(requestId);
+    if (!entry || entry.closed)
+      return false;
+    this.finish(entry, reason);
+    entry.reject(reason);
+    return true;
+  }
+  listForInstance(instanceId) {
+    const entries = [];
+    for (const entry of this.pending.values()) {
+      if (entry.instanceId === instanceId)
+        entries.push(entry);
+    }
+    return entries;
+  }
+  listForAccount(accountId) {
+    const entries = [];
+    for (const entry of this.pending.values()) {
+      if (entry.accountId === accountId)
+        entries.push(entry);
+    }
+    return entries;
+  }
+  get(requestId) {
+    const entry = this.pending.get(requestId);
+    return entry && !entry.closed ? entry : null;
+  }
+  finish(entry, reason, action) {
+    entry.closed = true;
+    if (entry.timer !== undefined) {
+      clearTimeout(entry.timer);
+      entry.timer = undefined;
+    }
+    this.pending.delete(entry.requestId);
+    this.logger.debug("relay.interaction.closed", "interaction closed", {
+      requestId: entry.requestId,
+      instanceId: entry.instanceId,
+      reason,
+      ...action !== undefined ? { action } : {}
+    });
+    for (const listener of this.closedListeners) {
+      try {
+        listener({
+          requestId: entry.requestId,
+          instanceId: entry.instanceId,
+          accountId: entry.accountId,
+          kind: entry.kind,
+          reason,
+          ...action !== undefined ? { action } : {}
+        });
+      } catch (error) {
+        this.logger.debug("relay.interaction.close_listener_failed", "interaction close listener threw", {
+          requestId: entry.requestId,
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+}
+
 // packages/relay/src/logging.ts
 var ORDER = { error: 0, warn: 1, info: 2, debug: 3 };
 function createNoopRelayLogger() {
@@ -8339,6 +8475,9 @@ class InstanceGateway {
   isOnline(instanceId) {
     return this.connections.has(instanceId);
   }
+  broadcastControlEvent(accountId, event) {
+    this.deps.broadcastControlEvent?.(accountId, event);
+  }
   handleConnection(socket) {
     let authed = null;
     startHeartbeat(socket, this.deps.heartbeatIntervalMs, undefined, this.logger);
@@ -8374,6 +8513,12 @@ class InstanceGateway {
         p.reject(new Error("instance-offline"));
       }
     }
+    const interactions = this.deps.interactions;
+    if (interactions) {
+      for (const entry of interactions.listForInstance(instanceId)) {
+        interactions.close(entry.requestId, "withdrawn");
+      }
+    }
     this.deps.onStatusChange?.(instanceId, accountId, false);
     this.broadcastDirectorySnapshot(accountId);
   }
@@ -8622,6 +8767,76 @@ class InstanceGateway {
         }).catch((err) => respond(errorPayload(err.code ?? "DELIVERY_FAILED", err instanceof Error ? err.message : String(err))));
         return;
       }
+      if (envelope.type === MSG.interactionRequest) {
+        const parsed = validateInteractionRequest(envelope.payload);
+        if (!parsed) {
+          respond(errorPayload("invalid-payload", `${MSG.interactionRequest}: malformed payload`));
+          return;
+        }
+        const registry = this.deps.interactions;
+        if (!registry) {
+          respond(errorPayload("interaction-unavailable", "interaction registry is not configured"));
+          return;
+        }
+        const instanceId = authed.instanceId;
+        const accountId = authed.accountId;
+        const chatKey = `relay:${accountId}`;
+        const requestId = parsed.requestId;
+        const now = Date.now();
+        if (parsed.expiresAt <= now) {
+          respond({ responded: false, reason: "timeout" });
+          return;
+        }
+        if (parsed.kind !== "elicitation") {
+          respond({ responded: false, reason: "unsupported" });
+          return;
+        }
+        const answerWindowMs = parsed.expiresAt - now;
+        registry.open({
+          requestId,
+          instanceId,
+          accountId,
+          kind: parsed.kind,
+          expiresAt: parsed.expiresAt,
+          chatKey,
+          sessionAlias: "",
+          answerWindowMs,
+          timeoutMs: answerWindowMs + REQUEST_RESPONSE_RESERVE_MS,
+          ...parsed.conversation !== undefined ? { conversation: parsed.conversation } : {},
+          ...parsed.elicitation !== undefined ? { elicitation: parsed.elicitation } : {},
+          ...parsed.permission !== undefined ? { permission: parsed.permission } : {},
+          resolve: (decision) => respond(interactionResultForBrowser({ responded: true, response: decision }, accountId)),
+          reject: (reason) => respond({ responded: false, reason: reason === "expired" ? "timeout" : "withdrawn" })
+        });
+        this.deps.broadcastControlEvent?.(accountId, {
+          type: "interaction-opened",
+          chatKey,
+          sessionAlias: "",
+          instanceId,
+          interaction: parsed
+        });
+        return;
+      }
+      if (envelope.type === MSG.interactionWithdraw) {
+        const parsed = validateInteractionWithdraw(envelope.payload);
+        if (!parsed) {
+          respond(errorPayload("invalid-payload", `${MSG.interactionWithdraw}: malformed payload`));
+          return;
+        }
+        const registry = this.deps.interactions;
+        if (!registry) {
+          respond(errorPayload("interaction-unavailable", "interaction registry is not configured"));
+          return;
+        }
+        const pending = registry.get(parsed.requestId);
+        if (!pending || pending.instanceId !== authed.instanceId || pending.accountId !== authed.accountId) {
+          respond({ ok: true });
+          return;
+        }
+        registry.close(parsed.requestId, "withdrawn");
+        respond({ ok: true });
+        return;
+      }
       respond(errorPayload("invalid-request", `unknown request type: ${envelope.type}`));
       return;
     }
@@ -8816,6 +9031,7 @@ class WebGateway {
     this.options.logger?.debug("relay.web.connected", "web client connected", { accountId });
     startHeartbeat(socket, this.options.heartbeatIntervalMs, undefined, this.options.logger);
     socket.on("close", () => {
+      const closedViewerId = this.viewerBySocket.get(socket);
       this.clearSocketAttachments(socket);
       set.delete(socket);
       this.subscriptions.delete(socket);
@@ -8824,6 +9040,8 @@ class WebGateway {
       this.attachmentsBySocket.delete(socket);
       if (set.size === 0)
         this.byAccount.delete(accountId);
+      if (closedViewerId)
+        this.options.onViewerClosed?.(closedViewerId);
       this.options.logger?.debug("relay.web.disconnected", "web client disconnected", { accountId });
     });
     return viewerId;
@@ -8956,6 +9174,443 @@ class WebGateway {
   }
 }
 
+// packages/relay/src/gateway/desktop-stream-gateway.ts
+import {
+  DESKTOP_BUFFERED_HARD_CLOSE_BYTES,
+  DESKTOP_WS_MAX_PAYLOAD_BYTES
+} from "@ganglion/xacpx-relay-protocol";
+
+// packages/relay/src/gateway/desktop-ticket-store.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import {
+  DESKTOP_TICKET_TTL_MS,
+  MAX_DESKTOP_STREAM_ID_LENGTH,
+  MAX_DESKTOP_TICKET_LENGTH
+} from "@ganglion/xacpx-relay-protocol";
+function defaultMint() {
+  return randomBytes2(32).toString("base64url");
+}
+
+class DesktopTicketStore {
+  tickets = new Map;
+  now;
+  mint;
+  ttlMs;
+  constructor(options = {}) {
+    this.now = options.now ?? Date.now;
+    this.mint = options.mint ?? defaultMint;
+    this.ttlMs = options.ttlMs ?? DESKTOP_TICKET_TTL_MS;
+  }
+  mintTicket(input) {
+    if (!input.streamId || input.streamId.length > MAX_DESKTOP_STREAM_ID_LENGTH) {
+      throw new Error("desktop ticket requires a bounded streamId");
+    }
+    if (!input.accountId || !input.instanceId) {
+      throw new Error("desktop ticket requires accountId and instanceId");
+    }
+    const issued = this.mint();
+    const ticket = issued.length > MAX_DESKTOP_TICKET_LENGTH ? issued.slice(0, MAX_DESKTOP_TICKET_LENGTH) : issued;
+    if (!ticket)
+      throw new Error("desktop ticket mint produced an empty ticket");
+    const record = {
+      ticket,
+      streamId: input.streamId,
+      accountId: input.accountId,
+      instanceId: input.instanceId,
+      side: input.side,
+      expiresAt: this.now() + this.ttlMs
+    };
+    const existing = this.tickets.get(ticket);
+    if (existing && (existing.expiresAt > this.now() || existing.streamId !== record.streamId)) {
+      throw new Error("desktop ticket collision");
+    }
+    this.tickets.set(ticket, record);
+    return record;
+  }
+  consume(ticket, side, accountId) {
+    const record = this.tickets.get(ticket);
+    if (!record)
+      return null;
+    this.tickets.delete(ticket);
+    if (record.side !== side)
+      return null;
+    if (record.expiresAt <= this.now())
+      return null;
+    if (accountId !== undefined && record.accountId !== accountId)
+      return null;
+    return record;
+  }
+  revokeForStream(streamId) {
+    for (const [ticket, record] of [...this.tickets]) {
+      if (record.streamId === streamId)
+        this.tickets.delete(ticket);
+    }
+  }
+  sweepExpired() {
+    const now = this.now();
+    let removed = 0;
+    for (const [ticket, record] of [...this.tickets]) {
+      if (record.expiresAt <= now) {
+        this.tickets.delete(ticket);
+        removed += 1;
+      }
+    }
+    return removed;
+  }
+  size() {
+    return this.tickets.size;
+  }
+}
+
+// packages/relay/src/gateway/desktop-stream-registry.ts
+import {
+  DESKTOP_MAX_STREAMS_PER_ACCOUNT,
+  DESKTOP_MAX_STREAMS_PER_INSTANCE
+} from "@ganglion/xacpx-relay-protocol";
+
+class DesktopStreamRegistry {
+  records = new Map;
+  now;
+  maxPerInstance;
+  maxPerAccount;
+  createStreamId;
+  seq = 0;
+  constructor(options = {}) {
+    this.now = options.now ?? Date.now;
+    this.maxPerInstance = options.maxStreamsPerInstance ?? DESKTOP_MAX_STREAMS_PER_INSTANCE;
+    this.maxPerAccount = options.maxStreamsPerAccount ?? DESKTOP_MAX_STREAMS_PER_ACCOUNT;
+    this.createStreamId = options.createStreamId ?? (() => `ds-${Date.now().toString(36)}-${(this.seq += 1).toString(36)}`);
+  }
+  reserve(input) {
+    const now = this.now();
+    this.pruneClosed();
+    const liveForInstance = [...this.records.values()].filter((r) => r.instanceId === input.instanceId && r.accountId === input.accountId && r.state !== "closed");
+    if (liveForInstance.length >= this.maxPerInstance) {
+      return { ok: false, code: "desktop-busy", scope: "instance" };
+    }
+    const liveForAccount = [...this.records.values()].filter((r) => r.accountId === input.accountId && r.state !== "closed");
+    if (liveForAccount.length >= this.maxPerAccount) {
+      return { ok: false, code: "desktop-busy", scope: "account" };
+    }
+    const record = {
+      streamId: this.createStreamId(),
+      accountId: input.accountId,
+      instanceId: input.instanceId,
+      state: "preparing",
+      createdAt: now,
+      expiresAt: now + input.ttlMs
+    };
+    this.records.set(record.streamId, record);
+    return { ok: true, record };
+  }
+  get(streamId) {
+    return this.records.get(streamId);
+  }
+  setState(streamId, state) {
+    const record = this.records.get(streamId);
+    if (!record || record.state === "closed")
+      return;
+    record.state = state;
+    return record;
+  }
+  extendExpiry(streamId, expiresAt) {
+    const record = this.records.get(streamId);
+    if (!record || record.state === "closed")
+      return;
+    if (expiresAt > record.expiresAt)
+      record.expiresAt = expiresAt;
+    return record;
+  }
+  isLive(record, now = this.now()) {
+    return record !== undefined && record.state !== "closed" && record.expiresAt > now;
+  }
+  close(streamId) {
+    const record = this.records.get(streamId);
+    if (!record)
+      return;
+    record.state = "closed";
+    return record;
+  }
+  closeForInstance(instanceId) {
+    return [...this.records.values()].filter((r) => r.instanceId === instanceId && r.state !== "closed");
+  }
+  sweepExpired(now = this.now()) {
+    return [...this.records.values()].filter((r) => (r.state === "preparing" || r.state === "waiting-browser") && r.expiresAt <= now);
+  }
+  pruneClosed() {
+    for (const [id, record] of [...this.records]) {
+      if (record.state === "closed")
+        this.records.delete(id);
+    }
+  }
+}
+
+// packages/relay/src/gateway/desktop-stream-gateway.ts
+function wireCloseReason(reason) {
+  const bytes = Buffer.byteLength(reason, "utf8");
+  if (bytes <= 64)
+    return reason;
+  return "stream-closed";
+}
+function wireCloseCode(reason) {
+  return reason === "backpressure" ? 1013 : 1000;
+}
+var PRE_ATTACH_MAX_STREAMS = 64;
+var PRE_ATTACH_MAX_BYTES_PER_STREAM = 64 * 1024;
+
+class DesktopStreamGateway {
+  tickets;
+  streams;
+  paired = new Map;
+  preAttach = new Map;
+  logger;
+  maxPayloadBytes;
+  hardCloseBufferedBytes;
+  onStreamClosed;
+  constructor(options = {}) {
+    this.tickets = options.tickets ?? new DesktopTicketStore;
+    this.streams = options.streams ?? new DesktopStreamRegistry;
+    this.logger = options.logger ?? createNoopRelayLogger();
+    this.maxPayloadBytes = options.maxPayloadBytes ?? DESKTOP_WS_MAX_PAYLOAD_BYTES;
+    this.hardCloseBufferedBytes = options.hardCloseBufferedBytes ?? DESKTOP_BUFFERED_HARD_CLOSE_BYTES;
+    this.onStreamClosed = options.onStreamClosed;
+  }
+  get ticketStore() {
+    return this.tickets;
+  }
+  get streamRegistry() {
+    return this.streams;
+  }
+  reserve(input) {
+    this.sweepExpired();
+    return this.streams.reserve(input);
+  }
+  sweepExpired() {
+    const expired = this.streams.sweepExpired();
+    for (const record of expired) {
+      this.closeStream(record.streamId, "stream-expired");
+    }
+    if (expired.length > 0)
+      this.streams.pruneClosed();
+    this.tickets.sweepExpired();
+    return expired.length;
+  }
+  mintBrowserTicket(input) {
+    const ticket = this.tickets.mintTicket({ ...input, side: "browser" });
+    this.streams.extendExpiry(ticket.streamId, ticket.expiresAt);
+    return ticket;
+  }
+  attachBrowser(ticket, socket, authenticatedAccountId) {
+    const record = this.tickets.consume(ticket, "browser", authenticatedAccountId);
+    if (!record)
+      return this.reject(socket, "unknown-or-reused-ticket");
+    return this.pair(record, "browser", socket);
+  }
+  precheckConnectorTicket(ticket) {
+    const record = this.tickets.consume(ticket, "connector");
+    if (!record)
+      return { ok: false, reason: "unknown-or-reused-ticket" };
+    const registryRecord = this.streams.get(record.streamId);
+    if (!this.streams.isLive(registryRecord))
+      return { ok: false, reason: "stream-expired" };
+    if (registryRecord.accountId !== record.accountId || registryRecord.instanceId !== record.instanceId) {
+      return { ok: false, reason: "ticket-identity-mismatch" };
+    }
+    return { ok: true, claim: { streamId: record.streamId, accountId: record.accountId, instanceId: record.instanceId } };
+  }
+  attachConnector(ticketOrClaim, socket) {
+    if (typeof ticketOrClaim !== "string")
+      return this.pair(ticketOrClaim, "connector", socket);
+    const record = this.tickets.consume(ticketOrClaim, "connector");
+    if (!record)
+      return this.reject(socket, "unknown-or-reused-ticket");
+    return this.pair(record, "connector", socket);
+  }
+  streamState(streamId) {
+    const record = this.streams.get(streamId);
+    return record?.state;
+  }
+  goActive(streamId, security) {
+    const record = this.streams.get(streamId);
+    if (!record || record.state === "closed")
+      return;
+    this.streams.setState(streamId, "active");
+    if (!this.flushPreAttach(streamId))
+      return;
+    this.logger.info("relay.desktop.stream_active", "desktop stream active", { streamId, security });
+  }
+  reportConnectorReady(streamId, security) {
+    const record = this.streams.get(streamId);
+    if (!record || record.state === "closed")
+      return false;
+    if (security !== "vnc-auth")
+      return false;
+    const pair = this.paired.get(streamId) ?? {};
+    pair.security = security;
+    this.paired.set(streamId, pair);
+    if (pair.browser && pair.connector)
+      this.goActive(streamId, security);
+    else
+      this.streams.setState(streamId, "waiting-browser");
+    return true;
+  }
+  closeStream(streamId, reason = "closed") {
+    const pair = this.paired.get(streamId);
+    const record = this.streams.get(streamId);
+    const known = pair !== undefined || record !== undefined && record.state !== "closed";
+    this.paired.delete(streamId);
+    this.preAttach.delete(streamId);
+    this.streams.close(streamId);
+    this.tickets.revokeForStream(streamId);
+    if (!known)
+      return;
+    this.logger.info("relay.desktop.stream_closed", "desktop stream closed", { streamId, reason });
+    const wireReason = wireCloseReason(reason);
+    const wireCode = wireCloseCode(reason);
+    try {
+      pair?.browser?.close(wireCode, wireReason);
+    } catch {}
+    try {
+      pair?.connector?.close(wireCode, wireReason);
+    } catch {}
+    this.onStreamClosed?.(streamId);
+  }
+  closeForInstance(instanceId, reason = "instance-offline") {
+    for (const record of this.streams.closeForInstance(instanceId)) {
+      this.closeStream(record.streamId, reason);
+    }
+  }
+  pair(record, side, socket) {
+    const streamId = record.streamId;
+    const registryRecord = this.streams.get(streamId);
+    if (!this.streams.isLive(registryRecord))
+      return this.reject(socket, "stream-expired");
+    if (registryRecord.accountId !== record.accountId || registryRecord.instanceId !== record.instanceId) {
+      return this.reject(socket, "ticket-identity-mismatch");
+    }
+    const pair = this.paired.get(streamId) ?? {};
+    if (pair[side])
+      return this.reject(socket, "side-already-attached");
+    pair[side] = socket;
+    this.paired.set(streamId, pair);
+    socket.on("message", (data, isBinary) => this.onFrame(streamId, side, socket, data, isBinary));
+    socket.on("close", () => this.closeStream(streamId, `${side}-close`));
+    if (pair.browser && pair.connector && pair.security) {
+      this.goActive(streamId, pair.security);
+    }
+    return { ok: true, streamId };
+  }
+  onFrame(streamId, from, socket, data, isBinary) {
+    const record = this.streams.get(streamId);
+    const pair = this.paired.get(streamId);
+    if (!record || record.state === "closed" || !pair) {
+      return;
+    }
+    if (!isBinary || !(data instanceof Uint8Array)) {
+      this.logger.warn("relay.desktop.text_frame", "desktop text frame rejected", { streamId });
+      this.closeStream(streamId, "text-frame");
+      return;
+    }
+    if (data.byteLength === 0 || data.byteLength > this.maxPayloadBytes) {
+      this.logger.warn("relay.desktop.oversize_frame", "desktop oversize frame rejected", {
+        streamId,
+        bytes: data.byteLength
+      });
+      this.closeStream(streamId, "oversize-frame");
+      return;
+    }
+    const peer = from === "browser" ? pair.connector : pair.browser;
+    if (!peer) {
+      this.bufferPreAttach(streamId, data);
+      return;
+    }
+    if (peer.bufferedAmount > this.hardCloseBufferedBytes || socket.bufferedAmount > this.hardCloseBufferedBytes) {
+      this.logger.warn("relay.desktop.backpressure_close", "slow desktop peer evicted", { streamId });
+      this.closeStream(streamId, "backpressure");
+      return;
+    }
+    try {
+      peer.send(data);
+    } catch {
+      this.closeStream(streamId, "send-failed");
+    }
+  }
+  reject(socket, reason) {
+    try {
+      socket.close(4403, reason);
+    } catch {}
+    return { ok: false, reason };
+  }
+  bufferPreAttach(streamId, data) {
+    const existing = this.preAttach.get(streamId);
+    const bytes = (existing?.bytes ?? 0) + data.byteLength;
+    if (bytes > PRE_ATTACH_MAX_BYTES_PER_STREAM) {
+      this.logger.warn("relay.desktop.preattach_overflow", "pre-attach desktop buffer overflow", { streamId });
+      this.closeStream(streamId, "preattach-overflow");
+      return;
+    }
+    if (!existing && this.preAttach.size >= PRE_ATTACH_MAX_STREAMS) {
+      this.logger.warn("relay.desktop.preattach_overflow", "too many pre-attach desktop streams", { streamId });
+      this.closeStream(streamId, "preattach-overflow");
+      return;
+    }
+    const entry = existing ?? { chunks: [], bytes: 0 };
+    entry.chunks.push(data);
+    entry.bytes = bytes;
+    this.preAttach.set(streamId, entry);
+  }
+  flushPreAttach(streamId) {
+    const entry = this.preAttach.get(streamId);
+    if (!entry)
+      return true;
+    this.preAttach.delete(streamId);
+    const pair = this.paired.get(streamId);
+    const peer = pair?.browser;
+    if (!peer || pair?.connector === undefined)
+      return true;
+    for (const chunk of entry.chunks) {
+      try {
+        peer.send(chunk);
+      } catch {
+        this.closeStream(streamId, "send-failed");
+        return false;
+      }
+    }
+    return true;
+  }
+}
+
+// packages/relay/src/gateway/desktop-viewer-cancel.ts
+import { MSG as MSG2 } from "@ganglion/xacpx-relay-protocol";
+function sendDesktopCancel(gateway, instanceId, streamId) {
+  try {
+    gateway?.sendEvent(instanceId, MSG2.desktopCancel, { streamId });
+  } catch {}
+}
+function cancelViewerDesktopStreamByRequest(gateway, desktop, owners, requestId, viewerId, reason = "viewer-disconnected") {
+  for (const [streamId, owner] of [...owners]) {
+    if (owner.requestId !== requestId || owner.viewerId !== viewerId)
+      continue;
+    const state = desktop.streamState(streamId);
+    if (state !== "preparing" && state !== "waiting-browser")
+      continue;
+    sendDesktopCancel(gateway, owner.instanceId, streamId);
+    owners.delete(streamId);
+    desktop.closeStream(streamId, reason);
+    return true;
+  }
+  return false;
+}
+function cancelViewerDesktopStreams(gateway, desktop, owners, viewerId) {
+  for (const [streamId, owner] of [...owners]) {
+    if (owner.viewerId !== viewerId)
+      continue;
+    sendDesktopCancel(gateway, owner.instanceId, streamId);
+    owners.delete(streamId);
+    desktop.closeStream(streamId, "viewer-disconnected");
+  }
+}
+
 // packages/relay/src/push.ts
 var import_web_push = __toESM(require_src2(), 1);
 import { createECDH } from "node:crypto";
@@ -9190,7 +9845,9 @@ class PushSubscriptionStore {
 import {
   decodeEnvelope as decodeEnvelope2,
   isErrorPayload,
-  MSG as MSG2,
+  DESKTOP_HUB_REQUEST_TIMEOUT_MS,
+  MAX_DESKTOP_ERROR_MESSAGE_LENGTH,
+  MSG as MSG3,
   parseTerminalEventPayload,
   parseWebClientMessage
 } from "@ganglion/xacpx-relay-protocol";
@@ -9203,6 +9860,15 @@ function fail(deps, socket, requestId, instanceId, code, message) {
     message
   });
 }
+function failDesktop(deps, socket, requestId, instanceId, code, message) {
+  deps.webGateway.send(socket, {
+    kind: "desktop-request-failed",
+    requestId,
+    instanceId,
+    code,
+    message
+  });
+}
 function mapConnectorError(err) {
   if (err instanceof Error) {
     if (err.message === "instance-offline") {
@@ -9218,16 +9884,24 @@ function mapConnectorError(err) {
   }
   return { code: "terminal-protocol-error", message: String(err) };
 }
-async function sendConnectorRequest(deps, instanceId, type, payload) {
+function mapDesktopConnectorError(err) {
+  if (err instanceof Error) {
+    if (err.message === "instance-offline" || err.message === "instance-reconnected") {
+      return { code: "desktop-instance-offline", message: "instance is offline" };
+    }
+    if (err.message === "timeout") {
+      return { code: "desktop-stream-timeout", message: "desktop prepare timed out" };
+    }
+    return { code: "desktop-protocol-error", message: err.message.slice(0, 160) };
+  }
+  return { code: "desktop-protocol-error", message: String(err).slice(0, 160) };
+}
+async function sendConnectorRequest(deps, instanceId, type, payload, timeoutMs = TERMINAL_REQUEST_TIMEOUT_MS) {
   try {
-    return await deps.gateway.sendRequest(instanceId, type, payload, {
-      timeoutMs: TERMINAL_REQUEST_TIMEOUT_MS
-    });
+    return await deps.gateway.sendRequest(instanceId, type, payload, { timeoutMs });
   } catch (err) {
     if (err instanceof Error && err.message === "instance-reconnected" && deps.gateway.isOnline(instanceId)) {
-      return await deps.gateway.sendRequest(instanceId, type, payload, {
-        timeoutMs: TERMINAL_REQUEST_TIMEOUT_MS
-      });
+      return await deps.gateway.sendRequest(instanceId, type, payload, { timeoutMs });
     }
     throw err;
   }
@@ -9263,6 +9937,35 @@ async function handleWebClientMessageAsync(deps, accountId, socket, raw) {
         instanceId,
         ...deps.stateSnapshot(instanceId)
       });
+      const open = (deps.interactions?.listForInstance(instanceId) ?? []).filter((entry) => entry.expiresAt > Date.now());
+      const frames = open.map((entry) => ({
+        chatKey: entry.chatKey,
+        sessionAlias: entry.sessionAlias,
+        instanceId,
+        interaction: {
+          requestId: entry.requestId,
+          kind: entry.kind,
+          ...entry.conversation !== undefined ? { conversation: entry.conversation } : {},
+          expiresAt: entry.expiresAt,
+          ...entry.kind === "elicitation" ? { elicitation: entry.elicitation } : { permission: entry.permission }
+        }
+      }));
+      for (const frame of frames) {
+        deps.webGateway.send(socket, {
+          kind: "control-event",
+          instanceId,
+          event: { type: "interaction-opened", ...frame }
+        });
+      }
+      deps.webGateway.send(socket, {
+        kind: "interaction-snapshot",
+        instanceId,
+        interactions: frames.map((frame) => ({
+          chatKey: frame.chatKey,
+          sessionAlias: frame.sessionAlias,
+          interaction: frame.interaction
+        }))
+      });
     }
     return;
   }
@@ -9276,12 +9979,20 @@ async function handleWebClientMessageAsync(deps, accountId, socket, raw) {
     const viewerId = deps.webGateway.getViewerId(socket);
     if (!viewerId || !deps.webGateway.socketOwnsAttachment(socket, msg.attachmentId))
       return;
-    deps.gateway.sendEvent(msg.instanceId, MSG2.terminalStreamStart, {
+    deps.gateway.sendEvent(msg.instanceId, MSG3.terminalStreamStart, {
       attachmentId: msg.attachmentId,
       viewerId
     });
     return;
   }
+  if (msg.kind === "desktop-open") {
+    await handleDesktopOpen(deps, accountId, socket, msg);
+    return;
+  }
+  if (msg.kind === "desktop-close") {
+    handleDesktopClose(deps, accountId, socket, msg);
+    return;
+  }
   if (msg.kind === "terminal-take-control") {
     await handleTakeControl(deps, socket, msg);
     return;
@@ -9298,7 +10009,7 @@ async function handleWebClientMessageAsync(deps, accountId, socket, raw) {
     const viewerId = deps.webGateway.getViewerId(socket);
     if (!viewerId || !deps.webGateway.socketOwnsAttachment(socket, msg.attachmentId))
       return;
-    deps.gateway.sendEvent(msg.instanceId, MSG2.terminalInput, {
+    deps.gateway.sendEvent(msg.instanceId, MSG3.terminalInput, {
       attachmentId: msg.attachmentId,
       generation: msg.generation,
       viewerId,
@@ -9310,7 +10021,7 @@ async function handleWebClientMessageAsync(deps, accountId, socket, raw) {
     const viewerId = deps.webGateway.getViewerId(socket);
     if (!viewerId || !deps.webGateway.socketOwnsAttachment(socket, msg.attachmentId))
       return;
-    deps.gateway.sendEvent(msg.instanceId, MSG2.terminalResize, {
+    deps.gateway.sendEvent(msg.instanceId, MSG3.terminalResize, {
       attachmentId: msg.attachmentId,
       generation: msg.generation,
       viewerId,
@@ -9323,7 +10034,7 @@ async function handleWebClientMessageAsync(deps, accountId, socket, raw) {
     const viewerId = deps.webGateway.getViewerId(socket);
     if (!viewerId || !deps.webGateway.socketOwnsAttachment(socket, msg.attachmentId))
       return;
-    deps.gateway.sendEvent(msg.instanceId, MSG2.terminalHeartbeat, {
+    deps.gateway.sendEvent(msg.instanceId, MSG3.terminalHeartbeat, {
       attachmentId: msg.attachmentId,
       viewerId
     });
@@ -9334,7 +10045,7 @@ async function handleWebClientMessageAsync(deps, accountId, socket, raw) {
       return;
     const binding = deps.webGateway.unbindAttachment(msg.attachmentId);
     if (binding) {
-      deps.gateway.sendEvent(msg.instanceId, MSG2.terminalDetach, {
+      deps.gateway.sendEvent(msg.instanceId, MSG3.terminalDetach, {
         attachmentId: msg.attachmentId,
         viewerId: binding.viewerId
       });
@@ -9342,18 +10053,18 @@ async function handleWebClientMessageAsync(deps, accountId, socket, raw) {
     return;
   }
   if (msg.kind === "terminal-input" && "terminalId" in msg) {
-    deps.gateway.sendEvent(msg.instanceId, MSG2.terminalInput, {
+    deps.gateway.sendEvent(msg.instanceId, MSG3.terminalInput, {
       terminalId: msg.terminalId,
       data: msg.data
     });
   } else if (msg.kind === "terminal-resize" && "terminalId" in msg) {
-    deps.gateway.sendEvent(msg.instanceId, MSG2.terminalResize, {
+    deps.gateway.sendEvent(msg.instanceId, MSG3.terminalResize, {
       terminalId: msg.terminalId,
       cols: msg.cols,
       rows: msg.rows
     });
   } else if (msg.kind === "terminal-close") {
-    deps.gateway.sendEvent(msg.instanceId, MSG2.terminalClose, { terminalId: msg.terminalId });
+    deps.gateway.sendEvent(msg.instanceId, MSG3.terminalClose, { terminalId: msg.terminalId });
   }
 }
 async function handleTerminalOpen(deps, accountId, socket, msg) {
@@ -9368,7 +10079,7 @@ async function handleTerminalOpen(deps, accountId, socket, msg) {
   }
   let payload;
   try {
-    payload = await sendConnectorRequest(deps, msg.instanceId, MSG2.terminalOpen, {
+    payload = await sendConnectorRequest(deps, msg.instanceId, MSG3.terminalOpen, {
       chatKey: `relay:${accountId}`,
       sessionAlias: msg.sessionAlias,
       viewerId,
@@ -9421,8 +10132,113 @@ async function handleTerminalOpen(deps, accountId, socket, msg) {
     detachConnectorAttachment(deps, msg.instanceId, result.attachmentId, viewerId);
   }
 }
+async function handleDesktopOpen(deps, accountId, socket, msg) {
+  if (!deps.desktop) {
+    failDesktop(deps, socket, msg.requestId, msg.instanceId, "desktop-protocol-error", "desktop is not enabled on this hub");
+    return;
+  }
+  const ownerViewerId = deps.webGateway.getViewerId(socket);
+  if (!ownerViewerId) {
+    failDesktop(deps, socket, msg.requestId, msg.instanceId, "desktop-protocol-error", "missing viewer identity");
+    return;
+  }
+  const owned = deps.instances.getOwned(msg.instanceId, accountId);
+  if (!owned)
+    return;
+  if (!deps.gateway.isOnline(msg.instanceId)) {
+    failDesktop(deps, socket, msg.requestId, msg.instanceId, "desktop-instance-offline", "instance is offline");
+    return;
+  }
+  if (!owned.capabilities?.includes("desktop.rfb.v1")) {
+    failDesktop(deps, socket, msg.requestId, msg.instanceId, "desktop-disabled", "desktop is not enabled on this instance");
+    return;
+  }
+  const reserved = deps.desktop.reserve(accountId, msg.instanceId);
+  if (!reserved.ok) {
+    failDesktop(deps, socket, msg.requestId, msg.instanceId, reserved.code, reserved.scope === "account" ? "too many active desktop viewers on this account" : "another desktop viewer is active");
+    return;
+  }
+  const streamId = reserved.streamId;
+  deps.desktop.trackOwner(streamId, { viewerId: ownerViewerId, accountId, instanceId: msg.instanceId, requestId: msg.requestId });
+  const cancelStream = (reason) => {
+    sendDesktopCancel(deps.gateway, msg.instanceId, streamId);
+    deps.desktop?.cancel(streamId, reason);
+  };
+  const failWith = (code, message) => {
+    cancelStream(code);
+    failDesktop(deps, socket, msg.requestId, msg.instanceId, code, message);
+  };
+  const connectorTicket = deps.desktop.mintConnectorTicket(streamId, accountId, msg.instanceId);
+  let payload;
+  try {
+    payload = await deps.gateway.sendRequest(msg.instanceId, MSG3.desktopPrepare, {
+      streamId,
+      ticket: connectorTicket.ticket,
+      expiresAt: connectorTicket.expiresAt
+    }, { timeoutMs: DESKTOP_HUB_REQUEST_TIMEOUT_MS });
+  } catch (err) {
+    const mapped = mapDesktopConnectorError(err);
+    failWith(mapped.code, mapped.message);
+    return;
+  }
+  if (isErrorPayload(payload)) {
+    const code = payload.error.code.length > 0 ? payload.error.code.slice(0, 128) : "desktop-protocol-error";
+    failWith(code, payload.error.message.slice(0, MAX_DESKTOP_ERROR_MESSAGE_LENGTH));
+    return;
+  }
+  const result = payload;
+  if (!result || result.streamId !== streamId || result.security !== "vnc-auth" && result.security !== "ard") {
+    failWith("desktop-protocol-error", "malformed prepare result");
+    return;
+  }
+  if (result.security !== "vnc-auth") {
+    failWith("desktop-auth-unsupported", "Apple Remote Desktop auth needs Phase B");
+    return;
+  }
+  if (deps.webGateway.getViewerId(socket) !== ownerViewerId || !deps.desktop.ownsStream(streamId, ownerViewerId)) {
+    failWith("desktop-stream-timeout", "requesting viewer disconnected");
+    return;
+  }
+  if (!deps.desktop.markReady(streamId, result.security)) {
+    failWith("desktop-stream-timeout", "desktop stream expired");
+    return;
+  }
+  const browserTicket = deps.desktop.mintBrowserTicket(streamId, accountId, msg.instanceId);
+  const sent = deps.webGateway.send(socket, {
+    kind: "desktop-opened",
+    requestId: msg.requestId,
+    instanceId: msg.instanceId,
+    streamId,
+    wsPath: `/desktop/observe?ticket=${browserTicket.ticket}`,
+    expiresAt: browserTicket.expiresAt,
+    security: result.security
+  });
+  if (!sent) {
+    failWith("desktop-stream-timeout", "requesting viewer disconnected");
+    return;
+  }
+}
+function handleDesktopClose(deps, accountId, socket, msg) {
+  if (!deps.desktop)
+    return;
+  const viewerId = deps.webGateway.getViewerId(socket) ?? "";
+  if (msg.streamId !== undefined) {
+    const owner = deps.desktop.streamOwner(msg.streamId);
+    if (!owner || owner.viewerId !== viewerId)
+      return;
+    if (owner.accountId !== accountId)
+      return;
+    sendDesktopCancel(deps.gateway, owner.instanceId, msg.streamId);
+    deps.desktop.cancel(msg.streamId, "browser-close");
+    return;
+  }
+  if (msg.requestId === undefined)
+    return;
+  if (!deps.desktop.cancelPendingByRequest(msg.requestId, viewerId, "browser-close"))
+    return;
+}
 function detachConnectorAttachment(deps, instanceId, attachmentId, viewerId) {
-  deps.gateway.sendEvent(instanceId, MSG2.terminalDetach, {
+  deps.gateway.sendEvent(instanceId, MSG3.terminalDetach, {
     attachmentId,
     viewerId
   });
@@ -9434,7 +10250,7 @@ async function handleTakeControl(deps, socket, msg) {
     return;
   }
   try {
-    const payload = await sendConnectorRequest(deps, msg.instanceId, MSG2.terminalTakeControl, { attachmentId: msg.attachmentId, generation: msg.generation, viewerId });
+    const payload = await sendConnectorRequest(deps, msg.instanceId, MSG3.terminalTakeControl, { attachmentId: msg.attachmentId, generation: msg.generation, viewerId });
     if (isErrorPayload(payload)) {
       fail(deps, socket, msg.requestId, msg.instanceId, payload.error.code, payload.error.message);
       return;
@@ -9462,7 +10278,7 @@ async function handleResync(deps, socket, msg) {
     return;
   }
   try {
-    const payload = await sendConnectorRequest(deps, msg.instanceId, MSG2.terminalResync, { attachmentId: msg.attachmentId, generation: msg.generation, viewerId });
+    const payload = await sendConnectorRequest(deps, msg.instanceId, MSG3.terminalResync, { attachmentId: msg.attachmentId, generation: msg.generation, viewerId });
     if (isErrorPayload(payload)) {
       fail(deps, socket, msg.requestId, msg.instanceId, payload.error.code, payload.error.message);
       return;
@@ -9481,7 +10297,7 @@ async function handleResync(deps, socket, msg) {
 }
 async function handleTerminate(deps, socket, msg) {
   try {
-    const payload = await sendConnectorRequest(deps, msg.instanceId, MSG2.terminalTerminate, { terminalId: msg.terminalId, generation: msg.generation });
+    const payload = await sendConnectorRequest(deps, msg.instanceId, MSG3.terminalTerminate, { terminalId: msg.terminalId, generation: msg.generation });
     if (isErrorPayload(payload)) {
       fail(deps, socket, msg.requestId, msg.instanceId, payload.error.code, payload.error.message);
       return;
@@ -9507,8 +10323,8 @@ async function handleTerminate(deps, socket, msg) {
   }
 }
 function handleConnectorTerminalEvent(webGateway, instanceId, envelopeType, payload) {
-  if (envelopeType === MSG2.terminalViewerEvent) {
-    const parsed = parseTerminalEventPayload(MSG2.terminalViewerEvent, payload);
+  if (envelopeType === MSG3.terminalViewerEvent) {
+    const parsed = parseTerminalEventPayload(MSG3.terminalViewerEvent, payload);
     if (!parsed)
       return true;
     const p = parsed;
@@ -9599,8 +10415,8 @@ function handleConnectorTerminalEvent(webGateway, instanceId, envelopeType, payl
       webGateway.sendToAttachment(p.viewerId, p.attachmentId, event);
     return true;
   }
-  if (envelopeType === MSG2.terminalResourceExit) {
-    const parsed = parseTerminalEventPayload(MSG2.terminalResourceExit, payload);
+  if (envelopeType === MSG3.terminalResourceExit) {
+    const parsed = parseTerminalEventPayload(MSG3.terminalResourceExit, payload);
     if (!parsed)
       return true;
     const p = parsed;
@@ -9626,7 +10442,7 @@ import { serveStatic } from "@hono/node-server/serve-static";
 import { createECDH as createECDH2, randomUUID as randomUUID4 } from "node:crypto";
 import {
   isErrorPayload as isErrorPayload2,
-  MSG as MSG3,
+  MSG as MSG4,
   parseControlPayload
 } from "@ganglion/xacpx-relay-protocol";
 
@@ -9698,12 +10514,18 @@ function compactDetail(detail, isSubagent) {
       return {
         type: "command",
         command: detail.command,
-        ...detail.exitCode !== undefined ? { exitCode: detail.exitCode } : {}
+        ...detail.exitCode !== undefined ? { exitCode: detail.exitCode } : {},
+        ...detail.truncated !== undefined ? { truncated: detail.truncated } : {}
       };
     case "read":
       return { type: "read", path: detail.path, ...detail.lines ? { lines: detail.lines } : {} };
     case "search":
-      return { type: "search", query: detail.query };
+      return {
+        type: "search",
+        query: detail.query,
+        ...detail.count !== undefined ? { count: detail.count } : {},
+        ...detail.truncated !== undefined ? { truncated: detail.truncated } : {}
+      };
     case "text":
       return { type: "text", text: clip(detail.text, COMPACT_DETAIL_PREVIEW) };
     case "fields":
@@ -9878,25 +10700,25 @@ var LOGIN_FAILURES_SWEEP_AT = 1024;
 var LOGIN_FAILURES_MAX = 4096;
 var GLOBAL_MAX_FAILURES = 200;
 var CHAT_SCOPED_TYPES = new Set([
-  MSG3.prompt,
-  MSG3.promptCancel,
-  MSG3.commandExecute,
-  MSG3.queueCancel,
-  MSG3.scheduledList,
-  MSG3.scheduledCreate,
-  MSG3.scheduledCancel,
-  MSG3.sessionsList,
-  MSG3.sessionsCreate,
-  MSG3.sessionsNativeList,
-  MSG3.sessionsRemove,
-  MSG3.sessionsArchive,
-  MSG3.sessionsUnarchive,
-  MSG3.sessionsRename,
-  MSG3.sessionModelGet,
-  MSG3.sessionModelSet,
-  MSG3.sessionEffortGet,
-  MSG3.sessionEffortSet,
-  MSG3.terminalCreate
+  MSG4.prompt,
+  MSG4.promptCancel,
+  MSG4.commandExecute,
+  MSG4.queueCancel,
+  MSG4.scheduledList,
+  MSG4.scheduledCreate,
+  MSG4.scheduledCancel,
+  MSG4.sessionsList,
+  MSG4.sessionsCreate,
+  MSG4.sessionsNativeList,
+  MSG4.sessionsRemove,
+  MSG4.sessionsArchive,
+  MSG4.sessionsUnarchive,
+  MSG4.sessionsRename,
+  MSG4.sessionModelGet,
+  MSG4.sessionModelSet,
+  MSG4.sessionEffortGet,
+  MSG4.sessionEffortSet,
+  MSG4.terminalCreate
 ]);
 function requireJson(contentType) {
   return (contentType ?? "").toLowerCase().includes("application/json");
@@ -9908,6 +10730,12 @@ function safePreviewUrl(v) {
   return;
 }
 var RPC_MAX_BODY_BYTES = 16 * 1024 * 1024;
+function validateInteractionResponsePayload(payload) {
+  const parsed = parseControlPayload(MSG4.interactionRespond, payload);
+  if (!parsed)
+    return null;
+  return parsed;
+}
 var MAX_PERSISTED_ATTACHMENTS = 5;
 var MAX_ATTACHMENT_FIELD_LEN = 256;
 function boundField(v) {
@@ -9915,16 +10743,16 @@ function boundField(v) {
 }
 function rpcSessionLocks(type, payload) {
   const value = payload;
-  if (type === MSG3.prompt) {
+  if (type === MSG4.prompt) {
     return typeof value.sessionAlias === "string" && value.sessionAlias ? { alias: value.sessionAlias, lifecycle: false, turn: "shared" } : undefined;
   }
-  if (type === MSG3.commandExecute) {
+  if (type === MSG4.commandExecute) {
     return typeof value.sessionAlias === "string" && value.sessionAlias ? { alias: value.sessionAlias, lifecycle: false, turn: "exclusive" } : undefined;
   }
-  if (type === MSG3.sessionsRename) {
+  if (type === MSG4.sessionsRename) {
     return typeof value.alias === "string" && value.alias ? { alias: value.alias, lifecycle: true, turn: "none" } : undefined;
   }
-  if (type === MSG3.sessionsCreate || type === MSG3.sessionsRemove || type === MSG3.sessionsArchive || type === MSG3.sessionsUnarchive) {
+  if (type === MSG4.sessionsCreate || type === MSG4.sessionsRemove || type === MSG4.sessionsArchive || type === MSG4.sessionsUnarchive) {
     return typeof value.alias === "string" && value.alias ? { alias: value.alias, lifecycle: true, turn: "exclusive" } : undefined;
   }
   return;
@@ -10016,6 +10844,20 @@ function createApp(deps) {
   const now = deps.now ?? (() => new Date);
   const acquireSessionLifecycleRpcLock = createKeyedRpcLock();
   const sessionTurnRpcLock = createKeyedRwLock();
+  deps.interactions?.onClose((closed) => {
+    const owner = deps.instances.getOwned(closed.instanceId, closed.accountId);
+    if (owner === null)
+      return;
+    deps.gateway.broadcastControlEvent?.(closed.accountId, {
+      type: "interaction-closed",
+      chatKey: `relay:${closed.accountId}`,
+      sessionAlias: "",
+      instanceId: owner.id,
+      requestId: closed.requestId,
+      reason: closed.reason,
+      ...closed.action !== undefined && (closed.action === "accept" || closed.action === "decline" || closed.action === "cancel") ? { action: closed.action } : {}
+    });
+  });
   const loginFailures = new Map;
   let globalFailures = { count: 0, windowStart: 0 };
   function sweepPerIpLoginFailures(nowMs) {
@@ -10286,27 +11128,61 @@ function createApp(deps) {
         ...payload,
         chatKey: `relay:${account.id}`,
         senderId: account.id,
-        isOwner: true
+        isOwner: true,
+        chatType: "direct"
       };
     }
+    if (body.type === MSG4.conversationPrompt || body.type === MSG4.conversationPromptWithPolicy) {
+      payload = {
+        ...payload,
+        humanIngress: {
+          chatKey: `relay:${account.id}`,
+          senderId: account.id,
+          accountId: account.id,
+          senderName: account.username,
+          isOwner: true,
+          chatType: "direct"
+        }
+      };
+    }
+    if (body.type === MSG4.interactionRespond) {
+      const answer = validateInteractionResponsePayload(payload);
+      if (!answer)
+        return c.json({ error: "invalid-payload" }, 400);
+      const registry = deps.interactions;
+      if (!registry)
+        return c.json({ error: "interaction-unavailable" }, 503);
+      const pending = registry.get(answer.requestId);
+      if (!pending || pending.accountId !== account.id || pending.kind !== answer.kind) {
+        return c.json({ error: "interaction-gone" }, 409);
+      }
+      const closed = registry.answer(answer.requestId, answer);
+      if (!closed) {
+        return c.json({ error: "interaction-gone" }, 409);
+      }
+      return c.json({ ok: true });
+    }
+    if (body.type === MSG4.interactionRequest || body.type === MSG4.interactionWithdraw) {
+      return c.json({ error: "connector-only" }, 403);
+    }
     const releaseSessionRpcLocks = [];
     let persistedPromptId;
     let webPromptRequestId;
     try {
-      if (body.type === MSG3.prompt && !parseControlPayload(MSG3.prompt, payload)) {
+      if (body.type === MSG4.prompt && !parseControlPayload(MSG4.prompt, payload)) {
         return c.json({ error: "invalid-payload" }, 400);
       }
-      if (body.type === MSG3.commandExecute && !parseControlPayload(MSG3.commandExecute, payload)) {
+      if (body.type === MSG4.commandExecute && !parseControlPayload(MSG4.commandExecute, payload)) {
         return c.json({ error: "invalid-payload" }, 400);
       }
-      if (body.type === MSG3.upload && !parseControlPayload(MSG3.upload, payload)) {
+      if (body.type === MSG4.upload && !parseControlPayload(MSG4.upload, payload)) {
         return c.json({ error: "invalid-payload" }, 400);
       }
-      const removeInput = body.type === MSG3.sessionsRemove ? parseControlPayload(MSG3.sessionsRemove, payload) : undefined;
-      if (body.type === MSG3.sessionsRemove && !removeInput) {
+      const removeInput = body.type === MSG4.sessionsRemove ? parseControlPayload(MSG4.sessionsRemove, payload) : undefined;
+      if (body.type === MSG4.sessionsRemove && !removeInput) {
         return c.json({ error: "invalid-payload" }, 400);
       }
-      if (body.type === MSG3.upload) {
+      if (body.type === MSG4.upload) {
         const up = payload;
         const approxBytes = up.content ? Math.floor(up.content.length * 3 / 4) : 0;
         if (approxBytes > 10 * 1024 * 1024)
@@ -10324,7 +11200,7 @@ function createApp(deps) {
           releaseSessionRpcLocks.push(await sessionTurnRpcLock.acquireExclusive(key));
         }
       }
-      if (body.type === MSG3.prompt || body.type === MSG3.commandExecute) {
+      if (body.type === MSG4.prompt || body.type === MSG4.commandExecute) {
         const p = payload;
         if (p.sessionAlias && p.text !== undefined) {
           const attachments = (p.media ?? []).slice(0, MAX_PERSISTED_ATTACHMENTS).map((m) => {
@@ -10339,11 +11215,11 @@ function createApp(deps) {
             };
           });
           const promptRequestId = randomUUID4();
-          if (body.type === MSG3.prompt) {
+          if (body.type === MSG4.prompt) {
             webPromptRequestId = promptRequestId;
           }
           persistedPromptId = deps.messages.append(instance.id, p.sessionAlias, "in", p.text, undefined, attachments, promptRequestId);
-          if (body.type === MSG3.prompt && typeof payload === "object" && payload !== null) {
+          if (body.type === MSG4.prompt && typeof payload === "object" && payload !== null) {
             payload.promptRequestId = promptRequestId;
             deps.onWebPromptCreated?.({
               promptRequestId,
@@ -10354,11 +11230,11 @@ function createApp(deps) {
         }
       }
       const result = await deps.gateway.sendRequest(instance.id, body.type, payload);
-      const isPromptRejection = body.type === MSG3.prompt && typeof result === "object" && result !== null && "ok" in result && result.ok === false;
+      const isPromptRejection = body.type === MSG4.prompt && typeof result === "object" && result !== null && "ok" in result && result.ok === false;
       if (webPromptRequestId && (isErrorPayload2(result) || isPromptRejection)) {
         deps.onWebPromptRejected?.(webPromptRequestId);
       }
-      if (body.type === MSG3.prompt && persistedPromptId !== undefined && typeof result === "object" && result !== null && result.queued === true && typeof result.queueItemId === "string") {
+      if (body.type === MSG4.prompt && persistedPromptId !== undefined && typeof result === "object" && result !== null && result.queued === true && typeof result.queueItemId === "string") {
         const p = payload;
         const queueItemId = result.queueItemId;
         deps.messages.markQueued(persistedPromptId, {
@@ -10374,7 +11250,7 @@ function createApp(deps) {
           });
         }
       }
-      if (body.type === MSG3.queueCancel && !isErrorPayload2(result)) {
+      if (body.type === MSG4.queueCancel && !isErrorPayload2(result)) {
         const p = payload;
         if (typeof p.itemId === "string") {
           const cancelResult = result;
@@ -10383,7 +11259,7 @@ function createApp(deps) {
           }
         }
       }
-      if ((body.type === MSG3.sessionsRemove || body.type === MSG3.sessionsArchive) && !isErrorPayload2(result)) {
+      if ((body.type === MSG4.sessionsRemove || body.type === MSG4.sessionsArchive) && !isErrorPayload2(result)) {
         const targetAlias = removeInput ? removeInput.alias : typeof payload === "object" && payload !== null && ("alias" in payload) && typeof payload.alias === "string" ? payload.alias : undefined;
         if (targetAlias) {
           deps.onWebPromptSessionCleared?.(instance.id, targetAlias);
@@ -10393,7 +11269,7 @@ function createApp(deps) {
         deps.messages.deleteBySession(instance.id, removeInput.alias);
         deps.turnSlotAnchors?.deleteBySession(instance.id, removeInput.alias);
       }
-      if (body.type === MSG3.commandExecute) {
+      if (body.type === MSG4.commandExecute) {
         const p = payload;
         const output = result?.output;
         if (p.sessionAlias && typeof output === "string")
@@ -10533,13 +11409,23 @@ async function createRelayRuntime(dbPath, options = {}) {
   const instances = new InstanceStore(db);
   const messages = new MessageStore(db);
   let gatewayRef = null;
+  const desktopStreamOwners = new Map;
+  const desktop = new DesktopStreamGateway({
+    logger,
+    onStreamClosed: (streamId) => {
+      desktopStreamOwners.delete(streamId);
+    }
+  });
   const webGateway = new WebGateway({
     logger,
     onAttachmentDetached: (info) => {
-      gatewayRef?.sendEvent(info.instanceId, MSG4.terminalDetach, {
+      gatewayRef?.sendEvent(info.instanceId, MSG5.terminalDetach, {
         attachmentId: info.attachmentId,
         viewerId: info.viewerId
       });
+    },
+    onViewerClosed: (viewerId) => {
+      cancelViewerDesktopStreams(gatewayRef, desktop, desktopStreamOwners, viewerId);
     }
   });
   const pushSubscriptions = new PushSubscriptionStore(db);
@@ -10667,7 +11553,9 @@ async function createRelayRuntime(dbPath, options = {}) {
         parts: a.parts,
         status: a.text ? "streaming" : "working",
         startedAt: a.startedAt,
-        ...typeof a.slotAfterId === "number" ? { slotAfterId: a.slotAfterId } : {}
+        ...typeof a.slotAfterId === "number" ? { slotAfterId: a.slotAfterId } : {},
+        ...a.conversation ? { conversation: a.conversation } : {},
+        ...a.truncated ? { truncated: true } : {}
       });
     }
     return out;
@@ -10702,17 +11590,30 @@ async function createRelayRuntime(dbPath, options = {}) {
       a.parts.push({ type: "tool", step });
   };
   const pendingCompletionRoutes = new PendingCompletionRouteStore(db);
+  const interactions = new InteractionRegistry({
+    debug: (event, message, fields) => logger.debug(event, message, fields)
+  });
+  const broadcastControlEvent = (accountId, event) => {
+    webGateway.broadcast(accountId, {
+      kind: "control-event",
+      instanceId: event.instanceId ?? "",
+      event
+    });
+  };
   const gateway = new InstanceGateway({
     instances,
     accounts,
     requestTimeoutMs: options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
     logger,
     pendingCompletionRoutes,
+    interactions,
+    broadcastControlEvent,
     onDirectoryChange: (accountId, endpoints) => {
       webGateway.broadcast(accountId, { kind: "agent-directory", endpoints });
     },
     onStatusChange: (instanceId, accountId, online) => {
       if (!online) {
+        desktop.closeForInstance(instanceId, "instance-offline");
         const prefix = `${instanceId}\x00`;
         for (const k of turnBuffers.keys())
           if (k.startsWith(prefix))
@@ -10822,7 +11723,7 @@ async function createRelayRuntime(dbPath, options = {}) {
         messages.append(instanceId, sessionAlias, "out", text, structured, undefined, undefined, undefined, slot.startedAt, slot.slotAfterId, slot.startedAfterSeq);
       };
       try {
-        if (envelope.type === MSG4.instanceEvent) {
+        if (envelope.type === MSG5.instanceEvent) {
           const raw = envelope.payload?.event;
           if (!validControlEvent(raw)) {
             logger.debug("relay.event.invalid", "dropped malformed instance event", {
@@ -10870,7 +11771,8 @@ async function createRelayRuntime(dbPath, options = {}) {
                 startedAt,
                 slotAfterId: slot.slotAfterId,
                 ...slot.startedAfterSeq !== undefined ? { startedAfterSeq: slot.startedAfterSeq } : {},
-                ...notification ? { notification } : {}
+                ...notification ? { notification } : {},
+                ...event.conversation ? { conversation: event.conversation } : {}
               });
               outbound = { ...event, slotAfterId: slot.slotAfterId, startedAt };
             } catch (err) {
@@ -10961,7 +11863,7 @@ async function createRelayRuntime(dbPath, options = {}) {
               if (promptRequestId) {
                 removePendingWebPrompt(promptRequestId);
               }
-              gateway.sendEvent(instanceId, MSG4.instanceRecoveryAck, { recoveryIds: [recoveryId] });
+              gateway.sendEvent(instanceId, MSG5.instanceRecoveryAck, { recoveryIds: [recoveryId] });
             } else {
               flush();
               if (promptRequestId) {
@@ -10991,9 +11893,13 @@ async function createRelayRuntime(dbPath, options = {}) {
               });
             }
           } else if (event.type === "turn-usage") {
-            sessionUsage.set(key(instanceId, event.sessionAlias), { used: event.used, size: event.size, ...event.cost ? { cost: event.cost } : {}, ...event.breakdown ? { breakdown: event.breakdown } : {} });
+            if (!event.conversation) {
+              sessionUsage.set(key(instanceId, event.sessionAlias), { used: event.used, size: event.size, ...event.cost ? { cost: event.cost } : {}, ...event.breakdown ? { breakdown: event.breakdown } : {} });
+            }
           } else if (event.type === "agent-commands") {
-            sessionCommands.set(key(instanceId, event.sessionAlias), event.commands);
+            if (!event.conversation) {
+              sessionCommands.set(key(instanceId, event.sessionAlias), event.commands);
+            }
           } else if (event.type === "session-history") {
             const existing = messages.listBySession(accountId, instanceId, event.sessionAlias, { limit: 1 });
             if (existing.messages.length === 0) {
@@ -11010,7 +11916,7 @@ async function createRelayRuntime(dbPath, options = {}) {
           } else if (event.type === "agent-message-completion") {
             messages.patchAgentMessageCompletionStatus(instanceId, event.sessionAlias, event.messageId, event.completionStatus);
           }
-        } else if (envelope.type === MSG4.instanceStateSync) {
+        } else if (envelope.type === MSG5.instanceStateSync) {
           if (!validInstanceStateSync(envelope.payload)) {
             logger.debug("relay.event.invalid", "dropped malformed instance state sync", { instanceId });
             return;
@@ -11117,7 +12023,7 @@ async function createRelayRuntime(dbPath, options = {}) {
               }
             }
             if (ackedRecoveryIds.length > 0) {
-              gateway.sendEvent(instanceId, MSG4.instanceRecoveryAck, { recoveryIds: ackedRecoveryIds });
+              gateway.sendEvent(instanceId, MSG5.instanceRecoveryAck, { recoveryIds: ackedRecoveryIds });
             }
             for (const turn of sync.turns) {
               reconcileInboundPrompt(turn.sessionAlias, { prompt: turn.prompt, queueItemId: turn.queueItemId, scheduled: turn.scheduled, promptRequestId: turn.promptRequestId }, false);
@@ -11170,13 +12076,27 @@ async function createRelayRuntime(dbPath, options = {}) {
                   };
                 })(),
                 ...turn.truncated ? { truncated: true } : {},
-                ...notification ? { notification } : {}
+                ...notification ? { notification } : {},
+                ...turn.conversation ? { conversation: turn.conversation } : {}
               });
             }
+            const productSessionAliases = new Set;
+            for (const turn of sync.turns) {
+              if (turn.conversation)
+                productSessionAliases.add(turn.sessionAlias);
+            }
+            for (const finished of sync.finishedOffline) {
+              if (finished.conversation)
+                productSessionAliases.add(finished.sessionAlias);
+            }
             for (const meter of sync.usage) {
+              if (productSessionAliases.has(meter.sessionAlias))
+                continue;
               sessionUsage.set(key(instanceId, meter.sessionAlias), { used: meter.used, size: meter.size, ...meter.cost ? { cost: meter.cost } : {}, ...meter.breakdown ? { breakdown: meter.breakdown } : {} });
             }
             for (const entry of sync.commands) {
+              if (productSessionAliases.has(entry.sessionAlias))
+                continue;
               sessionCommands.set(key(instanceId, entry.sessionAlias), entry.commands);
             }
             const keepAnchors = new Set;
@@ -11190,7 +12110,7 @@ async function createRelayRuntime(dbPath, options = {}) {
             gateway.disconnect(instanceId);
             throw err;
           }
-        } else if (envelope.type === MSG4.instanceNotice) {
+        } else if (envelope.type === MSG5.instanceNotice) {
           const notice = envelope.payload;
           webGateway.broadcast(accountId, { kind: "notice", instanceId, notice });
           if (notice.kind === "task-completion") {
@@ -11220,6 +12140,7 @@ async function createRelayRuntime(dbPath, options = {}) {
     checkUpdate: createRelayUpdateChecker({ current: readRelayVersion() }),
     vapidPublicKey: vapid ? () => vapid.publicKey : undefined,
     pushSubscriptions,
+    interactions,
     onWebPromptCreated: ({ promptRequestId, instanceId, sessionAlias }) => {
       recordPendingWebPrompt(promptRequestId, instanceId, sessionAlias);
     },
@@ -11239,6 +12160,8 @@ async function createRelayRuntime(dbPath, options = {}) {
   });
   const completionRouteSweepTimer = setInterval(() => gateway.sweepExpiredCompletionRoutes(), 60 * 60000);
   completionRouteSweepTimer.unref?.();
+  const desktopSweepTimer = setInterval(() => desktop.sweepExpired(), DESKTOP_TICKET_TTL_MS2);
+  desktopSweepTimer.unref?.();
   return {
     db,
     accounts,
@@ -11250,11 +12173,15 @@ async function createRelayRuntime(dbPath, options = {}) {
     pushNotifier,
     gateway,
     webGateway,
+    desktop,
+    desktopStreamOwners,
     stateSnapshot,
+    interactions,
     pendingWebPromptsCount: () => pendingWebPrompts.size,
     app,
     close: () => {
       clearInterval(completionRouteSweepTimer);
+      clearInterval(desktopSweepTimer);
       db.close();
     }
   };
@@ -11280,16 +12207,61 @@ async function startRelayServer(options) {
     }
   });
   const dedicated = options.wsPort !== undefined;
+  const webWss = new WebSocketServer({ noServer: true, maxPayload: WEB_CLIENT_MAX_PAYLOAD_BYTES });
+  const desktopBrowserWss = new WebSocketServer({ noServer: true, maxPayload: DESKTOP_WS_MAX_PAYLOAD_BYTES2 });
+  const desktopConnectorWss = new WebSocketServer({ noServer: true, maxPayload: DESKTOP_WS_MAX_PAYLOAD_BYTES2 });
   let wss;
   let gatewayWss;
+  let dedicatedControlWss;
+  let gatewayHttpServer;
   if (dedicated) {
-    wss = new WebSocketServer({ port: options.wsPort, host });
-    await new Promise((resolve) => wss.on("listening", () => resolve()));
-    wss.on("connection", (socket) => runtime.gateway.handleConnection(socket));
+    const dedicatedHttpServer = createServer((req, res) => {
+      res.writeHead(426, { "Content-Type": "text/plain" });
+      res.end("Upgrade Required");
+    });
+    gatewayHttpServer = dedicatedHttpServer;
+    wss = new WebSocketServer({ noServer: true, maxPayload: DESKTOP_WS_MAX_PAYLOAD_BYTES2 });
+    dedicatedControlWss = new WebSocketServer({ noServer: true });
+    dedicatedHttpServer.on("upgrade", (req, socket, head) => {
+      const path = (req.url ?? "").split("?")[0] ?? "";
+      if (path === "/desktop/instance") {
+        const ticket = desktopTicketFromUrl(req.url ?? "");
+        if (!ticket) {
+          try {
+            socket.destroy();
+          } catch {}
+          return;
+        }
+        const precheck = runtime.desktop.precheckConnectorTicket(ticket);
+        if (!precheck.ok) {
+          try {
+            socket.destroy();
+          } catch {}
+          return;
+        }
+        desktopConnectorWss.handleUpgrade(req, socket, head, (ws) => {
+          const attached = runtime.desktop.attachConnector(precheck.claim, adaptDesktopSocket(ws));
+          if (!attached.ok) {
+            try {
+              ws.close(4403, attached.reason);
+            } catch {}
+          }
+        });
+        return;
+      }
+      dedicatedControlWss.handleUpgrade(req, socket, head, (ws) => runtime.gateway.handleConnection(ws));
+    });
+    await new Promise((resolve, reject) => {
+      const onErr = (err) => reject(err instanceof Error ? err : new Error(String(err)));
+      dedicatedHttpServer.once("error", onErr);
+      dedicatedHttpServer.listen(options.wsPort, host, () => {
+        dedicatedHttpServer.removeListener("error", onErr);
+        resolve();
+      });
+    });
   } else {
     gatewayWss = new WebSocketServer({ noServer: true });
   }
-  const webWss = new WebSocketServer({ noServer: true, maxPayload: WEB_CLIENT_MAX_PAYLOAD_BYTES });
   httpServer.on("upgrade", (req, socket, head) => {
     const path = (req.url ?? "").split("?")[0] ?? "";
     if (path === "/ws") {
@@ -11305,19 +12277,88 @@ async function startRelayServer(options) {
           instances: runtime.instances,
           gateway: runtime.gateway,
           webGateway: runtime.webGateway,
-          stateSnapshot: runtime.stateSnapshot
+          stateSnapshot: runtime.stateSnapshot,
+          desktop: {
+            reserve: (reserveAccountId, instanceId) => {
+              const reserved = runtime.desktop.reserve({
+                accountId: reserveAccountId,
+                instanceId,
+                ttlMs: DESKTOP_TICKET_TTL_MS2
+              });
+              if (!reserved.ok)
+                return reserved;
+              return { ok: true, streamId: reserved.record.streamId };
+            },
+            mintConnectorTicket: (streamId, ticketAccountId, instanceId) => runtime.desktop.ticketStore.mintTicket({ streamId, accountId: ticketAccountId, instanceId, side: "connector" }),
+            mintBrowserTicket: (streamId, ticketAccountId, instanceId) => runtime.desktop.mintBrowserTicket({ streamId, accountId: ticketAccountId, instanceId }),
+            markReady: (streamId, security) => runtime.desktop.reportConnectorReady(streamId, security),
+            cancel: (streamId, reason) => {
+              runtime.desktopStreamOwners.delete(streamId);
+              runtime.desktop.closeStream(streamId, reason);
+            },
+            cancelPendingByRequest: (requestId, ownerViewerId, reason) => cancelViewerDesktopStreamByRequest(runtime.gateway, runtime.desktop, runtime.desktopStreamOwners, requestId, ownerViewerId, reason),
+            ownsStream: (streamId, ownerViewerId) => runtime.desktopStreamOwners.get(streamId)?.viewerId === ownerViewerId,
+            streamOwner: (streamId) => runtime.desktopStreamOwners.get(streamId),
+            trackOwner: (streamId, owner) => {
+              runtime.desktopStreamOwners.set(streamId, owner);
+            }
+          },
+          interactions: runtime.interactions
         }, account.id, ws, String(data)));
       });
       return;
     }
+    if (path === "/desktop/observe") {
+      const token = parseCookie(req.headers.cookie ?? "")["xrelay_session"];
+      const account = token ? runtime.accounts.getSessionAccount(token) : null;
+      if (!account) {
+        socket.destroy();
+        return;
+      }
+      const ticket = desktopTicketFromUrl(req.url ?? "");
+      if (!ticket) {
+        socket.destroy();
+        return;
+      }
+      desktopBrowserWss.handleUpgrade(req, socket, head, (ws) => {
+        const attached = runtime.desktop.attachBrowser(ticket, adaptDesktopSocket(ws), account.id);
+        if (!attached.ok) {
+          try {
+            ws.close(4403, attached.reason);
+          } catch {}
+        }
+      });
+      return;
+    }
     if (gatewayWss && (path === "/" || path === "/gateway" || path.startsWith("/gateway/"))) {
       gatewayWss.handleUpgrade(req, socket, head, (ws) => runtime.gateway.handleConnection(ws));
       return;
     }
+    if (!dedicated && path === "/desktop/instance") {
+      const ticket = desktopTicketFromUrl(req.url ?? "");
+      if (!ticket) {
+        socket.destroy();
+        return;
+      }
+      const precheck = runtime.desktop.precheckConnectorTicket(ticket);
+      if (!precheck.ok) {
+        socket.destroy();
+        return;
+      }
+      desktopConnectorWss.handleUpgrade(req, socket, head, (ws) => {
+        const attached = runtime.desktop.attachConnector(precheck.claim, adaptDesktopSocket(ws));
+        if (!attached.ok) {
+          try {
+            ws.close(4403, attached.reason);
+          } catch {}
+        }
+      });
+      return;
+    }
     socket.destroy();
   });
   const httpPort = httpServer.address().port;
-  const wsPort = wss ? wss.address().port : null;
+  const wsPort = dedicated && gatewayHttpServer ? gatewayHttpServer.address()?.port ?? null : null;
   return {
     runtime,
     httpPort,
@@ -11325,15 +12366,46 @@ async function startRelayServer(options) {
     close: async () => {
       stopMaintenance();
       await new Promise((resolve) => webWss.close(() => resolve()));
+      await new Promise((resolve) => desktopBrowserWss.close(() => resolve()));
+      await new Promise((resolve) => desktopConnectorWss.close(() => resolve()));
       if (gatewayWss)
         await new Promise((resolve) => gatewayWss.close(() => resolve()));
+      if (dedicatedControlWss)
+        await new Promise((resolve) => dedicatedControlWss.close(() => resolve()));
       if (wss)
         await new Promise((resolve) => wss.close(() => resolve()));
+      if (gatewayHttpServer) {
+        await new Promise((resolve) => gatewayHttpServer.close(() => resolve()));
+      }
       await new Promise((resolve) => httpServer.close(() => resolve()));
       runtime.close();
     }
   };
 }
+function desktopTicketFromUrl(url) {
+  const query = url.split("?")[1] ?? "";
+  for (const part of query.split("&")) {
+    const idx = part.indexOf("=");
+    if (idx === -1)
+      continue;
+    if (part.slice(0, idx) !== "ticket")
+      continue;
+    let ticket;
+    try {
+      ticket = decodeURIComponent(part.slice(idx + 1));
+    } catch {
+      return null;
+    }
+    if (ticket.length === 0 || ticket.length > MAX_DESKTOP_TICKET_LENGTH2)
+      return null;
+    return ticket;
+  }
+  return null;
+}
+function adaptDesktopSocket(ws) {
+  ws.on("error", () => {});
+  return ws;
+}
 function parseCookie(header) {
   const out = {};
   for (const part of header.split(";")) {