@runuai/host 0.9.14 → 0.9.42

package/lib/preview-sidecar.ts

@@ -9,18 +9,20 @@
  * (always local — no registry pull) under `node` with a ~5-line `net` TCP proxy;
  * node streams give backpressure + handle WebSockets (Metro/HMR).
  *
- * Hot path is cache-only (NO docker call per request — that thrashed under a
- * browser's concurrent requests). The cached port is trusted until a tunnel
- * connect fails, which invalidates it (mirrors the container-IP cache). Declared
- * ports keep their published-port path; only ad-hoc ports use a sidecar.
+ * The cache deduplicates creation, but every tunnel open re-proves the exact
+ * sidecar container and its current Docker mapping. A process-lifetime cached
+ * localhost port is unsafe across an unnoticed daemon restart: another process
+ * can inherit that port before the bridge reconnects and triggers recovery.
  */
 import net from "node:net";
 
 import { dockerCli } from "./docker-exec";
+import { inspectTunnelContainer } from "./tunnel-runtime";
 
 /** Port the proxy listens on inside the sidecar (published to a random host port). */
 const INNER_PORT = 9000;
 const LABEL = "com.runuai.preview-sidecar.task";
+const TARGET_LABEL = "com.runuai.preview-sidecar.target";
 
 /** (taskId,name,containerPort) -> published 127.0.0.1 host port of a live sidecar. */
 const cache = new Map<string, number>();
@@ -135,13 +137,18 @@ async function imageOf(appContainer: string): Promise<string | null> {
   return r.status === 0 && r.stdout.trim() ? r.stdout.trim() : null;
 }
 
-/** `docker port <name>` -> the published 127.0.0.1 host port, or null. */
+/** Live Docker proof -> the published 127.0.0.1 host port and labels, or null. */
+async function publishedSidecar(
+  name: string,
+): Promise<{ port: number; labels: Record<string, string> } | null> {
+  const proof = await inspectTunnelContainer(name, INNER_PORT);
+  return proof.kind === "running" && proof.published?.host === "127.0.0.1"
+    ? { port: proof.published.port, labels: proof.labels }
+    : null;
+}
+
 async function publishedPort(name: string): Promise<number | null> {
-  const r = await dockerCli(["port", name, String(INNER_PORT)], {
-    timeoutMs: 5_000,
-  });
-  const m = r.stdout.match(/127\.0\.0\.1:(\d+)/);
-  return r.status === 0 && m ? Number(m[1]) : null;
+  return (await publishedSidecar(name))?.port ?? null;
 }
 
 async function createSidecar(args: {
@@ -152,6 +159,7 @@ async function createSidecar(args: {
 }): Promise<number | null> {
   const name = sidecarName(args.taskId, args.name);
   const appContainer = `${args.composeProject}-app-1`;
+  const target = `${appContainer}:${args.containerPort}`;
 
   // Reuse a still-running sidecar from a previous host process (--rm keeps it up
   // across a host restart; the in-memory cache was cleared). `docker port` is an
@@ -163,9 +171,20 @@ async function createSidecar(args: {
   // sidecar serves `socket hang up` forever: the recovery path invalidates the
   // CACHE on a failed connect, then lands right back here and returns the same
   // corpse. Nothing could break the cycle short of removing it by hand.
-  const existing = await publishedPort(name);
+  const existing = await publishedSidecar(name);
   if (existing !== null) {
-    if (await probeSidecar(existing)) return existing;
+    // The Docker name is stable per (task, preview name), while a task-scoped
+    // preview may later point that name at another container port. The
+    // process-local cache key carries the port, but it vanishes on host
+    // restart; without a durable target label a healthy old proxy would be
+    // reused and silently route the authenticated request to the wrong port.
+    // Legacy unlabeled sidecars rebuild once.
+    if (
+      existing.labels[TARGET_LABEL] === target &&
+      (await probeSidecar(existing.port))
+    ) {
+      return existing.port;
+    }
     await dockerCli(["rm", "-f", name], { timeoutMs: 10_000 });
   }
 
@@ -179,6 +198,7 @@ async function createSidecar(args: {
       "--name", name,
       "--network", `${args.composeProject}_default`,
       "--label", `${LABEL}=${args.taskId}`,
+      "--label", `${TARGET_LABEL}=${target}`,
       "-p", `127.0.0.1::${INNER_PORT}`,
       "--entrypoint", "node",
       image,
@@ -224,7 +244,31 @@ export async function ensurePreviewSidecar(args: {
 }): Promise<number | null> {
   const key = cacheKey(args.taskId, args.name, args.containerPort);
   const cached = cache.get(key);
-  if (cached !== undefined) return cached;
+  if (cached !== undefined) {
+    const current = await publishedSidecar(sidecarName(args.taskId, args.name));
+    const expectedTarget =
+      `${args.composeProject}-app-1:${args.containerPort}`;
+    const app =
+      current?.port === cached &&
+      current.labels[TARGET_LABEL] === expectedTarget
+        ? await inspectTunnelContainer(
+            `${args.composeProject}-app-1`,
+            args.containerPort,
+          )
+        : null;
+    // The sidecar's PID is the proxy itself, and it resolves the app by stable
+    // Compose DNS name for each connection. Proving both exact containers are
+    // running avoids the old 150ms socket-settle penalty on every browser asset
+    // while still rejecting a localhost port inherited after daemon restart.
+    if (
+      current?.port === cached &&
+      current.labels[TARGET_LABEL] === expectedTarget &&
+      app?.kind === "running"
+    ) {
+      return cached;
+    }
+    cache.delete(key);
+  }
 
   let pending = inflight.get(key);
   if (!pending) {