@unbrained/pm-cli 2026.6.30 → 2026.7.1

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]="588f0e3a-3f1c-56d9-8908-c8003ae549cd")}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]="8f5d4783-6790-59c5-b9fa-9b1f1abd13b9")}catch(e){}}();
 import { spawn } from "node:child_process";
 import { cp, mkdir, mkdtemp, readdir, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
@@ -276,25 +276,24 @@ function extractPmInvocationArgsFromSegment(segment) {
     if (executable === "node" && args.length > 0 && isPmCliScriptToken(args[0])) {
         return args.slice(1);
     }
+    return extractPackageManagerPmInvocationArgs(executable, args);
+}
+function extractPackageManagerPmInvocationArgs(executable, args) {
+    const parsed = parsePackageManagerPmInvocation(executable, args);
+    if (!parsed || (!isPmExecutableToken(parsed.command) && !isPmCliPackageToken(parsed.command))) {
+        return null;
+    }
+    return parsed.args;
+}
+function parsePackageManagerPmInvocation(executable, args) {
     if (executable === "npx" || executable === "bunx") {
-        const parsed = parseNpxCommand(args);
-        /* c8 ignore start -- npx launcher edge permutations are covered by command-parser integration suites */
-        if (parsed && (isPmExecutableToken(parsed.command) || isPmCliPackageToken(parsed.command))) {
-            return parsed.args;
-        }
-        /* c8 ignore stop */
+        return parseNpxCommand(args);
     }
     if (executable === "pnpm") {
-        const parsed = parsePnpmDlxCommand(args);
-        if (parsed && (isPmExecutableToken(parsed.command) || isPmCliPackageToken(parsed.command))) {
-            return parsed.args;
-        }
+        return parsePnpmDlxCommand(args);
     }
     if (executable === "npm") {
-        const parsed = parseNpmExecCommand(args);
-        if (parsed && (isPmExecutableToken(parsed.command) || isPmCliPackageToken(parsed.command))) {
-            return parsed.args;
-        }
+        return parseNpmExecCommand(args);
     }
     return null;
 }
@@ -452,30 +451,23 @@ function segmentInvokesUnsafeDirectTestRunner(normalizedSegment) {
         return true;
     }
     if (executable === "node") {
-        return (args.includes("--test") ||
-            args.some((arg) => arg === "vitest" || arg === "vitest.mjs" || arg.endsWith("/vitest") || arg.endsWith("/vitest.mjs")));
+        return nodeArgsInvokeUnsafeDirectTestRunner(args);
     }
+    return packageManagerInvokesUnsafeDirectTestRunner(executable, args);
+}
+function nodeArgsInvokeUnsafeDirectTestRunner(args) {
+    return (args.includes("--test") ||
+        args.some((arg) => arg === "vitest" || arg === "vitest.mjs" || arg.endsWith("/vitest") || arg.endsWith("/vitest.mjs")));
+}
+function packageManagerInvokesUnsafeDirectTestRunner(executable, args) {
     if (executable === "npx" || executable === "bunx") {
         return isDirectTestRunnerSubcommand(parseNpxCommand(args)?.command);
     }
-    if (executable === "pnpm") {
-        const dlx = parsePnpmDlxCommand(args);
-        if (isDirectTestRunnerSubcommand(dlx?.command)) {
-            return true;
-        }
-        return firstDirectTestRunnerSubcommand(executable, args) === "vitest";
-    }
-    if (executable === "npm") {
-        const exec = parseNpmExecCommand(args);
-        if (isDirectTestRunnerSubcommand(exec?.command)) {
-            return true;
-        }
-        return firstDirectTestRunnerSubcommand(executable, args) === "vitest";
-    }
-    if (executable === "yarn" || executable === "bun") {
-        return firstDirectTestRunnerSubcommand(executable, args) === "vitest";
+    if (executable === "pnpm" || executable === "npm") {
+        return (isDirectTestRunnerSubcommand(parsePackageManagerPmInvocation(executable, args)?.command) ||
+            firstDirectTestRunnerSubcommand(executable, args) === "vitest");
     }
-    return false;
+    return (executable === "yarn" || executable === "bun") && firstDirectTestRunnerSubcommand(executable, args) === "vitest";
 }
 function assertSandboxSafeTestRunnerCommand(command) {
     const normalized = normalizeCommandForValidation(command);
@@ -496,52 +488,48 @@ function getRuntimeSafetySkipReason(command) {
 function parseAddEntries(raw) {
     if (!raw)
         return [];
-    return raw.map((entry) => {
-        const trimmed = entry.trim();
-        const kv = looksLikeStructuredLinkedTestEntry(trimmed)
-            ? normalizeStructuredLinkedTestEntry(parseCsvKv(entry, "--add"), "--add")
-            : { command: trimmed };
-        const command = kv.command?.trim() || undefined;
-        const filePath = kv.path?.trim() || undefined;
-        if (!command) {
-            throw new PmCliError("--add requires command=<value> or a bare command (path=<value> is optional metadata)", EXIT_CODE.USAGE);
-        }
-        const sharedHostSafe = parseLinkedTestBooleanValue(kv.shared_host_safe?.trim(), "--add", "shared_host_safe");
-        /* c8 ignore start -- command is guaranteed present after the non-empty guard above */
-        if (command) {
-            assertNoRecursiveTestAllCommand(command);
-            assertSandboxSafeTestRunnerCommand(command);
-        }
-        /* c8 ignore stop */
-        const timeoutSecondsRaw = kv.timeout_seconds?.trim();
-        const timeoutAliasRaw = kv.timeout?.trim();
-        if (timeoutSecondsRaw && timeoutAliasRaw && timeoutSecondsRaw !== timeoutAliasRaw) {
-            throw new PmCliError("--add timeout and timeout_seconds must match when both are provided", EXIT_CODE.USAGE);
-        }
-        const timeoutRaw = timeoutSecondsRaw ?? timeoutAliasRaw;
-        const timeoutSeconds = timeoutRaw === undefined ? undefined : Math.floor(parseOptionalNumber(timeoutRaw, "timeout_seconds"));
-        const envSet = parseLinkedTestEnvSetValue(kv.env_set?.trim(), "--add");
-        const envClear = parseLinkedTestEnvClearValue(kv.env_clear?.trim(), "--add");
-        const pmContextMode = parseLinkedTestContextModeValue(kv.pm_context_mode?.trim(), "--add");
-        return {
-            command,
-            path: filePath,
-            scope: ensureScope(kv.scope),
-            timeout_seconds: timeoutSeconds,
-            pm_context_mode: pmContextMode,
-            env_set: envSet,
-            env_clear: envClear,
-            shared_host_safe: sharedHostSafe,
-            assert_stdout_contains: parseLinkedTestStringList(kv.assert_stdout_contains?.trim()),
-            assert_stdout_regex: parseLinkedTestRegexList(kv.assert_stdout_regex?.trim(), "--add", "assert_stdout_regex"),
-            assert_stderr_contains: parseLinkedTestStringList(kv.assert_stderr_contains?.trim()),
-            assert_stderr_regex: parseLinkedTestRegexList(kv.assert_stderr_regex?.trim(), "--add", "assert_stderr_regex"),
-            assert_stdout_min_lines: parseLinkedTestMinLines(kv.assert_stdout_min_lines?.trim(), "--add"),
-            assert_json_field_equals: parseLinkedTestAssertionEqualsMap(kv.assert_json_field_equals?.trim(), "--add"),
-            assert_json_field_gte: parseLinkedTestAssertionGteMap(kv.assert_json_field_gte?.trim(), "--add"),
-            note: kv.note?.trim() || undefined,
-        };
-    });
+    return raw.map(parseAddEntry);
+}
+function parseAddEntry(entry) {
+    const trimmed = entry.trim();
+    const kv = looksLikeStructuredLinkedTestEntry(trimmed)
+        ? normalizeStructuredLinkedTestEntry(parseCsvKv(entry, "--add"), "--add")
+        : { command: trimmed };
+    const command = trimLinkedTestEntryField(kv.command);
+    if (!command) {
+        throw new PmCliError("--add requires command=<value> or a bare command (path=<value> is optional metadata)", EXIT_CODE.USAGE);
+    }
+    assertNoRecursiveTestAllCommand(command);
+    assertSandboxSafeTestRunnerCommand(command);
+    return {
+        command,
+        path: trimLinkedTestEntryField(kv.path),
+        scope: ensureScope(kv.scope),
+        timeout_seconds: parseLinkedTestTimeoutSeconds(trimLinkedTestEntryField(kv.timeout_seconds), trimLinkedTestEntryField(kv.timeout)),
+        pm_context_mode: parseLinkedTestContextModeValue(trimLinkedTestEntryField(kv.pm_context_mode), "--add"),
+        env_set: parseLinkedTestEnvSetValue(trimLinkedTestEntryField(kv.env_set), "--add"),
+        env_clear: parseLinkedTestEnvClearValue(trimLinkedTestEntryField(kv.env_clear), "--add"),
+        shared_host_safe: parseLinkedTestBooleanValue(trimLinkedTestEntryField(kv.shared_host_safe), "--add", "shared_host_safe"),
+        assert_stdout_contains: parseLinkedTestStringList(trimLinkedTestEntryField(kv.assert_stdout_contains)),
+        assert_stdout_regex: parseLinkedTestRegexList(trimLinkedTestEntryField(kv.assert_stdout_regex), "--add", "assert_stdout_regex"),
+        assert_stderr_contains: parseLinkedTestStringList(trimLinkedTestEntryField(kv.assert_stderr_contains)),
+        assert_stderr_regex: parseLinkedTestRegexList(trimLinkedTestEntryField(kv.assert_stderr_regex), "--add", "assert_stderr_regex"),
+        assert_stdout_min_lines: parseLinkedTestMinLines(trimLinkedTestEntryField(kv.assert_stdout_min_lines), "--add"),
+        assert_json_field_equals: parseLinkedTestAssertionEqualsMap(trimLinkedTestEntryField(kv.assert_json_field_equals), "--add"),
+        assert_json_field_gte: parseLinkedTestAssertionGteMap(trimLinkedTestEntryField(kv.assert_json_field_gte), "--add"),
+        note: trimLinkedTestEntryField(kv.note),
+    };
+}
+function trimLinkedTestEntryField(value) {
+    const trimmed = value?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : undefined;
+}
+function parseLinkedTestTimeoutSeconds(timeoutSecondsRaw, timeoutAliasRaw) {
+    if (timeoutSecondsRaw && timeoutAliasRaw && timeoutSecondsRaw !== timeoutAliasRaw) {
+        throw new PmCliError("--add timeout and timeout_seconds must match when both are provided", EXIT_CODE.USAGE);
+    }
+    const timeoutRaw = timeoutSecondsRaw ?? timeoutAliasRaw;
+    return timeoutRaw === undefined ? undefined : Math.floor(parseOptionalNumber(timeoutRaw, "timeout_seconds"));
 }
 /* c8 ignore start -- add-json validation matrix is covered by linked-test parser integration suites */
 function parseAddJsonEntries(raw) {
@@ -1121,47 +1109,11 @@ function compareAssertionValues(actual, expected) {
 /* c8 ignore start -- assertion failure-path permutations are covered by linked-test integration fixtures */
 function evaluateLinkedTestAssertions(linkedTest, stdout, stderr) {
     const failures = [];
-    for (const expected of linkedTest.assert_stdout_contains ?? []) {
-        if (!stdout.includes(expected)) {
-            failures.push(`stdout missing required text: "${expected}"`);
-        }
-    }
-    for (const pattern of linkedTest.assert_stdout_regex ?? []) {
-        try {
-            const regex = new RegExp(pattern, "m");
-            if (!regex.test(stdout)) {
-                failures.push(`stdout failed regex assertion: /${pattern}/m`);
-            }
-        }
-        catch (error) {
-            failures.push(`stdout regex assertion is invalid: /${pattern}/ (${error instanceof Error ? error.message : String(error)})`);
-        }
-    }
-    for (const expected of linkedTest.assert_stderr_contains ?? []) {
-        if (!stderr.includes(expected)) {
-            failures.push(`stderr missing required text: "${expected}"`);
-        }
-    }
-    for (const pattern of linkedTest.assert_stderr_regex ?? []) {
-        try {
-            const regex = new RegExp(pattern, "m");
-            if (!regex.test(stderr)) {
-                failures.push(`stderr failed regex assertion: /${pattern}/m`);
-            }
-        }
-        catch (error) {
-            failures.push(`stderr regex assertion is invalid: /${pattern}/ (${error instanceof Error ? error.message : String(error)})`);
-        }
-    }
-    if (typeof linkedTest.assert_stdout_min_lines === "number") {
-        const lineCount = stdout
-            .split(/\r?\n/)
-            .map((line) => line.trim())
-            .filter((line) => line.length > 0).length;
-        if (lineCount < linkedTest.assert_stdout_min_lines) {
-            failures.push(`stdout line count ${lineCount} is below required minimum ${linkedTest.assert_stdout_min_lines}`);
-        }
-    }
+    failures.push(...evaluateContainsAssertions("stdout", stdout, linkedTest.assert_stdout_contains));
+    failures.push(...evaluateRegexAssertions("stdout", stdout, linkedTest.assert_stdout_regex));
+    failures.push(...evaluateContainsAssertions("stderr", stderr, linkedTest.assert_stderr_contains));
+    failures.push(...evaluateRegexAssertions("stderr", stderr, linkedTest.assert_stderr_regex));
+    failures.push(...evaluateStdoutLineCountAssertion(stdout, linkedTest.assert_stdout_min_lines));
     const jsonEqualsAssertions = linkedTest.assert_json_field_equals ?? {};
     const jsonGteAssertions = linkedTest.assert_json_field_gte ?? {};
     const needsJsonAssertions = Object.keys(jsonEqualsAssertions).length > 0 || Object.keys(jsonGteAssertions).length > 0;
@@ -1204,6 +1156,40 @@ function evaluateLinkedTestAssertions(linkedTest, stdout, stderr) {
     return failures;
 }
 /* c8 ignore stop */
+function evaluateContainsAssertions(streamName, output, expectedValues) {
+    const failures = [];
+    for (const expected of expectedValues ?? []) {
+        if (!output.includes(expected)) {
+            failures.push(`${streamName} missing required text: "${expected}"`);
+        }
+    }
+    return failures;
+}
+function evaluateRegexAssertions(streamName, output, patterns) {
+    const failures = [];
+    for (const pattern of patterns ?? []) {
+        try {
+            const regex = new RegExp(pattern, "m");
+            if (!regex.test(output)) {
+                failures.push(`${streamName} failed regex assertion: /${pattern}/m`);
+            }
+        }
+        catch (error) {
+            failures.push(`${streamName} regex assertion is invalid: /${pattern}/ (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
+    return failures;
+}
+function evaluateStdoutLineCountAssertion(stdout, minimum) {
+    if (typeof minimum !== "number") {
+        return [];
+    }
+    const lineCount = stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0).length;
+    return lineCount < minimum ? [`stdout line count ${lineCount} is below required minimum ${minimum}`] : [];
+}
 const EMPTY_LINKED_TEST_RUN_PATTERNS = [
     { code: "no_projects_matched_filters", regex: /\bNo projects matched the filters\b/i },
     { code: "no_test_files_found", regex: /\bNo test files found\b/i },
@@ -1656,4 +1642,4 @@ export const _testOnlyTestCommand = {
     summarizeRunResultStatuses,
 };
 //# sourceMappingURL=test.js.map
-//# debugId=588f0e3a-3f1c-56d9-8908-c8003ae549cd
+//# debugId=8f5d4783-6790-59c5-b9fa-9b1f1abd13b9