@agentproto/acp 0.1.0-alpha.1 → 0.1.0

package/dist/tunnel/index.mjs

@@ -16,6 +16,14 @@ var KNOWN_TYPES = /* @__PURE__ */ new Set([
   "stdin",
   "kill",
   "resize",
+  "http_request",
+  "http_response",
+  "http_response_head",
+  "http_response_chunk",
+  "ws_open",
+  "ws_open_ack",
+  "ws_message",
+  "ws_close",
   "ping",
   "pong",
   "error",
@@ -23,7 +31,8 @@ var KNOWN_TYPES = /* @__PURE__ */ new Set([
   "spawned",
   "stdout",
   "stderr",
-  "exit"
+  "exit",
+  "reconnect_soon"
 ]);
 function parseFrame(raw) {
   let parsed;
@@ -51,11 +60,16 @@ function decodeData(data) {
 }
 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
+    },
     label: opts.label,
     daemon: {
       name: "agentproto",
@@ -74,6 +88,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();
   });
@@ -83,6 +106,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({
@@ -97,6 +125,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({
@@ -110,11 +143,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;
@@ -150,6 +232,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], {
@@ -174,6 +298,15 @@ function createTunnelServer(opts) {
     } else {
       opts.sink.send({ t: "spawned", execId: req.execId, pid: -1 });
     }
+    if (opts.onChildSpawned) {
+      try {
+        opts.onChildSpawned({ execId: req.execId, child, request: approved });
+      } catch (err) {
+        console.warn(
+          `[tunnel-server] onChildSpawned hook threw for execId=${req.execId}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
     child.stdout?.on("data", (chunk) => {
       const f = {
         t: "stdout",
@@ -209,6 +342,258 @@ 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;
+    }
+    const base = opts.httpUpstream.replace(/^http(s?):\/\//, "ws$1://");
+    const url = `${base.replace(/\/$/, "")}${req.path}`;
+    let upstream;
+    try {
+      upstream = await opts.dialUpstreamWs({
+        url,
+        ...req.protocols && req.protocols.length > 0 ? { protocols: req.protocols } : {},
+        headers
+      });
+    } catch (err) {
+      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 (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) => {
+      opts.sink.send({
+        t: "http_response",
+        reqId: req.reqId,
+        ...partial
+      });
+    };
+    if (!opts.httpUpstream) {
+      respond({
+        status: 502,
+        error: {
+          code: "http_upstream_not_configured",
+          message: "Daemon was not started with an http upstream \u2014 cannot forward HTTP frames."
+        }
+      });
+      return;
+    }
+    if (!req.path.startsWith("/") || req.path.startsWith("//") || req.path.includes("..")) {
+      respond({
+        status: 400,
+        error: {
+          code: "invalid_path",
+          message: `Daemon http forward requires a safe relative path; got '${req.path}'.`
+        }
+      });
+      return;
+    }
+    const HOP_BY_HOP = /* @__PURE__ */ new Set([
+      "connection",
+      "keep-alive",
+      "transfer-encoding",
+      "upgrade",
+      "proxy-authenticate",
+      "proxy-authorization",
+      "te",
+      "trailer",
+      "host",
+      // upstream sets its own based on the URL
+      "content-length"
+      // fetch recomputes
+    ]);
+    const headers = {};
+    for (const [k, v] of Object.entries(req.headers ?? {})) {
+      if (HOP_BY_HOP.has(k.toLowerCase())) continue;
+      headers[k] = v;
+    }
+    const url = `${opts.httpUpstream.replace(/\/$/, "")}${req.path}`;
+    const controller = new AbortController();
+    const timeoutMs = req.timeoutMs ?? 3e4;
+    let timer = setTimeout(
+      () => controller.abort(),
+      timeoutMs
+    );
+    const clearTimer = () => {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    };
+    try {
+      const upstreamRes = await fetch(url, {
+        method: req.method,
+        headers,
+        body: req.body === void 0 ? void 0 : decodeData(req.body),
+        signal: controller.signal
+        // node fetch follows redirects by default — fine for MCP, the
+        // upstream gateway doesn't redirect anyway.
+      });
+      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();
+        try {
+          while (true) {
+            const { value, done } = await reader.read();
+            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,
+        body: buf.length > 0 ? encodeData(buf) : ""
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const aborted = err instanceof Error && err.name === "AbortError";
+      respond({
+        status: aborted ? 504 : 502,
+        error: {
+          code: aborted ? "timeout" : "upstream_fetch_failed",
+          message
+        }
+      });
+    } finally {
+      clearTimer();
+    }
+  }
   return {
     children,
     async close() {
@@ -226,6 +611,9 @@ function createTunnelClient(opts) {
   let helloPromise = null;
   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();
@@ -234,6 +622,31 @@ function createTunnelClient(opts) {
       p.reject(new Error("Tunnel closed before spawn completed."));
     }
     spawnPending.clear();
+    for (const [, p] of httpPending) {
+      clearTimeout(p.timer);
+      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();
   });
@@ -285,6 +698,178 @@ function createTunnelClient(opts) {
         }
         return;
       }
+      case "http_response": {
+        const pending = httpPending.get(frame.reqId);
+        if (!pending) return;
+        httpPending.delete(frame.reqId);
+        clearTimeout(pending.timer);
+        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":
         opts.sink.send({ t: "pong", nonce: frame.nonce });
         return;
@@ -293,6 +878,8 @@ function createTunnelClient(opts) {
       case "stdin":
       case "kill":
       case "resize":
+      case "http_request":
+      case "ws_open":
         return;
     }
   }
@@ -341,7 +928,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) => {
@@ -353,6 +941,113 @@ function createTunnelClient(opts) {
       childByExec.set(execId, duck);
       return duck;
     },
+    async forwardHttp(req) {
+      if (!hello) await this.ready();
+      const reqId = randomUUID();
+      const timeoutMs = 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
+      };
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          httpPending.delete(reqId);
+          reject(
+            new Error(
+              `Tunnel forwardHttp(${req.method} ${req.path}) timed out after ${timeoutMs + 5e3}ms.`
+            )
+          );
+        }, timeoutMs + 5e3);
+        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.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);
+      });
+    },
     async close() {
       opts.sink.close("client.close");
     }
@@ -364,11 +1059,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() {
@@ -391,10 +1088,6 @@ var TunnelChildDuck = class extends EventEmitter {
         cb();
       }
     });
-    Object.defineProperty(this, "__sink", {
-      value: sink,
-      enumerable: false
-    });
   }
   __pushStdout(buf) {
     this.stdout.push(buf);
@@ -426,14 +1119,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