@norskvideo/ctl-test-harness 0.1.10 → 0.1.12

package/launch.d.ts

@@ -12,13 +12,15 @@ export declare function withContainerUser<T>(opts: T & {
 }): T & {
     containerUser?: string;
 };
-/** True when the resolved norsk-ctl CLI understands `--no-publish`. Memoised. */
+/** 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 (`noPublish`) so
- *  concurrent instances on a shared runner can't collide on the product's
+/** 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 `noPublish` pass
- *  through untouched. Async because the capability probe is. */
-export declare function withNoPublish<T extends {
-    noPublish?: boolean;
-}>(opts: T): Promise<T>;
+ *  {@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

@@ -32,15 +32,18 @@ export function withContainerUser(opts) {
     const user = runnerContainerUser();
     return user === undefined ? opts : { ...opts, containerUser: user };
 }
-// The CLI is `.strict()`, so passing `--no-publish` to a norsk-ctl that predates
-// the flag aborts the launch with "Unknown argument". 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. On an old
-// ctl this silently no-ops (publish as today); when `latest` catches up the same
-// harness starts binding no host ports — no cross-repo release ordering to get
-// right. Cached: one `--help` spawn per process.
-let noPublishSupport;
-async function probeNoPublishSupport() {
+// 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",
@@ -48,24 +51,24 @@ async function probeNoPublishSupport() {
         });
         const [out, errText] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
         await proc.exited;
-        return `${out}${errText}`.includes("--no-publish");
+        return `${out}${errText}`.includes(INTERNAL_ONLY_FLAG);
     }
     catch {
         return false;
     }
 }
-/** True when the resolved norsk-ctl CLI understands `--no-publish`. Memoised. */
+/** True when the resolved norsk-ctl CLI understands `--internal-only`. Memoised. */
 export function ctlSupportsNoPublish() {
-    noPublishSupport ??= probeNoPublishSupport();
-    return noPublishSupport;
+    internalOnlySupport ??= probeInternalOnlySupport();
+    return internalOnlySupport;
 }
-/** In `direct` reach mode, ask the daemon to bind no host ports (`noPublish`) so
- *  concurrent instances on a shared runner can't collide on the product's
+/** 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 `noPublish` pass
- *  through untouched. Async because the capability probe is. */
+ *  {@link ctlSupportsNoPublish}). `publish` mode and an explicit `internalOnly`
+ *  pass through untouched. Async because the capability probe is. */
 export async function withNoPublish(opts) {
-    if (opts.noPublish !== undefined || netReachMode() !== "direct")
+    if (opts.internalOnly !== undefined || netReachMode() !== "direct")
         return opts;
-    return (await ctlSupportsNoPublish()) ? { ...opts, noPublish: true } : opts;
+    return (await ctlSupportsNoPublish()) ? { ...opts, internalOnly: true } : opts;
 }

package/package.json

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