@runuai/host 0.8.44 → 0.8.45

package/lib/tunnel-registry.ts

@@ -0,0 +1,104 @@
+/**
+ * Tunnel upstreams, plus the frames that arrive before an upstream exists.
+ *
+ * `tunnel.open` is handled ASYNCHRONOUSLY on the host: resolving a target can
+ * await the task lifecycle lock and, for an ad-hoc preview, `docker run` of a
+ * sidecar (ADR-043). The frames that follow it — `tunnel.data`,
+ * `tunnel.requestEnd`, `tunnel.close` — are handled synchronously off the same
+ * WebSocket, and the cloud emits `requestEnd` for a bodyless GET on the tick
+ * after `open`. So they routinely land while the open is still resolving.
+ *
+ * Looking the tunnel up with `tunnels.get(id)?.` silently dropped them, and a
+ * dropped `requestEnd` is unrecoverable rather than merely late. The HTTP open
+ * deliberately leaves its `ClientRequest` unended so request bodies can stream,
+ * and node writes no header until `write`/`end` — so the upstream socket
+ * CONNECTS and then receives nothing at all. On the wire that reads as an
+ * established TCP connection carrying zero bytes, an upstream that never saw a
+ * request, and a flat 30s `504 host did not respond in time` from the cloud's
+ * ack deadline: four symptoms that each point somewhere different, none of them
+ * at the open that never finished.
+ *
+ * So ops for an opening tunnel are QUEUED and replayed on `register`. The
+ * queue is bounded by the request itself — the cloud stops sending once its
+ * ack deadline fires — and is dropped by `abandon` when an open fails, so a
+ * tunnel that never opens leaves nothing behind.
+ */
+
+export interface TunnelUpstream {
+  write(chunk: Buffer): boolean;
+  end(): void;
+  destroy(): void;
+}
+
+type TunnelOp = (upstream: TunnelUpstream) => void;
+
+export class TunnelRegistry {
+  private readonly open = new Map<string, TunnelUpstream>();
+  /** tunnelId -> ops that arrived while its `tunnel.open` was still resolving. */
+  private readonly opening = new Map<string, TunnelOp[]>();
+
+  /**
+   * Mark a tunnel as opening. MUST be called synchronously when `tunnel.open`
+   * is received — before the first `await` of target resolution — or the frames
+   * that follow have nothing to queue against and are dropped, which is the
+   * whole bug this class exists for.
+   */
+  markOpening(tunnelId: string): void {
+    this.opening.set(tunnelId, []);
+  }
+
+  /** Target resolved: publish the upstream and replay what arrived meanwhile. */
+  register(tunnelId: string, upstream: TunnelUpstream): void {
+    this.open.set(tunnelId, upstream);
+    const queued = this.opening.get(tunnelId);
+    this.opening.delete(tunnelId);
+    if (!queued) return;
+    for (const op of queued) op(upstream);
+  }
+
+  /** Open failed (no target, or it errored) — nothing will ever service these. */
+  abandon(tunnelId: string): void {
+    this.opening.delete(tunnelId);
+  }
+
+  get(tunnelId: string): TunnelUpstream | undefined {
+    return this.open.get(tunnelId);
+  }
+
+  delete(tunnelId: string): void {
+    this.open.delete(tunnelId);
+  }
+
+  /**
+   * Run `op` against the upstream now, or queue it if the tunnel is still
+   * opening. A tunnel this registry has never heard of is dropped, exactly as
+   * the old `?.` did — that is a frame for a tunnel already torn down, not a
+   * race.
+   */
+  apply(tunnelId: string, op: TunnelOp): void {
+    const upstream = this.open.get(tunnelId);
+    if (upstream) {
+      op(upstream);
+      return;
+    }
+    this.opening.get(tunnelId)?.push(op);
+  }
+
+  /**
+   * Tear the tunnel down now, or as soon as it opens. Queued ops are discarded
+   * rather than replayed first: they exist to be written to an upstream that is
+   * about to be destroyed, and a `write` after `destroy` is at best wasted and
+   * at worst an unhandled error on a socket nobody is listening to any more.
+   */
+  abort(tunnelId: string): void {
+    const upstream = this.open.get(tunnelId);
+    this.open.delete(tunnelId);
+    if (upstream) {
+      upstream.destroy();
+      return;
+    }
+    if (this.opening.has(tunnelId)) {
+      this.opening.set(tunnelId, [(u) => u.destroy()]);
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.8.44",
+  "version": "0.8.45",
   "description": "Uai host — runs ephemeral AI coding tasks in Docker on a machine you control.",
   "license": "MIT",
   "author": "Diogo Perillo <diogo.perillo@gmail.com>",

package/src/main.ts

@@ -59,6 +59,7 @@ import {
   ensurePreviewSidecar,
   invalidatePreviewSidecar,
 } from "../lib/preview-sidecar";
+import { TunnelRegistry } from "../lib/tunnel-registry";
 import { newId } from "../lib/ulid";
 import {
   capabilities as agentKindCapabilities,
@@ -126,13 +127,7 @@ let reconnectAttempt = 0;
 let inFlight = 0;
 let shutdownRequested = false;
 let pendingBinaryTunnelId: string | null = null;
-const tunnels = new Map<string, TunnelUpstream>();
-
-interface TunnelUpstream {
-  write(chunk: Buffer): boolean;
-  end(): void;
-  destroy(): void;
-}
+const tunnels = new TunnelRegistry();
 
 interface PausableSource {
   pause(): unknown;
@@ -301,7 +296,8 @@ function connect(): void {
       const tunnelId = pendingBinaryTunnelId;
       pendingBinaryTunnelId = null;
       if (!tunnelId) return;
-      tunnels.get(tunnelId)?.write(rawDataToBuffer(data));
+      const chunk = rawDataToBuffer(data);
+      tunnels.apply(tunnelId, (upstream) => upstream.write(chunk));
       return;
     }
 
@@ -315,6 +311,10 @@ function connect(): void {
         void handleCommand(socket, frame);
         break;
       case "tunnel.open":
+        // Synchronously, BEFORE handleTunnelOpen's first await: the frames that
+        // follow this one (a bodyless GET's `requestEnd` arrives on the next
+        // tick) need somewhere to queue while the target resolves.
+        tunnels.markOpening(frame.tunnelId);
         void handleTunnelOpen(socket, frame);
         break;
       case "tunnel.data":
@@ -322,7 +322,10 @@ function connect(): void {
         break;
       case "tunnel.requestEnd":
         // Request body complete → finish the upstream request so it can reply.
-        tunnels.get(frame.tunnelId)?.end();
+        // Queued if the open is still resolving: node flushes no request header
+        // until `end`, so losing this strands the upstream on a connected
+        // socket that never receives a byte.
+        tunnels.apply(frame.tunnelId, (upstream) => upstream.end());
         break;
       case "tunnel.close":
         closeTunnel(socket, frame.tunnelId, frame.reason);
@@ -497,6 +500,8 @@ async function handleTunnelOpen(
 ): Promise<void> {
   const target = await resolveTunnelTarget(frame);
   if (!target) {
+    // Nothing will ever service what queued behind this open.
+    tunnels.abandon(frame.tunnelId);
     send(wsSocket, {
       kind: "tunnel.ack",
       tunnelId: frame.tunnelId,
@@ -555,7 +560,9 @@ function handleHttpTunnelOpen(
     },
   );
 
-  tunnels.set(frame.tunnelId, upstream);
+  // Registering replays anything that arrived while the target resolved — for a
+  // bodyless GET that is the `requestEnd` this request cannot reply without.
+  tunnels.register(frame.tunnelId, upstream);
 
   upstream.on("error", (err) => {
     tunnels.delete(frame.tunnelId);
@@ -595,7 +602,6 @@ function handleRawTunnelOpen(
   target: UpstreamAddr,
 ): void {
   const upstream = new Socket();
-  tunnels.set(frame.tunnelId, upstream);
 
   let acked = false;
   let responseBuffer = Buffer.alloc(0);
@@ -660,6 +666,11 @@ function handleRawTunnelOpen(
   });
 
   upstream.connect(target.port, target.host);
+  // AFTER `connect`, not before: replaying a queued write onto a socket that
+  // has not started connecting errors, while node buffers writes made once it
+  // is connecting. An upgrade's own request goes out from the `connect`
+  // handler, so only client frames that overtook the open replay here.
+  tunnels.register(frame.tunnelId, upstream);
 }
 
 function closeTunnel(
@@ -667,9 +678,9 @@ function closeTunnel(
   tunnelId: string,
   reason: string | undefined,
 ): void {
-  const upstream = tunnels.get(tunnelId);
-  tunnels.delete(tunnelId);
-  upstream?.destroy();
+  // `abort`, not get+delete: a client that gives up while the target is still
+  // resolving would otherwise leave the tunnel to open onto nobody.
+  tunnels.abort(tunnelId);
   send(wsSocket, { kind: "tunnel.close", tunnelId, reason });
 }