@unbrained/pm-cli 2026.7.6 → 2026.7.8

package/dist/cli/commands/test.d.ts

@@ -141,6 +141,14 @@ declare function resolveDirectRunnerSubcommand(parsed: {
 } | null): string | undefined;
 declare function firstDirectTestRunnerSubcommand(executable: string, args: string[]): string | undefined;
 declare function parseAddJsonEntries(raw: string[] | undefined): LinkedTest[];
+interface LinkedTestOutputBufferState {
+    stdout: string;
+    stderr: string;
+    stdoutBytes: number;
+    stderrBytes: number;
+    maxBufferExceeded: boolean;
+}
+declare function appendLinkedTestOutputChunk(state: LinkedTestOutputBufferState, chunk: Buffer | string, target: "stdout" | "stderr"): boolean;
 declare function runLinkedTestCommand(command: string, timeoutMs: number, env: NodeJS.ProcessEnv, progressContext: LinkedTestProgressContext, progressMode: LinkedTestProgressMode): Promise<LinkedTestExecutionResult>;
 /**
  * Implements classify linked test failure for the public runtime surface of this module.
@@ -207,6 +215,7 @@ export declare const _testOnlyTestCommand: {
     resolveLinkedTestRequestedContextMode: typeof resolveLinkedTestRequestedContextMode;
     resolveTrackedRunId: typeof resolveTrackedRunId;
     runLinkedTestCommand: typeof runLinkedTestCommand;
+    appendLinkedTestOutputChunk: typeof appendLinkedTestOutputChunk;
     seedLinkedTestSandbox: typeof seedLinkedTestSandbox;
     seedLinkedTestTrackerData: typeof seedLinkedTestTrackerData;
     splitJsonPathSegments: typeof splitJsonPathSegments;

package/dist/cli/commands/test.js

@@ -4,7 +4,7 @@
  * Implements the pm test command surface and its agent-facing runtime behavior.
  */
 
-!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]="caa941ed-c848-506c-9a3c-3d4959be0246")}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]="f029551e-3255-54ff-a331-dae9ed057908")}catch(e){}}();
 import { spawn } from "node:child_process";
 import { cp, mkdir, mkdtemp, readdir, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
@@ -214,7 +214,8 @@ function buildPmContextMismatchHint(params) {
             " Set pm_context_mode=tracker (or auto) on the linked test, or remove the override, to run against seeded tracker data.");
     }
     if (executionContext.pm_context_mode === "schema") {
-        return " Use --pm-context tracker to run PM tracker-read commands against seeded tracker data.";
+        return (" Use --auto-pm-context to route PM tracker-read linked commands through seeded tracker data automatically." +
+            " Alternatively, use --pm-context tracker for the whole run.");
     }
     return "";
 }
@@ -671,45 +672,22 @@ async function killProcessTree(pid) {
         // The process can already be gone.
     }
 }
-/* c8 ignore stop */
-/* c8 ignore start -- process lifecycle timing/error race branches are covered by cross-platform integration runners */
-async function runLinkedTestCommand(command, timeoutMs, env, progressContext, progressMode) {
-    const startedAt = Date.now();
-    const heartbeat = beginLinkedTestProgress(progressContext, progressMode);
-    const child = spawn(command, {
-        cwd: process.cwd(),
-        env,
-        shell: true,
-        windowsHide: true,
-        detached: process.platform !== "win32",
-        stdio: ["pipe", "pipe", "pipe"],
-    });
-    closeLinkedTestStdin(child);
-    let stdout = "";
-    let stderr = "";
-    let stdoutBytes = 0;
-    let stderrBytes = 0;
-    let timedOut = false;
-    let maxBufferExceeded = false;
-    let spawnError;
-    let forceKillTimer = null;
-    let timedOutTimer = null;
+function clearLinkedTestTimers(timers) {
+    if (timers.heartbeat) {
+        clearInterval(timers.heartbeat);
+    }
+    if (timers.timedOutTimer) {
+        clearTimeout(timers.timedOutTimer);
+        timers.timedOutTimer = null;
+    }
+    if (timers.forceKillTimer) {
+        clearTimeout(timers.forceKillTimer);
+        timers.forceKillTimer = null;
+    }
+}
+function createLinkedTestTerminationRequester(child, timers) {
     let terminationRequested = false;
-    const clearTimers = () => {
-        if (heartbeat) {
-            clearInterval(heartbeat);
-        }
-        if (timedOutTimer) {
-            clearTimeout(timedOutTimer);
-            timedOutTimer = null;
-        }
-        if (forceKillTimer) {
-            clearTimeout(forceKillTimer);
-            forceKillTimer = null;
-        }
-    };
-    /* c8 ignore start -- timeout termination branches depend on scheduler/process-group timing. */
-    const requestTermination = async () => {
+    return async () => {
         if (terminationRequested) {
             return;
         }
@@ -741,45 +719,46 @@ async function runLinkedTestCommand(command, timeoutMs, env, progressContext, pr
             }
         }
         /* c8 ignore next 3 -- exercised only when timeout escalation triggers force-kill fallback. */
-        forceKillTimer = setTimeout(() => {
+        timers.forceKillTimer = setTimeout(() => {
             void killProcessTree(pid);
         }, linkedTestTimeoutForceKillDelayMs());
-        forceKillTimer.unref?.();
-    };
-    /* c8 ignore stop */
-    const appendChunk = (chunk, target) => {
-        const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
-        const bytes = Buffer.byteLength(text);
-        if (target === "stdout") {
-            stdoutBytes += bytes;
-            if (stdoutBytes <= TEST_OUTPUT_MAX_BUFFER_BYTES) {
-                stdout += text;
-            }
-        }
-        else {
-            stderrBytes += bytes;
-            if (stderrBytes <= TEST_OUTPUT_MAX_BUFFER_BYTES) {
-                stderr += text;
-            }
-        }
-        if (!maxBufferExceeded && (stdoutBytes > TEST_OUTPUT_MAX_BUFFER_BYTES || stderrBytes > TEST_OUTPUT_MAX_BUFFER_BYTES)) {
-            maxBufferExceeded = true;
-            void requestTermination();
-        }
+        timers.forceKillTimer.unref?.();
     };
-    child.stdout?.on("data", (chunk) => appendChunk(chunk, "stdout"));
-    child.stderr?.on("data", (chunk) => appendChunk(chunk, "stderr"));
-    /* c8 ignore next 5 -- shell spawn error callbacks are non-deterministic across platforms. */
-    child.on("error", (error) => {
-        spawnError = error.message;
-    });
-    /* c8 ignore next 4 -- callback scheduling timing is non-deterministic under coverage instrumentation. */
-    timedOutTimer = setTimeout(() => {
-        timedOut = true;
-        void requestTermination();
-    }, timeoutMs);
-    timedOutTimer.unref?.();
-    const { code, signal } = await new Promise((resolve) => {
+}
+function readLinkedTestOutputChunkText(chunk, bytes, remainingBytes) {
+    if (remainingBytes <= 0) {
+        return "";
+    }
+    if (bytes <= remainingBytes) {
+        return typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    }
+    const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+    return buffer.subarray(0, remainingBytes).toString("utf8");
+}
+function appendLinkedTestOutputChunk(state, chunk, target) {
+    if (state.maxBufferExceeded) {
+        return false;
+    }
+    const bytes = typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.byteLength;
+    if (target === "stdout") {
+        const remainingBytes = TEST_OUTPUT_MAX_BUFFER_BYTES - state.stdoutBytes;
+        state.stdout += readLinkedTestOutputChunkText(chunk, bytes, remainingBytes);
+        state.stdoutBytes += bytes;
+    }
+    else {
+        const remainingBytes = TEST_OUTPUT_MAX_BUFFER_BYTES - state.stderrBytes;
+        state.stderr += readLinkedTestOutputChunkText(chunk, bytes, remainingBytes);
+        state.stderrBytes += bytes;
+    }
+    const bufferExceeded = state.stdoutBytes > TEST_OUTPUT_MAX_BUFFER_BYTES || state.stderrBytes > TEST_OUTPUT_MAX_BUFFER_BYTES;
+    if (!state.maxBufferExceeded && bufferExceeded) {
+        state.maxBufferExceeded = true;
+        return true;
+    }
+    return false;
+}
+function waitForLinkedTestChildClose(child) {
+    return new Promise((resolve) => {
         let settled = false;
         let pipeCloseGraceTimer = null;
         const settle = (value, destroyPipes = false) => {
@@ -817,14 +796,62 @@ async function runLinkedTestCommand(command, timeoutMs, env, progressContext, pr
             });
         });
     });
-    clearTimers();
+}
+function createLinkedTestChild(command, env) {
+    return spawn(command, {
+        cwd: process.cwd(),
+        env,
+        shell: true,
+        windowsHide: true,
+        detached: process.platform !== "win32",
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+}
+async function runLinkedTestCommand(command, timeoutMs, env, progressContext, progressMode) {
+    const startedAt = Date.now();
+    const child = createLinkedTestChild(command, env);
+    closeLinkedTestStdin(child);
+    const timers = {
+        heartbeat: beginLinkedTestProgress(progressContext, progressMode),
+        forceKillTimer: null,
+        timedOutTimer: null,
+    };
+    const output = {
+        stdout: "",
+        stderr: "",
+        stdoutBytes: 0,
+        stderrBytes: 0,
+        maxBufferExceeded: false,
+    };
+    const requestTermination = createLinkedTestTerminationRequester(child, timers);
+    let timedOut = false;
+    let spawnError;
+    const appendChunk = (chunk, target) => {
+        if (appendLinkedTestOutputChunk(output, chunk, target)) {
+            void requestTermination();
+        }
+    };
+    child.stdout?.on("data", (chunk) => appendChunk(chunk, "stdout"));
+    child.stderr?.on("data", (chunk) => appendChunk(chunk, "stderr"));
+    /* c8 ignore next 5 -- shell spawn error callbacks are non-deterministic across platforms. */
+    child.on("error", (error) => {
+        spawnError = error.message;
+    });
+    /* c8 ignore next 4 -- callback scheduling timing is non-deterministic under coverage instrumentation. */
+    timers.timedOutTimer = setTimeout(() => {
+        timedOut = true;
+        void requestTermination();
+    }, timeoutMs);
+    timers.timedOutTimer.unref?.();
+    const { code, signal } = await waitForLinkedTestChildClose(child);
+    clearLinkedTestTimers(timers);
     const executionResult = {
-        stdout,
-        stderr,
+        stdout: output.stdout,
+        stderr: output.stderr,
         exitCode: code,
         signal,
         timedOut,
-        maxBufferExceeded,
+        maxBufferExceeded: output.maxBufferExceeded,
         spawnError,
     };
     endLinkedTestProgress(progressContext, executionResult, startedAt, progressMode);
@@ -1481,6 +1508,39 @@ export async function runLinkedTests(tests, defaultTimeoutSeconds, options) {
     }
     return results;
 }
+async function readLinkedTestItem(params) {
+    const { id, pmRoot, settings, typeToFolder } = params;
+    const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeToFolder);
+    if (!located) {
+        throw new PmCliError(`Item ${id} not found`, EXIT_CODE.NOT_FOUND);
+    }
+    const loaded = await readLocatedItem(located, { schema: settings.schema });
+    return { itemId: located.id, tests: loaded.document.metadata.tests ?? [], changed: false };
+}
+function linkedTestsHaveSameIdentity(left, right) {
+    return (left.command === right.command &&
+        left.path === right.path &&
+        left.scope === right.scope &&
+        left.pm_context_mode === right.pm_context_mode);
+}
+function appendMissingLinkedTests(current, additions) {
+    const next = [...current];
+    for (const addition of additions) {
+        if (!next.some((entry) => linkedTestsHaveSameIdentity(entry, addition))) {
+            next.push(addition);
+        }
+    }
+    return next;
+}
+function removeLinkedTestsBySelector(current, removals) {
+    if (removals.length === 0) {
+        return current;
+    }
+    return current.filter((entry) => !removals.includes(entry.path ?? "") && !removals.includes(entry.command ?? ""));
+}
+function applyLinkedTestMutations(previous, adds, removes) {
+    return removeLinkedTestsBySelector(appendMissingLinkedTests(previous, adds), removes);
+}
 function hasTestRuntimeDirectiveFlags(options) {
     return ((options.envSet?.length ?? 0) > 0 ||
         (options.envClear?.length ?? 0) > 0 ||
@@ -1506,12 +1566,7 @@ function assertTestRunFlagUsage(options) {
 async function resolveLinkedTestItem(params) {
     const { id, options, pmRoot, settings, typeToFolder, adds, removes } = params;
     if (adds.length === 0 && removes.length === 0) {
-        const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeToFolder);
-        if (!located) {
-            throw new PmCliError(`Item ${id} not found`, EXIT_CODE.NOT_FOUND);
-        }
-        const loaded = await readLocatedItem(located, { schema: settings.schema });
-        return { itemId: located.id, tests: loaded.document.metadata.tests ?? [], changed: false };
+        return readLinkedTestItem({ id, pmRoot, settings, typeToFolder });
     }
     const result = await mutateItem({
         pmRoot,
@@ -1524,24 +1579,7 @@ async function resolveLinkedTestItem(params) {
         skipNoop: true,
         mutate(document) {
             const previous = document.metadata.tests ?? [];
-            const next = [...previous];
-            for (const add of adds) {
-                const exists = next.some((entry) => entry.command === add.command &&
-                    entry.path === add.path &&
-                    entry.scope === add.scope &&
-                    entry.pm_context_mode === add.pm_context_mode);
-                if (!exists) {
-                    next.push(add);
-                }
-            }
-            if (removes.length > 0) {
-                for (let i = next.length - 1; i >= 0; i -= 1) {
-                    const entry = next[i];
-                    if (removes.includes(entry.path ?? "") || removes.includes(entry.command ?? "")) {
-                        next.splice(i, 1);
-                    }
-                }
-            }
+            const next = applyLinkedTestMutations(previous, adds, removes);
             document.metadata.tests = next;
             return { changedFields: stableValueEquals(previous, next) ? [] : ["tests"] };
         },
@@ -1716,10 +1754,11 @@ export const _testOnlyTestCommand = {
     resolveLinkedTestRequestedContextMode,
     resolveTrackedRunId,
     runLinkedTestCommand,
+    appendLinkedTestOutputChunk,
     seedLinkedTestSandbox,
     seedLinkedTestTrackerData,
     splitJsonPathSegments,
     summarizeRunResultStatuses,
 };
 //# sourceMappingURL=test.js.map
-//# debugId=caa941ed-c848-506c-9a3c-3d4959be0246
+//# debugId=f029551e-3255-54ff-a331-dae9ed057908