@norskvideo/ctl-test-harness 0.1.9 → 0.1.11

package/container-net.js

@@ -1,6 +1,8 @@
 // Reach launched product instances by their norsk-net service DNS instead of a
-// host-published port. PROTOTYPE for dissolving the cross-product host-port
-// collision the release gate trips on.
+// host-published port. Dissolves the cross-product host-port collision the
+// release gate trips on. Consumed by the playout, funke, and commentary
+// integration harnesses (studioApiBase / mediaHttpBase / srtEgressUrl /
+// studioBaseFrom); commentary's WHIP path already reaches media directly.
 //
 // WHY host ports collide: in the docker-outside-of-docker CI runner the test
 // process is itself a container and studio/media run as HOST-sibling containers,

package/launch.d.ts

@@ -12,3 +12,15 @@ export declare function withContainerUser<T>(opts: T & {
 }): T & {
     containerUser?: string;
 };
+/** True when the resolved norsk-ctl CLI understands `--internal-only`. Memoised. */
+export declare function ctlSupportsNoPublish(): 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
+ *  {@link ctlSupportsNoPublish}). `publish` mode and an explicit `internalOnly`
+ *  pass through untouched. Async because the capability probe is. */
+export declare function withNoPublish<T>(opts: T & {
+    internalOnly?: boolean;
+}): Promise<T & {
+    internalOnly?: boolean;
+}>;

package/launch.js

@@ -9,6 +9,8 @@
 // This is the prevention half; @norskvideo/ctl-test-harness/daemon's
 // cleanupDaemon is the tolerance half (root-nuke on teardown). Pairing the two
 // is the harness's whole "launch clean, tear down clean" story.
+import { cliCommand } from "./cli-command.js";
+import { netReachMode } from "./container-net.js";
 /** The `uid:gid` the current process runs as, for docker `--container-user`, or
  *  undefined where POSIX uids don't exist (e.g. Windows, or Docker Desktop's VM
  *  which maps bind-mount ownership itself and needs no explicit spec). */
@@ -30,3 +32,43 @@ export function withContainerUser(opts) {
     const user = runnerContainerUser();
     return user === undefined ? opts : { ...opts, containerUser: user };
 }
+// The launch flag is `--internal-only`, NOT `--no-publish`: yargs reads a `--no-`
+// prefix as boolean negation of a `publish` option and, under `.strict()`, aborts
+// with "Unknown argument: publish". The CLI is also `.strict()` about unknown
+// flags, so a ctl that predates `--internal-only` would reject it too — a newer
+// product must still launch on an older ctl (the contract's whole additive rule).
+// So we probe the resolved binary once and only emit the flag when it advertises
+// it: a no-op on an old ctl (publish as today), self-upgrading when `latest`
+// 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() {
+    try {
+        const proc = Bun.spawn([...cliCommand, "instance", "launch-template", "--help"], {
+            stdout: "pipe",
+            stderr: "pipe",
+        });
+        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);
+    }
+    catch {
+        return false;
+    }
+}
+/** True when the resolved norsk-ctl CLI understands `--internal-only`. Memoised. */
+export function ctlSupportsNoPublish() {
+    internalOnlySupport ??= probeInternalOnlySupport();
+    return internalOnlySupport;
+}
+/** 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
+ *  {@link ctlSupportsNoPublish}). `publish` mode and an explicit `internalOnly`
+ *  pass through untouched. Async because the capability probe is. */
+export async function withNoPublish(opts) {
+    if (opts.internalOnly !== undefined || netReachMode() !== "direct")
+        return opts;
+    return (await ctlSupportsNoPublish()) ? { ...opts, internalOnly: true } : opts;
+}

package/package.json

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