@norskvideo/ctl-test-harness 0.1.49 → 0.1.51

package/demo/harness.js

@@ -14,6 +14,7 @@
 // program SRT listener, an HLS ladder), its config-schema port remap for a
 // built template, and whatever sidecar its output points at.
 import { netReachMode, STUDIO_INTERNAL_PORT, studioBaseFrom } from "../container-net.js";
+import { ctlSupportsPublishDebugPorts } from "../launch.js";
 import { pollUntil } from "../poll.js";
 import { DemoGateFailure } from "./gates.js";
 import { DemoSession, defaultDemoDeps, demoSlug, expandHome, resolveIngestPort, } from "./run.js";
@@ -146,6 +147,18 @@ export class ProductHarness {
             launchArgv.push("--container-user", user);
         if (internalOnly)
             launchArgv.push("--internal-only");
+        // ctl binds a product's studio host port to 127.0.0.1. Every gate that
+        // fetches it names `s.host` — "the host every printed URL names" — so a
+        // non-loopback host is the harness's own statement that it will reach that
+        // port from elsewhere: a reused host-sibling daemon over the host-gateway
+        // alias, or an explicit --public-host. Derived from the host already
+        // computed rather than a second thing for a demo spec to remember to set,
+        // and probed because the CLI is `.strict()` and a released ctl predating
+        // the flag would abort the launch.
+        else if (s.host !== "localhost" && (await (deps.supportsPublishDebugPorts ?? ctlSupportsPublishDebugPorts)())) {
+            launchArgv.push("--publish-debug-ports");
+            deps.log(`studio host port re-opened on every interface for ${s.host} (--publish-debug-ports)`);
+        }
         if (!this.launchedIds.includes(instanceId))
             this.launchedIds.push(instanceId);
         // The whole list each time, not an append: idempotent, and readable by

package/demo/run.d.ts

@@ -85,6 +85,9 @@ export interface DemoDeps {
     storeExists(storeDir: string): boolean;
     ensureNetwork(): ReturnType<typeof ensureRunnerOnNetwork>;
     supportsNoPublish(): Promise<boolean>;
+    /** Does the resolved ctl advertise `--publish-debug-ports`? Optional so an
+     *  existing custom-deps consumer keeps working; absent = probe the CLI. */
+    supportsPublishDebugPorts?(): Promise<boolean>;
     containerUser(): string | undefined;
     /** Symlinks under an exported workdir whose target does not exist, as
      *  `<link> -> <target>` lines. */

package/demo/run.js

@@ -32,7 +32,7 @@ import { parseManifestSeed, repoOf } from "@norskvideo/ctl-sdk/manifest-seed";
 import { DOCKER_NETWORK_NAME, ensureRunnerOnNetwork, netReachMode } from "../container-net.js";
 import { cleanupDaemon, requireLicenseFile, runCli, startDaemon, } from "../daemon.js";
 import { hashSlot } from "../harness-config.js";
-import { ctlSupportsNoPublish, runnerContainerUser } from "../launch.js";
+import { ctlSupportsNoPublish, ctlSupportsPublishDebugPorts, runnerContainerUser } from "../launch.js";
 import { pollUntil } from "../poll.js";
 import { nukePathAsRoot, reportForeignOwners } from "../root-nuke.js";
 import { startSrtSources } from "../source-pump.js";
@@ -300,6 +300,7 @@ export function defaultDemoDeps(cwd) {
         storeExists: (storeDir) => existsSync(storeDir),
         ensureNetwork: () => ensureRunnerOnNetwork(),
         supportsNoPublish: ctlSupportsNoPublish,
+        supportsPublishDebugPorts: ctlSupportsPublishDebugPorts,
         containerUser: runnerContainerUser,
         brokenSymlinks: findBrokenSymlinks,
         state: fileStateStore(cwd),

package/launch.d.ts

@@ -14,6 +14,13 @@ export declare function withContainerUser<T>(opts: T & {
 };
 /** True when the resolved norsk-ctl CLI understands `--internal-only`. Memoised. */
 export declare function ctlSupportsNoPublish(): Promise<boolean>;
+/** True when the resolved norsk-ctl CLI understands `--publish-debug-ports` —
+ *  the flag that keeps a product's studio host port on every interface, which a
+ *  harness reaching it from another host needs. Same probe for the same reason
+ *  as `--internal-only` above: a released ctl that predates the flag would abort
+ *  the launch under `.strict()`, and products pin a RELEASED ctl while picking
+ *  the harness up separately, so the two versions genuinely diverge. */
+export declare function ctlSupportsPublishDebugPorts(): Promise<boolean>;
 /** In `direct` reach mode, ask the daemon to bind no host ports (`internalOnly`)
  *  so concurrent instances on a shared runner can't collide on the product's
  *  host-port bands — but only when the resolved ctl supports the flag (see

package/launch.js

@@ -42,8 +42,9 @@ export function withContainerUser(opts) {
 // catches up — no cross-repo release ordering to get right. Cached: one `--help`
 // spawn per process.
 const INTERNAL_ONLY_FLAG = "--internal-only";
-let internalOnlySupport;
-async function probeInternalOnlySupport() {
+const PUBLISH_DEBUG_PORTS_FLAG = "--publish-debug-ports";
+const flagSupport = new Map();
+async function probeFlagSupport(flag) {
     try {
         const proc = Bun.spawn([...cliCommand, "instance", "launch-template", "--help"], {
             stdout: "pipe",
@@ -51,16 +52,34 @@ async function probeInternalOnlySupport() {
         });
         const [out, errText] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
         await proc.exited;
-        return `${out}${errText}`.includes(INTERNAL_ONLY_FLAG);
+        return `${out}${errText}`.includes(flag);
     }
     catch {
         return false;
     }
 }
+/** True when the resolved norsk-ctl CLI advertises `flag` in its launch help.
+ *  Memoised per flag: one `--help` spawn each, however many callers ask. */
+function ctlSupportsFlag(flag) {
+    const cached = flagSupport.get(flag);
+    if (cached)
+        return cached;
+    const probe = probeFlagSupport(flag);
+    flagSupport.set(flag, probe);
+    return probe;
+}
 /** True when the resolved norsk-ctl CLI understands `--internal-only`. Memoised. */
 export function ctlSupportsNoPublish() {
-    internalOnlySupport ??= probeInternalOnlySupport();
-    return internalOnlySupport;
+    return ctlSupportsFlag(INTERNAL_ONLY_FLAG);
+}
+/** True when the resolved norsk-ctl CLI understands `--publish-debug-ports` —
+ *  the flag that keeps a product's studio host port on every interface, which a
+ *  harness reaching it from another host needs. Same probe for the same reason
+ *  as `--internal-only` above: a released ctl that predates the flag would abort
+ *  the launch under `.strict()`, and products pin a RELEASED ctl while picking
+ *  the harness up separately, so the two versions genuinely diverge. */
+export function ctlSupportsPublishDebugPorts() {
+    return ctlSupportsFlag(PUBLISH_DEBUG_PORTS_FLAG);
 }
 /** In `direct` reach mode, ask the daemon to bind no host ports (`internalOnly`)
  *  so concurrent instances on a shared runner can't collide on the product's

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@norskvideo/ctl-test-harness",
-  "version": "0.1.49",
+  "version": "0.1.51",
   "type": "module",
   "exports": {
     ".": {

package/smoke.d.ts

@@ -142,6 +142,9 @@ export interface SmokeDeps {
     storeExists(storeDir: string): boolean;
     ensureNetwork(): ReturnType<typeof ensureRunnerOnNetwork>;
     supportsNoPublish(): Promise<boolean>;
+    /** Does the resolved ctl advertise `--publish-debug-ports`? Optional so an
+     *  existing custom-deps consumer keeps working; absent = probe the CLI. */
+    supportsPublishDebugPorts?(): Promise<boolean>;
     containerUser(): string | undefined;
     /** Diagnostic dump for a satisfied-phase timeout, taken while the instance
      *  is still up. Optional so an existing custom-deps consumer keeps working;

package/smoke.js

@@ -23,7 +23,7 @@ import { dumpInstanceContainerLogs, preserveEngineLogs } from "./container-logs.
 import { ensureRunnerOnNetwork, netReachMode, STUDIO_INTERNAL_PORT, studioBaseFrom, } from "./container-net.js";
 import { cleanupDaemon, requireLicenseFile, runCli, startDaemon, } from "./daemon.js";
 import { hashSlot } from "./harness-config.js";
-import { ctlSupportsNoPublish, runnerContainerUser } from "./launch.js";
+import { ctlSupportsNoPublish, ctlSupportsPublishDebugPorts, runnerContainerUser } from "./launch.js";
 import { pollUntil } from "./poll.js";
 import { nukePathAsRoot, reportForeignOwners } from "./root-nuke.js";
 import { startSrtSources } from "./source-pump.js";
@@ -72,6 +72,7 @@ export const defaultSmokeDeps = {
     storeExists: (storeDir) => existsSync(storeDir),
     ensureNetwork: () => ensureRunnerOnNetwork(),
     supportsNoPublish: ctlSupportsNoPublish,
+    supportsPublishDebugPorts: ctlSupportsPublishDebugPorts,
     containerUser: runnerContainerUser,
     diagnose: (instanceId) => dumpInstanceContainerLogs(instanceId),
     fetchProductRoute: async ({ daemonPort, product, route, storeDir }) => {
@@ -328,6 +329,15 @@ export async function runProductSmoke(slug, spec, deps = defaultSmokeDeps) {
             launchArgv.push("--container-user", user);
         if (internalOnly)
             launchArgv.push("--internal-only");
+        // ctl binds a product's OPERATOR compose ports (STUDIO_HOST_PORT among
+        // them) to 127.0.0.1. `fetchStudio` dials NORSK_TEST_HOST in publish mode;
+        // when that is not loopback the test process is a container reaching a host
+        // sibling, which a loopback bind refuses. Derived from the host the
+        // fetchers already use rather than a second thing to configure.
+        else if ((process.env.NORSK_TEST_HOST ?? "localhost") !== "localhost" &&
+            (await (deps.supportsPublishDebugPorts ?? ctlSupportsPublishDebugPorts)())) {
+            launchArgv.push("--publish-debug-ports");
+        }
         launched = true;
         await cliOk(launchArgv);
         await pollUntil(async () => {