@agentproto/acp 0.1.0-alpha.2 → 0.2.0

package/dist/tunnel/index.mjs

@@ -18,6 +18,12 @@ var KNOWN_TYPES = /* @__PURE__ */ new Set([
   "resize",
   "http_request",
   "http_response",
+  "http_response_head",
+  "http_response_chunk",
+  "ws_open",
+  "ws_open_ack",
+  "ws_message",
+  "ws_close",
   "ping",
   "pong",
   "error",
@@ -25,7 +31,8 @@ var KNOWN_TYPES = /* @__PURE__ */ new Set([
   "spawned",
   "stdout",
   "stderr",
-  "exit"
+  "exit",
+  "reconnect_soon"
 ]);
 function parseFrame(raw) {
   let parsed;
@@ -51,13 +58,21 @@ function encodeData(bytes) {
 function decodeData(data) {
   return Buffer.from(data, "base64");
 }
+var DEFAULT_WS_DIAL_TIMEOUT_MS = 1e4;
+var DEFAULT_HTTP_FORWARD_TIMEOUT_MS = 3e4;
 function createTunnelServer(opts) {
   const children = /* @__PURE__ */ new Map();
+  const ptyProcs = /* @__PURE__ */ new Map();
+  const upstreamWs = /* @__PURE__ */ new Map();
   let closed = false;
   opts.sink.send({
     t: "hello",
     version: TUNNEL_VERSION,
-    capabilities: { pty: opts.pty === true },
+    capabilities: {
+      pty: opts.pty === true,
+      wsForward: opts.dialUpstreamWs !== void 0 && !!opts.httpUpstream,
+      ...opts.tools && opts.tools.length ? { tools: opts.tools } : {}
+    },
     label: opts.label,
     daemon: {
       name: "agentproto",
@@ -76,6 +91,15 @@ function createTunnelServer(opts) {
     closed = true;
     for (const [, child] of children) child.kill("SIGTERM");
     children.clear();
+    for (const [, pty] of ptyProcs) pty.kill();
+    ptyProcs.clear();
+    for (const [, ws] of upstreamWs) {
+      try {
+        ws.close(1001, "tunnel_closed");
+      } catch {
+      }
+    }
+    upstreamWs.clear();
     offFrame();
     offClose();
   });
@@ -85,6 +109,11 @@ function createTunnelServer(opts) {
         await handleSpawn(frame);
         return;
       case "stdin": {
+        const pty = ptyProcs.get(frame.execId);
+        if (pty) {
+          pty.write(Buffer.from(frame.data, "base64").toString("utf8"));
+          return;
+        }
         const child = children.get(frame.execId);
         if (!child || !child.stdin) {
           opts.sink.send({
@@ -99,6 +128,11 @@ function createTunnelServer(opts) {
         return;
       }
       case "kill": {
+        const pty = ptyProcs.get(frame.execId);
+        if (pty) {
+          pty.kill(frame.signal ?? "SIGTERM");
+          return;
+        }
         const child = children.get(frame.execId);
         if (!child) {
           opts.sink.send({
@@ -112,14 +146,60 @@ function createTunnelServer(opts) {
         child.kill(frame.signal ?? "SIGTERM");
         return;
       }
-      case "resize":
+      case "resize": {
+        ptyProcs.get(frame.execId)?.resize(frame.cols, frame.rows);
         return;
+      }
       case "http_request":
         await handleHttpRequest(frame);
         return;
+      case "ws_open":
+        await handleWsOpen(frame);
+        return;
+      case "ws_message": {
+        const ws = upstreamWs.get(frame.reqId);
+        if (!ws) {
+          return;
+        }
+        try {
+          ws.send(decodeData(frame.data), { binary: frame.binary === true });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          opts.sink.send({
+            t: "ws_close",
+            reqId: frame.reqId,
+            code: 1011,
+            reason: `send_failed: ${message}`
+          });
+          try {
+            ws.close(1011, "send_failed");
+          } catch {
+          }
+          upstreamWs.delete(frame.reqId);
+        }
+        return;
+      }
+      case "ws_close": {
+        const ws = upstreamWs.get(frame.reqId);
+        if (!ws) return;
+        upstreamWs.delete(frame.reqId);
+        try {
+          ws.close(frame.code, frame.reason);
+        } catch {
+        }
+        return;
+      }
       case "ping":
         opts.sink.send({ t: "pong", nonce: frame.nonce });
         return;
+      case "reconnect_soon":
+        try {
+          opts.onReconnectSoon?.({
+            ...frame.reasonMs !== void 0 ? { reasonMs: frame.reasonMs } : {}
+          });
+        } catch {
+        }
+        return;
       case "pong":
       case "error":
         return;
@@ -155,6 +235,48 @@ function createTunnelServer(opts) {
       });
       return;
     }
+    if (approved.pty && opts.spawnPty) {
+      let pty;
+      try {
+        pty = opts.spawnPty({
+          command: approved.command,
+          args: [...approved.args],
+          cwd: approved.cwd,
+          env: approved.env ? { ...approved.env } : void 0,
+          cols: approved.cols ?? 80,
+          rows: approved.rows ?? 24
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        opts.sink.send({ t: "error", execId: req.execId, code: "spawn_failed", message });
+        return;
+      }
+      ptyProcs.set(req.execId, pty);
+      opts.sink.send({ t: "spawned", execId: req.execId, pid: pty.pid });
+      pty.onData((data) => {
+        opts.sink.send({ t: "stdout", execId: req.execId, data: encodeData(data) });
+      });
+      pty.onExit(({ exitCode, signal }) => {
+        opts.sink.send({
+          t: "exit",
+          execId: req.execId,
+          code: exitCode,
+          signal: signal != null ? String(signal) : null
+        });
+        ptyProcs.delete(req.execId);
+      });
+      if (opts.onChildSpawned) {
+        try {
+          opts.onChildSpawned({
+            execId: req.execId,
+            child: { pid: pty.pid },
+            request: approved
+          });
+        } catch {
+        }
+      }
+      return;
+    }
     let child;
     try {
       child = spawn(approved.command, [...approved.args], {
@@ -223,6 +345,162 @@ function createTunnelServer(opts) {
       children.delete(req.execId);
     });
   }
+  async function handleWsOpen(req) {
+    if (closed) return;
+    const reject = (status, code, message) => {
+      opts.sink.send({
+        t: "ws_open_ack",
+        reqId: req.reqId,
+        status,
+        error: { code, message }
+      });
+    };
+    if (!opts.dialUpstreamWs || !opts.httpUpstream) {
+      reject(
+        502,
+        "ws_upstream_not_configured",
+        "Daemon does not support WS forwarding \u2014 start with `--upstream ws://\u2026` (or upgrade)."
+      );
+      return;
+    }
+    if (!req.path.startsWith("/") || req.path.startsWith("//") || req.path.includes("..")) {
+      reject(
+        400,
+        "invalid_path",
+        `Daemon WS forward requires a safe relative path; got '${req.path}'.`
+      );
+      return;
+    }
+    const HOP_BY_HOP = /* @__PURE__ */ new Set([
+      "connection",
+      "upgrade",
+      "sec-websocket-version",
+      "sec-websocket-key",
+      "sec-websocket-extensions",
+      "sec-websocket-protocol",
+      "host",
+      "content-length"
+    ]);
+    const headers = {};
+    for (const [k, v] of Object.entries(req.headers ?? {})) {
+      if (HOP_BY_HOP.has(k.toLowerCase())) continue;
+      headers[k] = v;
+    }
+    let httpBase = opts.httpUpstream;
+    if (req.upstream) {
+      const resolved = await opts.resolveWsUpstream?.(req.upstream);
+      if (!resolved) {
+        reject(
+          502,
+          "unknown_ws_upstream",
+          `No WS upstream registered for '${req.upstream}'.`
+        );
+        return;
+      }
+      httpBase = resolved;
+    }
+    const base = httpBase.replace(/^http(s?):\/\//, "ws$1://");
+    const url = `${base.replace(/\/$/, "")}${req.path}`;
+    const dialTimeoutMs = opts.wsDialTimeoutMs ?? DEFAULT_WS_DIAL_TIMEOUT_MS;
+    const dialAbort = new AbortController();
+    let dialTimedOut = false;
+    let dialTimer = null;
+    const dialPromise = opts.dialUpstreamWs({
+      url,
+      ...req.protocols && req.protocols.length > 0 ? { protocols: req.protocols } : {},
+      headers,
+      signal: dialAbort.signal
+    });
+    const timeoutPromise = new Promise((_resolve, rej) => {
+      dialTimer = setTimeout(() => {
+        dialTimedOut = true;
+        dialAbort.abort(new Error("ws_dial_timeout"));
+        rej(new Error(`upstream WS dial timed out after ${dialTimeoutMs}ms`));
+      }, dialTimeoutMs);
+      if (typeof dialTimer !== "number") dialTimer.unref();
+    });
+    let upstream;
+    try {
+      upstream = await Promise.race([dialPromise, timeoutPromise]);
+    } catch (err) {
+      if (dialTimer) clearTimeout(dialTimer);
+      if (dialTimedOut) {
+        dialPromise.then(
+          (sock) => {
+            try {
+              sock.close(1001, "dial_timeout");
+            } catch {
+            }
+          },
+          () => {
+          }
+        );
+        reject(
+          504,
+          "upstream_ws_timeout",
+          `Upstream did not complete the WS upgrade within ${dialTimeoutMs}ms.`
+        );
+        return;
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      const m = message.match(/Unexpected server response: (\d+)/);
+      const status = m ? Number.parseInt(m[1], 10) : 502;
+      reject(status, "upstream_ws_failed", message);
+      return;
+    }
+    if (dialTimer) clearTimeout(dialTimer);
+    if (closed) {
+      try {
+        upstream.close(1001, "tunnel_closed");
+      } catch {
+      }
+      return;
+    }
+    upstreamWs.set(req.reqId, upstream);
+    opts.sink.send({
+      t: "ws_open_ack",
+      reqId: req.reqId,
+      status: 101,
+      ...upstream.protocol ? { protocol: upstream.protocol } : {}
+    });
+    upstream.onMessage((data, isBinary) => {
+      if (!opts.sink.isOpen) return;
+      opts.sink.send({
+        t: "ws_message",
+        reqId: req.reqId,
+        data: encodeData(data),
+        binary: isBinary
+      });
+    });
+    upstream.onClose((code, reason) => {
+      if (!upstreamWs.has(req.reqId)) return;
+      upstreamWs.delete(req.reqId);
+      if (opts.sink.isOpen) {
+        opts.sink.send({
+          t: "ws_close",
+          reqId: req.reqId,
+          code,
+          ...reason ? { reason } : {}
+        });
+      }
+    });
+    upstream.onError((err) => {
+      if (!upstreamWs.has(req.reqId)) return;
+      upstreamWs.delete(req.reqId);
+      if (opts.sink.isOpen) {
+        opts.sink.send({
+          t: "ws_close",
+          reqId: req.reqId,
+          code: 1011,
+          reason: `upstream_error: ${err.message}`
+        });
+      }
+      try {
+        upstream.close(1011, "upstream_error");
+      } catch {
+      }
+    });
+  }
   async function handleHttpRequest(req) {
     if (closed) return;
     const respond = (partial) => {
@@ -273,8 +551,17 @@ function createTunnelServer(opts) {
     }
     const url = `${opts.httpUpstream.replace(/\/$/, "")}${req.path}`;
     const controller = new AbortController();
-    const timeoutMs = req.timeoutMs ?? 3e4;
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const timeoutMs = req.timeoutMs ?? opts.httpForwardTimeoutMs ?? DEFAULT_HTTP_FORWARD_TIMEOUT_MS;
+    let timer = setTimeout(
+      () => controller.abort(),
+      timeoutMs
+    );
+    const clearTimer = () => {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    };
     try {
       const upstreamRes = await fetch(url, {
         method: req.method,
@@ -284,12 +571,92 @@ function createTunnelServer(opts) {
         // node fetch follows redirects by default — fine for MCP, the
         // upstream gateway doesn't redirect anyway.
       });
-      const buf = Buffer.from(await upstreamRes.arrayBuffer());
       const outHeaders = {};
       upstreamRes.headers.forEach((value, key) => {
         if (HOP_BY_HOP.has(key.toLowerCase())) return;
         outHeaders[key] = value;
       });
+      const contentType = (outHeaders["content-type"] ?? "").toLowerCase();
+      const isStream = contentType.startsWith("text/event-stream") || contentType.includes("application/x-ndjson");
+      if (isStream && upstreamRes.body) {
+        clearTimer();
+        opts.sink.send({
+          t: "http_response_head",
+          reqId: req.reqId,
+          status: upstreamRes.status,
+          headers: outHeaders
+        });
+        const reader = upstreamRes.body.getReader();
+        const idleMs = opts.httpStreamIdleTimeoutMs;
+        const IDLE = /* @__PURE__ */ Symbol("idle");
+        const readChunk = async () => {
+          if (!idleMs) return reader.read();
+          let idleTimer = null;
+          const idle = new Promise((resolve) => {
+            idleTimer = setTimeout(() => resolve(IDLE), idleMs);
+            if (typeof idleTimer !== "number") idleTimer.unref();
+          });
+          try {
+            return await Promise.race([reader.read(), idle]);
+          } finally {
+            if (idleTimer) clearTimeout(idleTimer);
+          }
+        };
+        try {
+          while (true) {
+            const chunk = await readChunk();
+            if (chunk === IDLE) {
+              try {
+                await reader.cancel();
+              } catch {
+              }
+              opts.sink.send({
+                t: "http_response_chunk",
+                reqId: req.reqId,
+                end: true,
+                error: {
+                  code: "upstream_stream_idle_timeout",
+                  message: `No data from upstream for ${idleMs}ms.`
+                }
+              });
+              return;
+            }
+            const { value, done } = chunk;
+            if (done) {
+              opts.sink.send({
+                t: "http_response_chunk",
+                reqId: req.reqId,
+                end: true
+              });
+              return;
+            }
+            if (value && value.byteLength > 0) {
+              opts.sink.send({
+                t: "http_response_chunk",
+                reqId: req.reqId,
+                data: encodeData(Buffer.from(value))
+              });
+            }
+            if (!opts.sink.isOpen) {
+              try {
+                await reader.cancel();
+              } catch {
+              }
+              return;
+            }
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          opts.sink.send({
+            t: "http_response_chunk",
+            reqId: req.reqId,
+            end: true,
+            error: { code: "upstream_stream_failed", message }
+          });
+        }
+        return;
+      }
+      const buf = Buffer.from(await upstreamRes.arrayBuffer());
       respond({
         status: upstreamRes.status,
         headers: outHeaders,
@@ -306,7 +673,7 @@ function createTunnelServer(opts) {
         }
       });
     } finally {
-      clearTimeout(timer);
+      clearTimer();
     }
   }
   return {
@@ -327,6 +694,8 @@ function createTunnelClient(opts) {
   const childByExec = /* @__PURE__ */ new Map();
   const spawnPending = /* @__PURE__ */ new Map();
   const httpPending = /* @__PURE__ */ new Map();
+  const wsOpenPending = /* @__PURE__ */ new Map();
+  const wsByReq = /* @__PURE__ */ new Map();
   const offFrame = opts.sink.onFrame((frame) => routeIncoming(frame));
   const offClose = opts.sink.onClose(() => {
     for (const [, duck] of childByExec) duck.__handleSinkClosed();
@@ -337,9 +706,29 @@ function createTunnelClient(opts) {
     spawnPending.clear();
     for (const [, p] of httpPending) {
       clearTimeout(p.timer);
-      p.reject(new Error("Tunnel closed before HTTP response arrived."));
+      if (p.mode === "buffered") {
+        p.reject(new Error("Tunnel closed before HTTP response arrived."));
+      } else {
+        if (!p.headEmitted) {
+          p.reject(new Error("Tunnel closed before HTTP response head arrived."));
+        } else if (p.controller && !p.ended) {
+          try {
+            p.controller.error(new Error("Tunnel closed mid-stream."));
+          } catch {
+          }
+        }
+      }
     }
     httpPending.clear();
+    for (const [, p] of wsOpenPending) {
+      clearTimeout(p.timer);
+      p.reject(new Error("Tunnel closed before WS upgrade completed."));
+    }
+    wsOpenPending.clear();
+    for (const [, duck] of wsByReq) {
+      duck.__handleSinkClosed();
+    }
+    wsByReq.clear();
     offFrame();
     offClose();
   });
@@ -396,12 +785,171 @@ function createTunnelClient(opts) {
         if (!pending) return;
         httpPending.delete(frame.reqId);
         clearTimeout(pending.timer);
-        pending.resolve({
-          status: frame.status,
-          headers: frame.headers ?? {},
-          body: frame.body ? decodeData(frame.body) : Buffer.alloc(0),
-          ...frame.error ? { error: frame.error } : {}
-        });
+        const body = frame.body ? decodeData(frame.body) : Buffer.alloc(0);
+        if (pending.mode === "buffered") {
+          pending.resolve({
+            status: frame.status,
+            headers: frame.headers ?? {},
+            body,
+            ...frame.error ? { error: frame.error } : {}
+          });
+        } else {
+          const stream = new ReadableStream({
+            start(controller) {
+              if (body.length > 0) controller.enqueue(new Uint8Array(body));
+              controller.close();
+            }
+          });
+          pending.resolveHead({
+            status: frame.status,
+            headers: frame.headers ?? {},
+            body: stream
+          });
+        }
+        return;
+      }
+      case "http_response_head": {
+        const pending = httpPending.get(frame.reqId);
+        if (!pending) return;
+        const headers = frame.headers ?? {};
+        if (pending.mode === "stream") {
+          const stream = new ReadableStream({
+            start(controller) {
+              pending.controller = controller;
+              for (const chunk of pending.pendingChunks) {
+                if (chunk.length > 0) controller.enqueue(new Uint8Array(chunk));
+              }
+              pending.pendingChunks = [];
+            },
+            cancel: () => {
+              if (httpPending.get(frame.reqId) === pending) {
+                clearTimeout(pending.timer);
+                httpPending.delete(frame.reqId);
+              }
+            }
+          });
+          pending.headEmitted = true;
+          clearTimeout(pending.timer);
+          pending.resolveHead({
+            status: frame.status,
+            headers,
+            body: stream
+          });
+        } else {
+          pending.streamHead = { status: frame.status, headers };
+        }
+        return;
+      }
+      case "http_response_chunk": {
+        const pending = httpPending.get(frame.reqId);
+        if (!pending) return;
+        const data = frame.data ? decodeData(frame.data) : Buffer.alloc(0);
+        if (pending.mode === "stream") {
+          if (frame.error) {
+            try {
+              pending.controller?.error(
+                new Error(`${frame.error.code}: ${frame.error.message}`)
+              );
+            } catch {
+            }
+            pending.ended = true;
+            clearTimeout(pending.timer);
+            httpPending.delete(frame.reqId);
+            return;
+          }
+          if (pending.controller) {
+            if (data.length > 0) {
+              try {
+                pending.controller.enqueue(new Uint8Array(data));
+              } catch {
+              }
+            }
+            if (frame.end) {
+              try {
+                pending.controller.close();
+              } catch {
+              }
+              pending.ended = true;
+              clearTimeout(pending.timer);
+              httpPending.delete(frame.reqId);
+            }
+          } else {
+            if (data.length > 0) pending.pendingChunks.push(data);
+            if (frame.end) {
+              pending.ended = true;
+            }
+          }
+        } else {
+          if (data.length > 0) pending.streamChunks.push(data);
+          if (frame.error) {
+            clearTimeout(pending.timer);
+            httpPending.delete(frame.reqId);
+            const concatenated = Buffer.concat(pending.streamChunks);
+            pending.resolve({
+              status: pending.streamHead?.status ?? 502,
+              headers: pending.streamHead?.headers ?? {},
+              body: concatenated,
+              error: frame.error
+            });
+            return;
+          }
+          if (frame.end) {
+            clearTimeout(pending.timer);
+            httpPending.delete(frame.reqId);
+            const concatenated = Buffer.concat(pending.streamChunks);
+            pending.resolve({
+              status: pending.streamHead?.status ?? 200,
+              headers: pending.streamHead?.headers ?? {},
+              body: concatenated
+            });
+          }
+        }
+        return;
+      }
+      case "ws_open_ack": {
+        const pending = wsOpenPending.get(frame.reqId);
+        if (!pending) return;
+        wsOpenPending.delete(frame.reqId);
+        clearTimeout(pending.timer);
+        if (frame.error || frame.status !== 101) {
+          const code = frame.error?.code ?? `http_${frame.status}`;
+          const msg = frame.error?.message ?? `Upstream WS upgrade returned ${frame.status}`;
+          pending.reject(new Error(`${code}: ${msg}`));
+          return;
+        }
+        const duck = new TunnelWebSocketDuck(
+          frame.reqId,
+          frame.protocol ?? null,
+          opts.sink,
+          () => wsByReq.delete(frame.reqId)
+        );
+        wsByReq.set(frame.reqId, duck);
+        pending.resolve(duck);
+        return;
+      }
+      case "ws_message": {
+        const duck = wsByReq.get(frame.reqId);
+        if (!duck) return;
+        duck.__handleMessage(decodeData(frame.data), frame.binary === true);
+        return;
+      }
+      case "ws_close": {
+        const pending = wsOpenPending.get(frame.reqId);
+        if (pending) {
+          wsOpenPending.delete(frame.reqId);
+          clearTimeout(pending.timer);
+          pending.reject(
+            new Error(
+              `WS closed before upgrade (code ${frame.code}${frame.reason ? `: ${frame.reason}` : ""})`
+            )
+          );
+          return;
+        }
+        const duck = wsByReq.get(frame.reqId);
+        if (duck) {
+          wsByReq.delete(frame.reqId);
+          duck.__handleClose(frame.code, frame.reason ?? "");
+        }
         return;
       }
       case "ping":
@@ -413,6 +961,7 @@ function createTunnelClient(opts) {
       case "kill":
       case "resize":
       case "http_request":
+      case "ws_open":
         return;
     }
   }
@@ -461,7 +1010,8 @@ function createTunnelClient(opts) {
         args,
         cwd: spawnOpts?.cwd,
         env: spawnOpts?.env,
-        pty: spawnOpts?.pty
+        pty: spawnOpts?.pty,
+        ...spawnOpts?.pty ? { cols: spawnOpts.cols ?? 80, rows: spawnOpts.rows ?? 24 } : {}
       };
       const spawnedFrame = await new Promise(
         (resolve, reject) => {
@@ -498,7 +1048,86 @@ function createTunnelClient(opts) {
             )
           );
         }, timeoutMs + 5e3);
-        httpPending.set(reqId, { resolve, reject, timer });
+        httpPending.set(reqId, {
+          mode: "buffered",
+          resolve,
+          reject,
+          timer,
+          streamHead: null,
+          streamChunks: []
+        });
+        opts.sink.send(frame);
+      });
+    },
+    async forwardHttpStream(req) {
+      if (!hello) await this.ready();
+      const reqId = randomUUID();
+      const headTimeoutMs = req.timeoutMs ?? 3e4;
+      const body = req.body === void 0 ? void 0 : encodeData(
+        typeof req.body === "string" ? req.body : Buffer.from(req.body)
+      );
+      const frame = {
+        t: "http_request",
+        reqId,
+        method: req.method,
+        path: req.path,
+        ...req.headers ? { headers: req.headers } : {},
+        ...body !== void 0 ? { body } : {},
+        timeoutMs: 24 * 60 * 60 * 1e3
+        // 24h — effectively "forever"
+      };
+      return new Promise((resolveHead, reject) => {
+        const timer = setTimeout(() => {
+          if (httpPending.has(reqId)) {
+            httpPending.delete(reqId);
+            reject(
+              new Error(
+                `Tunnel forwardHttpStream(${req.method} ${req.path}) head did not arrive within ${headTimeoutMs}ms.`
+              )
+            );
+          }
+        }, headTimeoutMs);
+        httpPending.set(reqId, {
+          mode: "stream",
+          resolveHead,
+          reject,
+          timer,
+          controller: null,
+          pendingChunks: [],
+          headEmitted: false,
+          ended: false
+        });
+        opts.sink.send(frame);
+      });
+    },
+    async forwardWebSocket(req) {
+      const h = await this.ready();
+      if (h.capabilities.wsForward !== true) {
+        throw new Error(
+          `Tunnel daemon '${h.label ?? "(unnamed)"}' does not advertise wsForward capability. Update the daemon to forward browser WS upgrades.`
+        );
+      }
+      const reqId = randomUUID();
+      const timeoutMs = req.openTimeoutMs ?? 3e4;
+      const frame = {
+        t: "ws_open",
+        reqId,
+        path: req.path,
+        ...req.upstream ? { upstream: req.upstream } : {},
+        ...req.headers ? { headers: req.headers } : {},
+        ...req.protocols && req.protocols.length > 0 ? { protocols: req.protocols } : {}
+      };
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          if (!wsOpenPending.has(reqId)) return;
+          wsOpenPending.delete(reqId);
+          reject(
+            new Error(
+              `Tunnel forwardWebSocket(${req.path}) did not receive ws_open_ack within ${timeoutMs}ms.`
+            )
+          );
+        }, timeoutMs);
+        wsOpenPending.set(reqId, { resolve, reject, timer });
         opts.sink.send(frame);
       });
     },
@@ -513,11 +1142,13 @@ var TunnelChildDuck = class extends EventEmitter {
   stdin;
   stdout;
   stderr;
+  sink;
   exited = false;
   constructor(execId, pid, sink) {
     super();
     this.execId = execId;
     this.pid = pid > 0 ? pid : null;
+    this.sink = sink;
     this.stdout = new Readable({ read() {
     } });
     this.stderr = new Readable({ read() {
@@ -540,10 +1171,6 @@ var TunnelChildDuck = class extends EventEmitter {
         cb();
       }
     });
-    Object.defineProperty(this, "__sink", {
-      value: sink,
-      enumerable: false
-    });
   }
   __pushStdout(buf) {
     this.stdout.push(buf);
@@ -575,14 +1202,104 @@ var TunnelChildDuck = class extends EventEmitter {
   }
   kill(signal = "SIGTERM") {
     if (this.exited) return false;
-    const sink = this.__sink;
-    sink.send({
+    this.sink.send({
       t: "kill",
       execId: this.execId,
       signal: typeof signal === "string" ? signal : `SIG${signal}`
     });
     return true;
   }
+  resize(cols, rows) {
+    if (this.exited) return;
+    this.sink.send({ t: "resize", execId: this.execId, cols, rows });
+  }
+};
+var TunnelWebSocketDuck = class {
+  protocol;
+  _readyState = "open";
+  reqId;
+  sink;
+  onCleanup;
+  messageListeners = /* @__PURE__ */ new Set();
+  closeListeners = /* @__PURE__ */ new Set();
+  errorListeners = /* @__PURE__ */ new Set();
+  constructor(reqId, protocol, sink, onCleanup) {
+    this.reqId = reqId;
+    this.protocol = protocol;
+    this.sink = sink;
+    this.onCleanup = onCleanup;
+  }
+  get readyState() {
+    return this._readyState;
+  }
+  send(data) {
+    if (this._readyState !== "open") return;
+    const bytes = typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(data);
+    this.sink.send({
+      t: "ws_message",
+      reqId: this.reqId,
+      data: encodeData(bytes),
+      binary: typeof data !== "string"
+    });
+  }
+  close(code = 1e3, reason) {
+    if (this._readyState === "closed") return;
+    if (this._readyState === "open") {
+      this._readyState = "closing";
+      this.sink.send({
+        t: "ws_close",
+        reqId: this.reqId,
+        code,
+        ...reason ? { reason } : {}
+      });
+    }
+    this.__handleClose(code, reason ?? "");
+  }
+  onMessage(listener) {
+    this.messageListeners.add(listener);
+    return () => this.messageListeners.delete(listener);
+  }
+  onClose(listener) {
+    this.closeListeners.add(listener);
+    return () => this.closeListeners.delete(listener);
+  }
+  onError(listener) {
+    this.errorListeners.add(listener);
+    return () => this.errorListeners.delete(listener);
+  }
+  __handleMessage(data, isBinary) {
+    if (this._readyState !== "open") return;
+    for (const l of this.messageListeners) {
+      try {
+        l(data, isBinary);
+      } catch {
+      }
+    }
+  }
+  __handleClose(code, reason) {
+    if (this._readyState === "closed") return;
+    this._readyState = "closed";
+    this.onCleanup();
+    for (const l of this.closeListeners) {
+      try {
+        l(code, reason);
+      } catch {
+      }
+    }
+    this.messageListeners.clear();
+    this.closeListeners.clear();
+    this.errorListeners.clear();
+  }
+  __handleSinkClosed() {
+    if (this._readyState === "closed") return;
+    for (const l of this.errorListeners) {
+      try {
+        l(new Error("Tunnel closed mid-WS."));
+      } catch {
+      }
+    }
+    this.__handleClose(1006, "tunnel_closed");
+  }
 };
 
 // src/tunnel/ws-adapter.ts
@@ -646,6 +1363,6 @@ function wrapWebSocket(ws) {
   };
 }
 
-export { TUNNEL_VERSION, createTunnelClient, createTunnelServer, decodeData, encodeData, encodeFrame, parseFrame, wrapWebSocket };
+export { DEFAULT_HTTP_FORWARD_TIMEOUT_MS, DEFAULT_WS_DIAL_TIMEOUT_MS, TUNNEL_VERSION, createTunnelClient, createTunnelServer, decodeData, encodeData, encodeFrame, parseFrame, wrapWebSocket };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map