@celilo/e2e 0.20.5 → 0.20.6

package/docker/Dockerfile.management

@@ -124,6 +124,36 @@ ENV NODE_EXTRA_CA_CERTS=/etc/ssl/certs/ca-certificates.crt
 # fall through to Bun's normal resolution.
 RUN printf '[install.scopes]\n"@celilo" = "http://npm-registry.lab"\n' > /root/.bunfig.toml
 
+# --- The fleet browser runtime (managed-browser-runtime) ----------------------
+#
+# Browser-driven health checks (celilo-web-console is the first) resolve
+# `/var/lib/celilo/browsers/current/chrome` and a descriptor describing what
+# was installed. This image provisions that runtime the way the celilo-mgmt
+# role does on a real management host (`modules/celilo-mgmt/ansible/roles/
+# celilo-mgmt/tasks/debian.yml`), pinned to the SAME playwright version that
+# role declares — the fleet's single browser-version declaration. A module
+# bundling a different client is a pin-drift finding, not a failure: the
+# consumer passes the stable path explicitly.
+#
+# Revision comes from the pinned client itself (`install --dry-run`), never
+# from a hand-maintained version→revision table — same reasoning as the role.
+ARG PLAYWRIGHT_VERSION=1.60.0
+RUN set -eux; \
+    REVISION="$(PLAYWRIGHT_BROWSERS_PATH=/var/lib/celilo/browsers bun x "playwright-core@${PLAYWRIGHT_VERSION}" install --dry-run chromium-headless-shell \
+      | grep -oE 'chromium_headless_shell-[0-9]+' | head -1 | cut -d- -f2)"; \
+    PLAYWRIGHT_BROWSERS_PATH=/var/lib/celilo/browsers bun x "playwright-core@${PLAYWRIGHT_VERSION}" install chromium-headless-shell; \
+    PLAYWRIGHT_BROWSERS_PATH=/var/lib/celilo/browsers bun x "playwright-core@${PLAYWRIGHT_VERSION}" install-deps chromium-headless-shell; \
+    BIN="$(find /var/lib/celilo/browsers/chromium_headless_shell-"${REVISION}" -type f \
+      \( -name chrome-headless-shell -o -name headless_shell \) | head -1)"; \
+    test -x "${BIN}"; \
+    mkdir -p /var/lib/celilo/browsers/current; \
+    ln -sf "${BIN}" /var/lib/celilo/browsers/current/chrome; \
+    BROWSER_VERSION="$(/var/lib/celilo/browsers/current/chrome --version | grep -oE '[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+' | head -1)"; \
+    printf '{"schemaVersion":1,"browser":"chromium","flavor":"headless-shell","browserVersion":"%s","playwrightVersion":"%s","revision":"%s","writtenBy":"e2e management image"}' \
+      "${BROWSER_VERSION}" "${PLAYWRIGHT_VERSION}" "${REVISION}" \
+      > /var/lib/celilo/browsers/current/celilo-browser.json; \
+    cat /var/lib/celilo/browsers/current/celilo-browser.json
+
 # Standard modules pre-packaged as .netapp files — built by e2e-build.
 # Tests import from /netapps/<module>.netapp instead of the monorepo mount.
 COPY netapps/ /netapps/

package/docker/Dockerfile.socks-proxy

@@ -18,6 +18,11 @@ RUN apt-get update && apt-get install -y \
     iproute2 \
     iputils-ping \
     dnsutils \
+    # wireguard-tools: the control-plane-vpn vantage. A browser that reaches
+    # celilo-web-console (secure-mgmt, VPN-only per D7) must enter as a real
+    # VPN peer — the proxy brings up a wg tunnel, it does not attach directly
+    # to the zone. Needs /dev/net/tun at `docker run` time (socks-proxy.ts).
+    wireguard-tools \
     && rm -rf /var/lib/apt/lists/*
 
 COPY config/socks/danted.conf /etc/danted.conf

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celilo/e2e",
-  "version": "0.20.5",
+  "version": "0.20.6",
   "description": "E2E test infrastructure for Celilo-deployed applications. Provides a simulated internet with DNS hierarchy, ACME server, firewalls, and target machines in Docker.",
   "type": "module",
   "main": "./src/index.ts",
@@ -38,7 +38,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@celilo/capabilities": "^5.1.1",
+    "@celilo/capabilities": "^6.0.0",
     "@celilo/cli-display": "^0.2.0",
     "@celilo/event-bus": "^0.7.0",
     "@celilo/terraform-fake": "^0.3.1",

package/src/socks-proxy.ts

@@ -3,6 +3,7 @@ import { existsSync } from 'node:fs';
 import { createConnection } from 'node:net';
 import { join } from 'node:path';
 import { progress } from './progress';
+import type { ExecResult, SocksProxyHandle } from './types';
 
 /** Package root — `docker/` and `config/` live here. */
 const PACKAGE_ROOT = join(__dirname, '..');
@@ -37,17 +38,6 @@ export interface SocksProxyOptions {
   nameserver?: string;
 }
 
-export interface SocksProxyHandle {
-  /** URL the host can use to reach the proxy, e.g. 'socks5://127.0.0.1:54321' */
-  hostUrl: string;
-  /** The published host port (the second half of hostUrl) */
-  hostPort: number;
-  /** Container name (deterministic per project + vantage) */
-  containerName: string;
-  /** Tear down the proxy. Idempotent. */
-  stop(): Promise<void>;
-}
-
 /**
  * Custom image with dante-server + an entrypoint that fixes routing
  * and DNS for the chosen vantage. Built from
@@ -139,6 +129,11 @@ export async function startSocksProxy(
         `--network ${networkName}`,
         `--ip ${cfg.ip}`,
         '--cap-add NET_ADMIN',
+        // wireguard-tools in the image plus the TUN device let the proxy bring
+        // up a real WireGuard tunnel, which is how a browser enters the
+        // topology as a control-plane-vpn peer (celilo-web-console's only
+        // client path, D7). Harmless for the plain vantages.
+        '--device /dev/net/tun',
         `-e VANTAGE=${vantage}`,
         ...(options.nameserver ? [`-e NAMESERVER_OVERRIDE=${options.nameserver}`] : []),
         '-p 127.0.0.1::1080',
@@ -224,6 +219,32 @@ function makeHandle(containerName: string, port: number): SocksProxyHandle {
     hostUrl: `socks5://127.0.0.1:${port}`,
     hostPort: port,
     containerName,
+    /**
+     * Run a command inside the proxy container.
+     *
+     * The proxy is started with `docker run`, not compose, so
+     * `net.exec` (a `docker compose exec`) cannot reach it. The
+     * control-plane-vpn test uses this to bring the proxy's WireGuard
+     * tunnel up after the tunnel has deployed — the peer is the proxy,
+     * so the browser behind it enters the topology the way a real
+     * admin laptop does.
+     */
+    async exec(cmd, timeoutMs = 60_000): Promise<ExecResult> {
+      try {
+        const stdout = execSync(`docker exec ${containerName} bash -c ${JSON.stringify(cmd)}`, {
+          timeout: timeoutMs,
+          stdio: 'pipe',
+        }).toString();
+        return { stdout, stderr: '', exitCode: 0 };
+      } catch (err: unknown) {
+        const e = err as { stdout?: Buffer; stderr?: Buffer; status?: number };
+        return {
+          stdout: e.stdout?.toString() ?? '',
+          stderr: e.stderr?.toString() ?? String(err),
+          exitCode: e.status ?? 1,
+        };
+      }
+    },
     async stop(): Promise<void> {
       if (stopped) return;
       stopped = true;

package/src/types.ts

@@ -220,6 +220,14 @@ export interface SocksProxyHandle {
   hostPort: number;
   /** Container name (deterministic per project + vantage) */
   containerName: string;
+  /**
+   * Run a command inside the proxy container (raw `docker exec`).
+   *
+   * The proxy is started with `docker run`, not compose, so `net.exec`
+   * cannot reach it. The control-plane-vpn browser test uses this to bring
+   * the proxy's WireGuard tunnel up after the tunnel has deployed.
+   */
+  exec(cmd: string, timeoutMs?: number): Promise<ExecResult>;
   /** Tear down the proxy. Idempotent. */
   stop(): Promise<void>;
 }