fix(e2e): bind fake APIs to the OpenShell bridge

test/e2e/live/hermes-discord.test.ts

@@ -40,7 +40,7 @@ const DISCORD_SERVER_IDS = process.env.DISCORD_SERVER_IDS ?? "149159099275359059
 const DISCORD_ALLOWED_IDS = process.env.DISCORD_ALLOWED_IDS ?? "1005536447329222676";
 const DISCORD_REQUIRE_MENTION = process.env.DISCORD_REQUIRE_MENTION ?? "0";
 const HERMES_HEALTH_URL = "http://localhost:8642/health";
-const FAKE_DISCORD_HOST = "host.docker.internal";
+const FAKE_DISCORD_HOST = "host.openshell.internal";
 const HERMES_DISCORD_HTTP_PROXY_GATEWAY_TEMPLATE = hermesDiscordHttpProxyWebSocketUrl(
   "{host}",
   "{port}",
@@ -267,7 +267,7 @@ results = []
 
 async def main():
     port = int(os.environ["FAKE_DISCORD_GATEWAY_CLIENT_PORT"])
-    host = os.environ.get("FAKE_DISCORD_GATEWAY_CLIENT_HOST", "host.docker.internal")
+    host = os.environ.get("FAKE_DISCORD_GATEWAY_CLIENT_HOST", "host.openshell.internal")
     token = read_env_token()
     client = discord.Client(intents=discord.Intents.none())
     setup = getattr(client, "_async_setup_hook", None)

test/e2e/live/messaging-providers-helpers.ts

@@ -3,6 +3,7 @@
 
 import crypto from "node:crypto";
 import fs from "node:fs";
+import { isIPv4 } from "node:net";
 import os from "node:os";
 import path from "node:path";
 
@@ -41,6 +42,7 @@ export const LIVE_TIMEOUT_MS = 90 * 60_000;
 export const OPENSHELL_EXEC_ARGUMENT_LIMIT_BYTES = 32_768;
 const FAKE_API_IMAGE =
   "node:22-trixie-slim@sha256:db8a96a63e5264607ada2d206758876ebbed6a12be2ada7517793cbfb0c2a29c";
+const DEFAULT_OPENSHELL_DOCKER_NETWORK = "openshell-docker";
 const FAKE_API_PROXY_SOURCE = String.raw`
 const net = require("node:net");
 const upstream = process.env.NEMOCLAW_FAKE_API_UPSTREAM;
@@ -656,6 +658,46 @@ export async function startFakeDockerApi(
   const containerPorts = options.kind === "slack" ? [8080, 8081] : [8080];
   fs.writeFileSync(captureFile, "");
 
+  const openshellNetwork =
+    options.env.OPENSHELL_DOCKER_NETWORK_NAME ??
+    process.env.OPENSHELL_DOCKER_NETWORK_NAME ??
+    DEFAULT_OPENSHELL_DOCKER_NETWORK;
+  const openshellNetworkInspect = await runHost(
+    host,
+    "docker",
+    ["network", "inspect", openshellNetwork],
+    {
+      artifactName: `inspect-fake-${options.kind}-openshell-network`,
+      env: options.env,
+      redactionValues: options.redactionValues,
+      timeoutMs: 30_000,
+    },
+  );
+  expectExitZero(openshellNetworkInspect, "inspect OpenShell Docker network");
+  let openshellNetworkRecords: unknown;
+  try {
+    openshellNetworkRecords = JSON.parse(openshellNetworkInspect.stdout);
+  } catch {
+    throw new Error("OpenShell Docker network inspection returned invalid JSON");
+  }
+  const openshellBridgeAddress =
+    Array.isArray(openshellNetworkRecords) && openshellNetworkRecords.length === 1
+      ? (
+          openshellNetworkRecords[0] as {
+            Driver?: unknown;
+            IPAM?: { Config?: Array<{ Gateway?: unknown }> };
+          }
+        ).IPAM?.Config?.find((entry) => typeof entry.Gateway === "string" && isIPv4(entry.Gateway))
+          ?.Gateway
+      : undefined;
+  if (
+    (openshellNetworkRecords as Array<{ Driver?: unknown }> | undefined)?.[0]?.Driver !==
+      "bridge" ||
+    typeof openshellBridgeAddress !== "string"
+  ) {
+    throw new Error("OpenShell Docker network has no IPv4 bridge gateway");
+  }
+
   const networkCreate = await runHost(
     host,
     "docker",
@@ -772,7 +814,7 @@ export async function startFakeDockerApi(
       proxyContainer,
       "--network",
       "bridge",
-      ...containerPorts.flatMap((port) => ["-p", `127.0.0.1::${String(port)}`]),
+      ...containerPorts.flatMap((port) => ["-p", `${openshellBridgeAddress}::${String(port)}`]),
       "--read-only",
       "--cap-drop",
       "ALL",
@@ -824,11 +866,13 @@ export async function startFakeDockerApi(
       },
     );
     expectExitZero(result, `read fake ${options.kind} API proxy port`);
-    const hostPort = result.stdout.trim().match(/^127\.0\.0\.1:(\d+)$/u)?.[1];
-    if (!hostPort) {
-      throw new Error(`fake ${options.kind} API proxy port did not bind only to 127.0.0.1`);
+    const published = result.stdout.trim().match(/^(\d+\.\d+\.\d+\.\d+):(\d+)$/u);
+    if (published?.[1] !== openshellBridgeAddress || !published[2]) {
+      throw new Error(
+        `fake ${options.kind} API proxy port did not bind only to the OpenShell bridge`,
+      );
     }
-    return hostPort;
+    return published[2];
   };
 
   const publishedRestPort = await publishedPort(8080, `port-fake-${options.kind}-api`);

test/e2e/support/messaging-providers-runtime-proofs.test.ts

@@ -28,6 +28,13 @@ import { parseInstalledWechatProof } from "../live/messaging-providers-wechat-ru
 const FAKE_TELEGRAM_API = path.resolve(import.meta.dirname, "../lib/fake-telegram-api.cjs");
 const FAKE_SLACK_API = path.resolve(import.meta.dirname, "../lib/fake-slack-api.cjs");
 const FAKE_WECHAT_API = path.resolve(import.meta.dirname, "../lib/fake-wechat-api.mts");
+const OPENSHELL_BRIDGE_ADDRESS = "172.18.0.1";
+const OPENSHELL_NETWORK_INSPECT = JSON.stringify([
+  {
+    Driver: "bridge",
+    IPAM: { Config: [{ Subnet: "172.18.0.0/16", Gateway: OPENSHELL_BRIDGE_ADDRESS }] },
+  },
+]);
 
 async function waitFor(predicate: () => boolean, message: string): Promise<void> {
   const deadline = Date.now() + 5_000;
@@ -56,7 +63,7 @@ function successfulCommand(stdout = "") {
   };
 }
 
-function fakeDockerHost(publishedAddress = "127.0.0.1"): {
+function fakeDockerHost(publishedAddress = OPENSHELL_BRIDGE_ADDRESS): {
   calls: string[][];
   host: HostCliClient;
 } {
@@ -71,9 +78,11 @@ function fakeDockerHost(publishedAddress = "127.0.0.1"): {
           const fixtureDir = fakeApiMount.slice(0, -":/tmp/fake".length);
           fs.writeFileSync(path.join(fixtureDir, "port"), "8080");
         });
-      return args[0] === "port"
-        ? successfulCommand(`${publishedAddress}:${args[2] === "8081/tcp" ? "32101" : "32100"}\n`)
-        : successfulCommand();
+      return args[0] === "network" && args[1] === "inspect"
+        ? successfulCommand(OPENSHELL_NETWORK_INSPECT)
+        : args[0] === "port"
+          ? successfulCommand(`${publishedAddress}:${args[2] === "8081/tcp" ? "32101" : "32100"}\n`)
+          : successfulCommand();
     },
   } as unknown as HostCliClient;
   return { calls, host };
@@ -85,10 +94,14 @@ async function runCleanup(actions: CleanupAction[]): Promise<void> {
 
 describe("messaging provider installed-runtime proofs", () => {
   it.each([
-    ["discord-gateway", ["127.0.0.1::8080"], ["8080/tcp"]],
-    ["slack", ["127.0.0.1::8080", "127.0.0.1::8081"], ["8080/tcp", "8081/tcp"]],
+    ["discord-gateway", [`${OPENSHELL_BRIDGE_ADDRESS}::8080`], ["8080/tcp"]],
+    [
+      "slack",
+      [`${OPENSHELL_BRIDGE_ADDRESS}::8080`, `${OPENSHELL_BRIDGE_ADDRESS}::8081`],
+      ["8080/tcp", "8081/tcp"],
+    ],
   ] as const)(
-    "proxies the isolated fake %s API through loopback-only ephemeral ports",
+    "proxies the isolated fake %s API through OpenShell-bridge ephemeral ports",
     async (kind, expectedPublications, expectedPortQueries) => {
       const { calls, host } = fakeDockerHost();
       const cleanup: CleanupAction[] = [];
@@ -118,6 +131,7 @@ describe("messaging provider installed-runtime proofs", () => {
           argument === "-p" ? [proxyRun[index + 1]] : [],
         );
 
+        expect(calls).toContainEqual(["network", "inspect", "openshell-docker"]);
         expect(createdNetwork.slice(0, -1)).toEqual(["network", "create", "--internal"]);
         expect(apiRun).toEqual(expect.arrayContaining(["--network", network]));
         expect(apiRun).not.toContain("-p");
@@ -137,7 +151,7 @@ describe("messaging provider installed-runtime proofs", () => {
     },
   );
 
-  it("rejects a fake API proxy port that Docker publishes beyond loopback", async () => {
+  it("rejects a fake API proxy port that Docker publishes beyond the OpenShell bridge", async () => {
     const { host } = fakeDockerHost("0.0.0.0");
     const cleanup: CleanupAction[] = [];
 
@@ -154,7 +168,7 @@ describe("messaging provider installed-runtime proofs", () => {
           redactionValues: [],
           env: {},
         }),
-      ).rejects.toThrow(/did not bind only to 127\.0\.0\.1/u);
+      ).rejects.toThrow(/did not bind only to the OpenShell bridge/u);
     } finally {
       await runCleanup(cleanup);
     }