@unbrained/pm-cli 2026.7.1 → 2026.7.2

package/dist/core/test/background-runs.js

@@ -4,7 +4,7 @@
  * Runs and records linked-test orchestration for Background Runs.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="831e5e73-7cc7-5703-981e-784a2fef0e81")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="aefbe330-eaa9-5b52-a406-b796df6bff8b")}catch(e){}}();
 import fs from "node:fs/promises";
 import { spawn } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
@@ -453,6 +453,148 @@ async function appendFileOrdered(queue, filePath, text) {
     await queue;
     await fs.appendFile(filePath, text, "utf8");
 }
+function resolvePositiveEnvInteger(name, fallback) {
+    const parsed = Number.parseInt(process.env[name] ?? "", 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function buildBackgroundWorkerEnv(record) {
+    return {
+        ...process.env,
+        PM_PATH: record.pm_root,
+        PM_GLOBAL_PATH: record.global_pm_root,
+        FORCE_COLOR: "0",
+    };
+}
+function buildBackgroundWorkerChildArgs(record, noExtensions) {
+    return noExtensions ? ["--no-extensions", ...record.command_args] : [...record.command_args];
+}
+function createBackgroundRunRecordWriteScheduler(pmRoot, record) {
+    let writeQueue = Promise.resolve();
+    return {
+        schedule() {
+            writeQueue = writeQueue.then(async () => {
+                try {
+                    await writeBackgroundRunRecord(pmRoot, record);
+                }
+                catch {
+                    // Keep worker alive even if a single metadata write fails.
+                }
+            });
+        },
+        async flush() {
+            await writeQueue;
+        },
+    };
+}
+function requestChildSignal(child, signal) {
+    try {
+        child.kill(signal);
+    }
+    catch {
+        // Child may already be gone.
+    }
+}
+async function requestBackgroundWorkerStop(record, child, state, scheduleRecordWrite) {
+    if (state.stopRequested) {
+        return;
+    }
+    state.stopRequested = true;
+    record.stop_requested_at = nowIso();
+    record.progress = {
+        ...record.progress,
+        phase: "stopping",
+        message: "Stop requested for background run.",
+        heartbeat_at: nowIso(),
+    };
+    scheduleRecordWrite();
+    requestChildSignal(child, "SIGTERM");
+    const forceTimer = setTimeout(() => requestChildSignal(child, "SIGKILL"), resolvePositiveEnvInteger("PM_BACKGROUND_RUN_FORCE_KILL_DELAY_MS", DEFAULT_BACKGROUND_RUN_FORCE_KILL_DELAY_MS));
+    forceTimer.unref?.();
+}
+function buildItemBackgroundProgress(line, progressPatch, phase) {
+    return {
+        phase,
+        message: line,
+        heartbeat_at: nowIso(),
+        item_index: progressPatch.item_index,
+        item_total: progressPatch.item_total,
+        item_id: progressPatch.item_id,
+        linked_test_index: undefined,
+        linked_test_total: undefined,
+        current_command: undefined,
+        elapsed_ms: undefined,
+    };
+}
+function buildLinkedTestBackgroundProgress(line, record, progressPatch, phase) {
+    return {
+        phase,
+        message: line,
+        heartbeat_at: nowIso(),
+        item_index: progressPatch.item_index ?? record.progress?.item_index,
+        item_total: progressPatch.item_total ?? record.progress?.item_total,
+        item_id: progressPatch.item_id ?? record.progress?.item_id,
+        linked_test_index: progressPatch.linked_test_index,
+        linked_test_total: progressPatch.linked_test_total,
+        current_command: progressPatch.current_command,
+        elapsed_ms: progressPatch.elapsed_ms,
+    };
+}
+function applyBackgroundWorkerProgressLine(record, line, stopRequested) {
+    const progressPatch = parseProgressLine(line);
+    if (!progressPatch) {
+        return false;
+    }
+    const phase = record.progress?.phase === "stopping" ? "stopping" : "running";
+    record.progress = progressPatch.item_id
+        ? buildItemBackgroundProgress(line, progressPatch, phase)
+        : buildLinkedTestBackgroundProgress(line, record, progressPatch, phase);
+    if (progressPatch.phase === "finished" && !stopRequested) {
+        record.progress.phase = "running";
+    }
+    return true;
+}
+function parseBackgroundWorkerStdout(stdoutBuffer) {
+    if (stdoutBuffer.trim().length === 0) {
+        return null;
+    }
+    try {
+        return JSON.parse(stdoutBuffer);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveBackgroundWorkerFinalStatus(record, stopRequested) {
+    if (stopRequested) {
+        return "stopped";
+    }
+    const passed = record.exit_code === 0 && (record.summary?.failed ?? 0) === 0 && record.summary?.fail_on_skipped_triggered !== true;
+    return passed ? "passed" : "failed";
+}
+function buildFinishedBackgroundProgress(record, stopRequested) {
+    return {
+        phase: "finished",
+        message: stopRequested ? "Background run stopped." : `Background run finished with status=${record.status}.`,
+        heartbeat_at: nowIso(),
+        item_index: record.progress?.item_index,
+        item_total: record.progress?.item_total,
+        item_id: record.progress?.item_id,
+        linked_test_index: record.progress?.linked_test_index,
+        linked_test_total: record.progress?.linked_test_total,
+        current_command: record.progress?.current_command,
+        elapsed_ms: record.progress?.elapsed_ms,
+    };
+}
+async function writeBackgroundWorkerResult(record, parsedResult, stdoutBuffer) {
+    if (parsedResult !== null) {
+        await writeFileAtomic(record.result_path, `${JSON.stringify(parsedResult, null, 2)}\n`);
+        return;
+    }
+    await writeFileAtomic(record.result_path, `${JSON.stringify({
+        parse_error: "Background run output was not valid JSON.",
+        stdout_excerpt: tailLines(stdoutBuffer, DEFAULT_BACKGROUND_RUN_LOG_TAIL_LINES),
+    }, null, 2)}\n`);
+}
 /**
  * Implements run background test run worker for the public runtime surface of this module.
  */
@@ -473,14 +615,9 @@ export async function runBackgroundTestRunWorker(pmRoot, runId, noExtensions = f
         },
     };
     const cliEntry = await resolveBackgroundCliEntry(process.cwd());
-    const env = {
-        ...process.env,
-        PM_PATH: record.pm_root,
-        PM_GLOBAL_PATH: record.global_pm_root,
-        FORCE_COLOR: "0",
-    };
+    const env = buildBackgroundWorkerEnv(record);
     await writeBackgroundRunRecord(pmRoot, record);
-    const childArgs = noExtensions ? ["--no-extensions", ...record.command_args] : [...record.command_args];
+    const childArgs = buildBackgroundWorkerChildArgs(record, noExtensions);
     const child = spawn(process.execPath, [cliEntry, ...childArgs], {
         cwd: process.cwd(),
         env,
@@ -489,114 +626,31 @@ export async function runBackgroundTestRunWorker(pmRoot, runId, noExtensions = f
         windowsHide: true,
     });
     record.child_pid = child.pid;
-    let writeQueue = Promise.resolve();
-    const scheduleRecordWrite = () => {
-        writeQueue = writeQueue.then(async () => {
-            try {
-                await writeBackgroundRunRecord(pmRoot, record);
-            }
-            catch {
-                // Keep worker alive even if a single metadata write fails.
-            }
-        });
-    };
+    const recordWriteScheduler = createBackgroundRunRecordWriteScheduler(pmRoot, record);
+    const scheduleRecordWrite = recordWriteScheduler.schedule;
     let stdoutWriteQueue = Promise.resolve();
     let stderrWriteQueue = Promise.resolve();
     let stdoutBuffer = "";
     let stderrBuffer = "";
-    let stopRequested = false;
-    const requestStop = async () => {
-        if (stopRequested) {
-            return;
-        }
-        stopRequested = true;
-        record.stop_requested_at = nowIso();
-        record.progress = {
-            ...record.progress,
-            phase: "stopping",
-            message: "Stop requested for background run.",
-            heartbeat_at: nowIso(),
-        };
-        scheduleRecordWrite();
-        try {
-            child.kill("SIGTERM");
-        }
-        catch {
-            // Child may already be gone.
-        }
-        const forceKillDelayMs = Number.parseInt(process.env.PM_BACKGROUND_RUN_FORCE_KILL_DELAY_MS ?? "", 10);
-        const delay = Number.isFinite(forceKillDelayMs) && forceKillDelayMs > 0
-            ? forceKillDelayMs
-            : DEFAULT_BACKGROUND_RUN_FORCE_KILL_DELAY_MS;
-        const forceTimer = setTimeout(() => {
-            try {
-                child.kill("SIGKILL");
-            }
-            catch {
-                // Child may already be gone.
-            }
-        }, delay);
-        forceTimer.unref?.();
-    };
+    const stopState = { stopRequested: false };
     const onSignal = () => {
-        void requestStop();
+        void requestBackgroundWorkerStop(record, child, stopState, scheduleRecordWrite);
     };
     process.on("SIGTERM", onSignal);
     process.on("SIGINT", onSignal);
-    const resourceIntervalMs = Number.parseInt(process.env.PM_BACKGROUND_RUN_RESOURCE_INTERVAL_MS ?? "", 10);
-    const resourceInterval = Number.isFinite(resourceIntervalMs) && resourceIntervalMs > 0
-        ? resourceIntervalMs
-        : DEFAULT_BACKGROUND_RUN_RESOURCE_SNAPSHOT_INTERVAL_MS;
     const resourceTimer = setInterval(() => {
         void (async () => {
             record.resource = await buildResourceSnapshot(record);
             record.progress.heartbeat_at = nowIso();
             scheduleRecordWrite();
         })();
-    }, resourceInterval);
+    }, resolvePositiveEnvInteger("PM_BACKGROUND_RUN_RESOURCE_INTERVAL_MS", DEFAULT_BACKGROUND_RUN_RESOURCE_SNAPSHOT_INTERVAL_MS));
     resourceTimer.unref?.();
     child.stdout?.on("data", (chunk) => {
         const text = chunk.toString("utf8");
         stdoutBuffer += text;
         stdoutWriteQueue = appendFileOrdered(stdoutWriteQueue, record.stdout_path, text);
     });
-    const applyProgressLine = (line) => {
-        const progressPatch = parseProgressLine(line);
-        if (!progressPatch) {
-            return false;
-        }
-        if (progressPatch.item_id) {
-            record.progress = {
-                phase: record.progress.phase === "stopping" ? "stopping" : "running",
-                message: line,
-                heartbeat_at: nowIso(),
-                item_index: progressPatch.item_index,
-                item_total: progressPatch.item_total,
-                item_id: progressPatch.item_id,
-                linked_test_index: undefined,
-                linked_test_total: undefined,
-                current_command: undefined,
-                elapsed_ms: undefined,
-            };
-            return true;
-        }
-        record.progress = {
-            phase: record.progress.phase === "stopping" ? "stopping" : "running",
-            message: line,
-            heartbeat_at: nowIso(),
-            item_index: progressPatch.item_index ?? record.progress?.item_index,
-            item_total: progressPatch.item_total ?? record.progress?.item_total,
-            item_id: progressPatch.item_id ?? record.progress?.item_id,
-            linked_test_index: progressPatch.linked_test_index,
-            linked_test_total: progressPatch.linked_test_total,
-            current_command: progressPatch.current_command,
-            elapsed_ms: progressPatch.elapsed_ms,
-        };
-        if (progressPatch.phase === "finished" && !stopRequested) {
-            record.progress.phase = "running";
-        }
-        return true;
-    };
     child.stderr?.on("data", (chunk) => {
         const text = chunk.toString("utf8");
         stderrWriteQueue = appendFileOrdered(stderrWriteQueue, record.stderr_path, text);
@@ -606,7 +660,7 @@ export async function runBackgroundTestRunWorker(pmRoot, runId, noExtensions = f
         let progressChanged = false;
         for (const part of parts) {
             const line = part.trimEnd();
-            if (line.length > 0 && applyProgressLine(line)) {
+            if (line.length > 0 && applyBackgroundWorkerProgressLine(record, line, stopState.stopRequested)) {
                 progressChanged = true;
             }
         }
@@ -631,55 +685,22 @@ export async function runBackgroundTestRunWorker(pmRoot, runId, noExtensions = f
     await stdoutWriteQueue;
     await stderrWriteQueue;
     const trailingStderrLine = stderrBuffer.trimEnd();
-    if (trailingStderrLine.length > 0 && applyProgressLine(trailingStderrLine)) {
+    if (trailingStderrLine.length > 0 && applyBackgroundWorkerProgressLine(record, trailingStderrLine, stopState.stopRequested)) {
         scheduleRecordWrite();
     }
     stderrBuffer = "";
-    let parsedResult = null;
-    if (stdoutBuffer.trim().length > 0) {
-        try {
-            parsedResult = JSON.parse(stdoutBuffer);
-        }
-        catch {
-            parsedResult = null;
-        }
-    }
+    const parsedResult = parseBackgroundWorkerStdout(stdoutBuffer);
     const evaluated = evaluateWorkerResult(record.kind, parsedResult);
     record.summary = evaluated.summary;
     record.exit_code = typeof exitCode === "number" ? exitCode : undefined;
     record.signal = signal ?? undefined;
     record.finished_at = nowIso();
-    record.status = stopRequested
-        ? "stopped"
-        : (record.exit_code === 0 &&
-            (record.summary.failed ?? 0) === 0 &&
-            record.summary.fail_on_skipped_triggered !== true)
-            ? "passed"
-            : "failed";
-    record.progress = {
-        phase: "finished",
-        message: stopRequested ? "Background run stopped." : `Background run finished with status=${record.status}.`,
-        heartbeat_at: nowIso(),
-        item_index: record.progress?.item_index,
-        item_total: record.progress?.item_total,
-        item_id: record.progress?.item_id,
-        linked_test_index: record.progress?.linked_test_index,
-        linked_test_total: record.progress?.linked_test_total,
-        current_command: record.progress?.current_command,
-        elapsed_ms: record.progress?.elapsed_ms,
-    };
+    record.status = resolveBackgroundWorkerFinalStatus(record, stopState.stopRequested);
+    record.progress = buildFinishedBackgroundProgress(record, stopState.stopRequested);
     record.resource = await buildResourceSnapshot(record);
-    if (parsedResult !== null) {
-        await writeFileAtomic(record.result_path, `${JSON.stringify(parsedResult, null, 2)}\n`);
-    }
-    else {
-        await writeFileAtomic(record.result_path, `${JSON.stringify({
-            parse_error: "Background run output was not valid JSON.",
-            stdout_excerpt: tailLines(stdoutBuffer, DEFAULT_BACKGROUND_RUN_LOG_TAIL_LINES),
-        }, null, 2)}\n`);
-    }
+    await writeBackgroundWorkerResult(record, parsedResult, stdoutBuffer);
     await writeBackgroundRunRecord(pmRoot, record);
-    await writeQueue;
+    await recordWriteScheduler.flush();
     return record;
 }
 /**
@@ -753,6 +774,35 @@ export async function getBackgroundTestRunStatus(pmRoot, runId) {
         },
     };
 }
+/* v8 ignore start -- stop-signal branches depend on live process state; command tests cover observable stop behavior */
+function sendBackgroundRunStopSignal(record, force) {
+    const signal = force ? "SIGKILL" : "SIGTERM";
+    if (!isPidRunning(record.worker_pid) || !record.worker_pid) {
+        return "none";
+    }
+    try {
+        process.kill(record.worker_pid, signal);
+        return signal;
+    }
+    catch {
+        return "none";
+    }
+}
+/* v8 ignore stop */
+function buildStoppingBackgroundProgress(record, signalSent) {
+    return {
+        phase: "stopping",
+        message: signalSent === "none" ? "Run marked stopped." : `Stop requested via ${signalSent}.`,
+        heartbeat_at: nowIso(),
+        item_index: record.progress?.item_index,
+        item_total: record.progress?.item_total,
+        item_id: record.progress?.item_id,
+        linked_test_index: record.progress?.linked_test_index,
+        linked_test_total: record.progress?.linked_test_total,
+        current_command: record.progress?.current_command,
+        elapsed_ms: record.progress?.elapsed_ms,
+    };
+}
 /**
  * Implements stop background test run for the public runtime surface of this module.
  */
@@ -768,34 +818,13 @@ export async function stopBackgroundTestRun(pmRoot, runId, force = false) {
             signal_sent: "none",
         };
     }
-    let signalSent = "none";
-    const signal = force ? "SIGKILL" : "SIGTERM";
-    if (isPidRunning(refreshed.worker_pid) && refreshed.worker_pid) {
-        try {
-            process.kill(refreshed.worker_pid, signal);
-            signalSent = signal;
-        }
-        catch {
-            signalSent = "none";
-        }
-    }
+    const signalSent = sendBackgroundRunStopSignal(refreshed, force);
     if (signalSent === "none") {
         refreshed.status = "stopped";
         refreshed.finished_at = refreshed.finished_at ?? nowIso();
     }
     refreshed.stop_requested_at = nowIso();
-    refreshed.progress = {
-        phase: "stopping",
-        message: signalSent === "none" ? "Run marked stopped." : `Stop requested via ${signalSent}.`,
-        heartbeat_at: nowIso(),
-        item_index: refreshed.progress?.item_index,
-        item_total: refreshed.progress?.item_total,
-        item_id: refreshed.progress?.item_id,
-        linked_test_index: refreshed.progress?.linked_test_index,
-        linked_test_total: refreshed.progress?.linked_test_total,
-        current_command: refreshed.progress?.current_command,
-        elapsed_ms: refreshed.progress?.elapsed_ms,
-    };
+    refreshed.progress = buildStoppingBackgroundProgress(refreshed, signalSent);
     await writeBackgroundRunRecord(pmRoot, refreshed);
     return {
         run: refreshed,
@@ -874,4 +903,4 @@ export const _testOnly = {
     tailLines,
 };
 //# sourceMappingURL=background-runs.js.map
-//# debugId=831e5e73-7cc7-5703-981e-784a2fef0e81
+//# debugId=aefbe330-eaa9-5b52-a406-b796df6bff8b