@norskvideo/ctl-test-harness 0.1.18 → 0.1.19

package/daemon.d.ts

@@ -6,6 +6,15 @@ export { makeStoreDir, makeTempDir, pollUntil, TEST_TMP_BASE };
 export declare function requireLicenseFile(opts?: {
     missing?: "exit" | "throw";
 }): string;
+/** What a caller sees when the CLI itself cannot be started: in a product
+ *  repo outside its nix shell nothing resolves (cli-command.ts), and spawn's
+ *  ENOENT must read as one line, not an uncaught 'error' event. */
+export declare function cliUnavailableMessage(command: readonly string[], cause: string): string;
+export declare function runCliWith(command: readonly string[], storeDir: string, ...args: string[]): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}>;
 export declare function runCli(storeDir: string, ...args: string[]): Promise<{
     stdout: string;
     stderr: string;

package/daemon.js

@@ -50,17 +50,30 @@ export function requireLicenseFile(opts = {}) {
     }
     return licenseFile;
 }
-export async function runCli(storeDir, ...args) {
+/** What a caller sees when the CLI itself cannot be started: in a product
+ *  repo outside its nix shell nothing resolves (cli-command.ts), and spawn's
+ *  ENOENT must read as one line, not an uncaught 'error' event. */
+export function cliUnavailableMessage(command, cause) {
+    return `could not run ${command.join(" ")}: ${cause} — set NORSK_CTL_BINARY to a norsk-ctl binary, or run inside the product's \`nix develop .#dev\` shell, which puts the pinned release on PATH`;
+}
+export async function runCliWith(command, storeDir, ...args) {
     return new Promise((res) => {
-        const [cmd, ...cmdArgs] = cliCommand;
+        const [cmd, ...cmdArgs] = command;
         const proc = spawn(cmd, [...cmdArgs, ...args], {
             env: { ...process.env, NORSK_CTL_STORE_DIR: storeDir },
         });
         const stdout = [];
         const stderr = [];
+        let failed = false;
         proc.stdout.on("data", (d) => stdout.push(d));
         proc.stderr.on("data", (d) => stderr.push(d));
+        proc.on("error", (e) => {
+            failed = true;
+            res({ stdout: "", stderr: cliUnavailableMessage(command, e.message), exitCode: 127 });
+        });
         proc.on("close", (code) => {
+            if (failed)
+                return;
             res({
                 stdout: Buffer.concat(stdout).toString(),
                 stderr: Buffer.concat(stderr).toString(),
@@ -69,6 +82,9 @@ export async function runCli(storeDir, ...args) {
         });
     });
 }
+export async function runCli(storeDir, ...args) {
+    return runCliWith(cliCommand, storeDir, ...args);
+}
 export function isPortFree(port) {
     return new Promise((resolve) => {
         const srv = createServer();
@@ -127,14 +143,20 @@ export function startDaemon(storeDir, options) {
         detached: options?.detached === true,
         env: { ...process.env, NORSK_CTL_STORE_DIR: storeDir, NORSK_CTL_PORT: String(port), ...options?.env },
     });
-    const ready = pollUntil(async () => {
-        const res = await fetch(`http://localhost:${port}/api/ready`, { signal: AbortSignal.timeout(1000) });
-        return res.ok;
-    }, {
-        timeoutMs: options?.readyTimeoutMs ?? DAEMON_READY_TIMEOUT_MS,
-        intervalMs: 500,
-        label: "Daemon did not become ready",
+    const spawnFailed = new Promise((_, reject) => {
+        proc.once("error", (e) => reject(new Error(cliUnavailableMessage(cliCommand, e.message))));
     });
+    const ready = Promise.race([
+        spawnFailed,
+        pollUntil(async () => {
+            const res = await fetch(`http://localhost:${port}/api/ready`, { signal: AbortSignal.timeout(1000) });
+            return res.ok;
+        }, {
+            timeoutMs: options?.readyTimeoutMs ?? DAEMON_READY_TIMEOUT_MS,
+            intervalMs: 500,
+            label: "Daemon did not become ready",
+        }),
+    ]);
     return { daemon: daemonHandle(proc), ready };
 }
 function runningContainers(names) {

package/demo/cli.js

@@ -91,7 +91,7 @@ export function resolvedSpecView(spec, opts) {
         if ("control" in ref)
             return `http://localhost:${ports.backendPort}${ref.control}`;
         if ("proxy" in ref)
-            return `https://localhost:${ports.proxyPort}${ref.proxy.replaceAll("{id}", instanceId)}`;
+            return `http://localhost:${ports.proxyPort}${ref.proxy.replaceAll("{id}", instanceId)}`;
         return `http://localhost:${studioHostPort}${ref.studio}`;
     };
     const t = spec.template;

package/demo/index.d.ts

@@ -1,6 +1,6 @@
 export type { DemoArgs, DemoCliIo, ResolvedSpecView } from "./cli.js";
 export { defaultDemoCliIo, demoMain, parseDemoArgs, resolvedSpecView } from "./cli.js";
 export type { CliResult, DemoDeps, DemoPorts, DemoRunOptions, DemoRunResult, DemoState, DemoStateStore, DemoTimeouts, ExportCheckOptions, IngestPortRow, ProcessHandle, TemplateParams, } from "./run.js";
-export { defaultDemoDeps, demoDown, demoPorts, demoSlug, expandHome, fileStateStore, findBrokenSymlinks, resolveIngestPort, runDemo, runExportCheck, } from "./run.js";
+export { defaultDemoDeps, demoDown, demoPorts, demoSlug, expandHome, fileStateStore, findBrokenSymlinks, killGroup, resolveIngestPort, runDemo, runExportCheck, } from "./run.js";
 export type { DemoContext, DemoIngest, DemoOpen, DemoReady, DemoSource, DemoSpec, DemoTemplate, DemoUrl, } from "./spec.js";
 export { DemoSpecSchema, defineDemo, formatSpecIssues } from "./spec.js";

package/demo/index.js

@@ -1,3 +1,3 @@
 export { defaultDemoCliIo, demoMain, parseDemoArgs, resolvedSpecView } from "./cli.js";
-export { defaultDemoDeps, demoDown, demoPorts, demoSlug, expandHome, fileStateStore, findBrokenSymlinks, resolveIngestPort, runDemo, runExportCheck, } from "./run.js";
+export { defaultDemoDeps, demoDown, demoPorts, demoSlug, expandHome, fileStateStore, findBrokenSymlinks, killGroup, resolveIngestPort, runDemo, runExportCheck, } from "./run.js";
 export { DemoSpecSchema, defineDemo, formatSpecIssues } from "./spec.js";

package/demo/run.d.ts

@@ -138,6 +138,9 @@ export declare function findBrokenSymlinks(dir: string): string[];
 /** `<cwd>/test-temp/demo/<product>.json` — beside the store dirs, inside the
  *  consumer's repo, where `down` from another shell can find it. */
 export declare function fileStateStore(cwd: string): DemoStateStore;
+/** SIGTERM a process group (a pid startProcess spawned detached leads its
+ *  own), falling back to the pid alone if it is not a group leader. */
+export declare function killGroup(pid: number): void;
 export declare function defaultDemoDeps(cwd: string): DemoDeps;
 export declare function runDemo(spec: DemoSpec, opts: DemoRunOptions, deps?: DemoDeps): Promise<DemoRunResult>;
 export interface ExportCheckOptions {

package/demo/run.js

@@ -170,6 +170,19 @@ export function fileStateStore(cwd) {
         remove: (product) => rmSync(path(product), { force: true }),
     };
 }
+/** SIGTERM a process group (a pid startProcess spawned detached leads its
+ *  own), falling back to the pid alone if it is not a group leader. */
+export function killGroup(pid) {
+    try {
+        process.kill(-pid, "SIGTERM");
+        return;
+    }
+    catch { }
+    try {
+        process.kill(pid, "SIGTERM");
+    }
+    catch { }
+}
 export function defaultDemoDeps(cwd) {
     return {
         licenseFile: () => requireLicenseFile({ missing: "throw" }),
@@ -187,17 +200,25 @@ export function defaultDemoDeps(cwd) {
             }
         },
         cli: (storeDir, argv) => runCli(storeDir, ...argv),
+        // The dev command is a tree (`bun run dev` = concurrently -> bun run
+        // --watch -> ...), so it gets its own process group and the group is what
+        // dies: a SIGTERM to the parent alone left the watcher alive after `down`.
         startProcess: (command, opts) => {
             const [cmd, ...args] = command;
-            const proc = spawn(cmd, args, { cwd: opts.cwd, stdio: "inherit", env: { ...process.env, ...opts.env } });
+            const proc = spawn(cmd, args, {
+                cwd: opts.cwd,
+                stdio: "inherit",
+                detached: true,
+                env: { ...process.env, ...opts.env },
+            });
             const exited = new Promise((res) => proc.once("exit", (code) => res(code)));
             return {
                 pid: proc.pid,
                 kill: () => {
-                    try {
+                    if (proc.pid !== undefined)
+                        killGroup(proc.pid);
+                    else
                         proc.kill("SIGTERM");
-                    }
-                    catch { }
                 },
                 exited,
             };
@@ -240,12 +261,7 @@ export function defaultDemoDeps(cwd) {
                 process.once("SIGTERM", release);
             }
         }),
-        killPid: (pid) => {
-            try {
-                process.kill(pid, "SIGTERM");
-            }
-            catch { }
-        },
+        killPid: killGroup,
         log: (line) => console.log(`[demo] ${line}`),
     };
 }
@@ -416,8 +432,10 @@ function urlResolver(o) {
             return ref.url;
         if ("control" in ref)
             return `http://localhost:${o.ports.backendPort}${ref.control}`;
+        // The private daemon is initialised without a cert source, so its proxy
+        // speaks plain http (reuse mode, 05-demo s7 step 2, will read the real one).
         if ("proxy" in ref)
-            return `https://${host}:${o.ports.proxyPort}${ref.proxy.replaceAll("{id}", o.instanceId)}`;
+            return `http://${host}:${o.ports.proxyPort}${ref.proxy.replaceAll("{id}", o.instanceId)}`;
         return `${studioBaseFrom({ instanceId: o.instanceId, studioHostPort: o.studioHostPort }, host, mode)}${ref.studio}`;
     };
 }

package/package.json

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