@bridge_gpt/mcp-server 0.2.34 → 0.2.37

package/build/run-unit-tests-launcher.js

@@ -0,0 +1,259 @@
+/**
+ * BAPI-683 — bounded, cross-platform launcher for the MCP server's compiled
+ * `node:test` suite.
+ *
+ * The previous `scripts.test` invocation enumerated every compiled test file
+ * as an explicit `node --test` command-line argument. Windows' CreateProcess
+ * command-line length limit (~8191 chars) made that argv too long once the
+ * suite grew past ~200 files (`The command line is too long.`, exit 1, before
+ * any test ran) — Linux/macOS have a much larger limit, so the same script
+ * kept passing there. This module discovers compiled test files at runtime
+ * and spawns them in size-bounded batches instead of expanding them ahead of
+ * time in package.json, so no single child invocation can approach the
+ * Windows ceiling regardless of how many test files exist.
+ *
+ * `scripts/run-unit-tests.js` is the thin CLI entrypoint that imports this
+ * compiled module; the logic lives here (under src/, built by tsc) so it can
+ * be unit-tested with node:test like every other module in this package.
+ */
+import { readdirSync } from "fs";
+import { spawnSync } from "child_process";
+import path from "path";
+const DEFAULT_BUILD_DIR = "build";
+// The Windows CreateProcess command-line limit is ~8191 characters. This
+// budget stays well under it (accounting for execPath + node options +
+// separators) so a single batch can never approach the real ceiling even on a
+// longer install path. Kept OS-independent so batching is deterministic and
+// stable across every CI runner and locally.
+export const MAX_COMMAND_LENGTH = 6000;
+// Explicit manifest: only tests that call node:test's `mock.module()` API
+// need --experimental-test-module-mocks. Everything else discovered under
+// build/ is eligible for the "normal" group automatically — new tests do NOT
+// need to be registered anywhere else. Add an entry here only when a new test
+// needs module mocking.
+export const MODULE_MOCK_MANIFEST = [
+    "build/attachment-download.test.js",
+    "build/attachment-upload.test.js",
+    "build/automation-progress.test.js",
+    "build/conductor/cli-git-hooks.test.js",
+    "build/conductor/cli.test.js",
+    "build/conductor/git-inspection.test.js",
+    "build/conductor/paths.test.js",
+    "build/conductor/pr-ci-producer-emit-seam.test.js",
+    "build/conductor/security-regressions.test.js",
+    "build/conductor/store-lifecycle.test.js",
+    "build/conductor/store-queries.test.js",
+    "build/conductor/tools-done-gate.test.js",
+    "build/conductor/tools.test.js",
+    "build/connect-github-api.test.js",
+    "build/connect-github-dispatch.static.test.js",
+    "build/connect-github-handoff.test.js",
+    "build/connect-github.test.js",
+    "build/council-wait-recovery.test.js",
+    "build/index-artifacts.test.js",
+    "build/index-brainstorm-filenames.test.js",
+    "build/index-generate-decision-page.integration.test.js",
+    "build/index-generate-decision-page.test.js",
+    "build/index-heavy-read-truncation.test.js",
+    "build/index-output-path.test.js",
+    "build/index.review-rounds.test.js",
+    "build/recovery-formatting.test.js",
+    "build/sfcc/client.test.js",
+    "build/sfcc/permissions.test.js",
+    "build/sfcc/read-boundary.test.js",
+    "build/sfcc/reads-custom-object-def.test.js",
+    "build/sfcc/reads-site-preference.test.js",
+    "build/sfcc/reads-system-object.test.js",
+    "build/sfcc/register.test.js",
+    "build/sfcc/setup-status.test.js",
+    "build/sfcc/tool-wrapper.test.js",
+    "build/sfcc/write-gate-rejection.test.js",
+    "build/sfcc/writes-custom-object-def.test.js",
+    "build/sfcc/writes-site-preference.test.js",
+    "build/sfcc/writes-system-object.test.js",
+    "build/ticket-wait-recovery.test.js",
+    "build/visual-diff.attachment-adapter.test.js",
+    "build/visual-diff.registration.test.js",
+    "build/wait-for-result.test.js",
+];
+// Files that must run as their own single-file `node --test --test-force-exit`
+// invocation instead of joining a multi-file batch. --test-force-exit makes
+// the runner exit before it finishes aggregating per-subprocess summaries, so
+// a multi-file batch run with it reports a nondeterministic (undercounted)
+// test tally — failures still surface and still set exit 1, but the count
+// cannot be trusted as a completeness signal. Batched invocations therefore
+// run WITHOUT the flag; only the files listed here get it, each alone, where
+// the tally stays exact. build/secret-safety.test.js is quarantined because it
+// leaks a handle that holds the event loop ~60s after its tests finish (they
+// run in ~147ms). Do NOT add --test-force-exit to batched invocations, and do
+// NOT remove a file from this quarantine, until its underlying handle leak is
+// fixed.
+export const FORCE_EXIT_QUARANTINE = ["build/secret-safety.test.js"];
+// build/integration/** is the separately-invoked MCP_INTEGRATION=1 suite (run
+// via `npm run test:integration`) plus the packaged-CLI smoke test (`npm run
+// test:smoke`) — neither runs as part of `npm test`. `measure-tools.test.js`
+// is the one file under that directory that has always run as part of the
+// normal unit suite.
+const INTEGRATION_DIR_PREFIX = "build/integration/";
+const INTEGRATION_DIR_ALLOWLIST = new Set(["build/integration/measure-tools.test.js"]);
+// Pre-existing compiled test files that were not wired into ANY script before
+// this launcher existed (discovered while building it). BAPI-683 preserves
+// the exact current running test set rather than silently picking these up —
+// see docs/BAPI-683-mcp-ci-windows-npm-test-launcher.md for the follow-up.
+const KNOWN_UNREGISTERED_ORPHANS = new Set([
+    "build/conductor/conductor-runtime.integration.test.js",
+    "build/sfcc/register-site-preference.integration.test.js",
+]);
+/** Recursively lists compiled `*.test.js` files under `<root>/<buildDir>`, sorted and package-relative. */
+export function discoverTestFiles(options) {
+    const { root, buildDir = DEFAULT_BUILD_DIR, fsImpl = { readdirSync } } = options;
+    const absoluteBuildDir = path.join(root, buildDir);
+    const results = [];
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = fsImpl.readdirSync(dir, { withFileTypes: true });
+        }
+        catch (err) {
+            if (err?.code === "ENOENT")
+                return;
+            throw err;
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(full);
+            }
+            else if (entry.name.endsWith(".test.js")) {
+                results.push(path.relative(root, full).split(path.sep).join("/"));
+            }
+        }
+    };
+    walk(absoluteBuildDir);
+    results.sort();
+    return results;
+}
+/** Throws if the module-mock or force-exit-quarantine manifest has drifted from the discovered build output. */
+export function validateManifest(discovered) {
+    const discoveredSet = new Set(discovered);
+    const seen = new Set();
+    for (const entry of MODULE_MOCK_MANIFEST) {
+        if (seen.has(entry)) {
+            throw new Error(`run-unit-tests: duplicate module-mock manifest entry: ${entry}`);
+        }
+        seen.add(entry);
+        if (!discoveredSet.has(entry)) {
+            throw new Error(`run-unit-tests: module-mock manifest entry not found in build output: ${entry} ` +
+                `(rebuild with 'npm run build', or remove it from MODULE_MOCK_MANIFEST if the file was deleted/renamed)`);
+        }
+    }
+    for (const entry of FORCE_EXIT_QUARANTINE) {
+        if (seen.has(entry)) {
+            throw new Error(`run-unit-tests: quarantine entry duplicated or also present in the module-mock manifest: ${entry}`);
+        }
+        seen.add(entry);
+        if (!discoveredSet.has(entry)) {
+            throw new Error(`run-unit-tests: force-exit quarantine entry not found in build output: ${entry} ` +
+                `(rebuild with 'npm run build', or remove it from FORCE_EXIT_QUARANTINE if the file was deleted/renamed)`);
+        }
+    }
+}
+/** Selects and validates the requested group's file list from the discovered inventory. */
+export function selectTestGroup(mode, discovered) {
+    if (mode !== "normal" && mode !== "module-mocks") {
+        throw new Error(`run-unit-tests: unknown group "${mode}" (expected "normal" or "module-mocks")`);
+    }
+    validateManifest(discovered);
+    const moduleMockSet = new Set(MODULE_MOCK_MANIFEST);
+    const normal = discovered.filter((file) => {
+        if (moduleMockSet.has(file))
+            return false;
+        if (file.startsWith(INTEGRATION_DIR_PREFIX) && !INTEGRATION_DIR_ALLOWLIST.has(file))
+            return false;
+        if (KNOWN_UNREGISTERED_ORPHANS.has(file))
+            return false;
+        return true;
+    });
+    const overlap = normal.filter((file) => moduleMockSet.has(file));
+    if (overlap.length > 0) {
+        throw new Error(`run-unit-tests: file(s) present in both normal and module-mock groups: ${overlap.join(", ")}`);
+    }
+    const selected = mode === "normal" ? normal : [...MODULE_MOCK_MANIFEST];
+    if (selected.length === 0) {
+        throw new Error(`run-unit-tests: selected group "${mode}" is empty — refusing to run zero tests`);
+    }
+    return selected;
+}
+/**
+ * Greedily packs sorted file paths into batches whose serialized
+ * `execPath ...nodeOptions ...files` command length stays within `maxLength`.
+ * A single file that cannot fit even alone is rejected rather than spawned.
+ */
+export function partitionTestBatches(files, options = {}) {
+    const { execPath = process.execPath, nodeOptions = [], maxLength = MAX_COMMAND_LENGTH } = options;
+    const prefixLength = [execPath, ...nodeOptions].join(" ").length;
+    const batches = [];
+    let current = [];
+    let currentLength = prefixLength;
+    for (const file of files) {
+        const addition = 1 + file.length; // separating space + path
+        if (prefixLength + addition > maxLength) {
+            throw new Error(`run-unit-tests: "${file}" alone exceeds the command-length budget ` +
+                `(${prefixLength + addition} > ${maxLength} chars) — cannot batch it safely`);
+        }
+        if (current.length > 0 && currentLength + addition > maxLength) {
+            batches.push(current);
+            current = [];
+            currentLength = prefixLength;
+        }
+        current.push(file);
+        currentLength += addition;
+    }
+    if (current.length > 0) {
+        batches.push(current);
+    }
+    return batches;
+}
+/** Discovers, selects, batches, and spawns the requested test group; returns an aggregate exit code. */
+export function runSelectedGroup(mode, options) {
+    // Validate the mode before touching the filesystem or spawning anything —
+    // an unknown group must fail fast with no discovery/spawn side effects.
+    if (mode !== "normal" && mode !== "module-mocks") {
+        throw new Error(`run-unit-tests: unknown group "${mode}" (expected "normal" or "module-mocks")`);
+    }
+    const { root, execPath = process.execPath, spawnFn = spawnSync, discoverFn = (opts) => discoverTestFiles(opts), log = console.log, } = options;
+    const discovered = discoverFn({ root });
+    const selected = selectTestGroup(mode, discovered);
+    // Split out the force-exit quarantine: those files run last, each as its own
+    // single-file spawn WITH --test-force-exit (exact tally, prompt exit despite
+    // the leaked handle). Every batched spawn runs WITHOUT the flag so its test
+    // tally stays deterministic — see FORCE_EXIT_QUARANTINE above.
+    const quarantineSet = new Set(FORCE_EXIT_QUARANTINE);
+    const batchable = selected.filter((file) => !quarantineSet.has(file));
+    const quarantined = selected.filter((file) => quarantineSet.has(file));
+    const extraFlags = mode === "module-mocks" ? ["--experimental-test-module-mocks"] : [];
+    const nodeOptions = [...extraFlags, "--test"];
+    const batches = partitionTestBatches(batchable, { execPath, nodeOptions });
+    log(`run-unit-tests: group="${mode}" files=${selected.length} batches=${batches.length}` +
+        (quarantined.length > 0 ? ` quarantined=${quarantined.length}` : ""));
+    let aggregateExit = 0;
+    const spawn = (args) => {
+        const result = spawnFn(execPath, args, {
+            cwd: root,
+            stdio: "inherit",
+            shell: false,
+        });
+        if ((result.status ?? 1) !== 0) {
+            aggregateExit = 1;
+        }
+    };
+    batches.forEach((batch, index) => {
+        log(`run-unit-tests: batch ${index + 1}/${batches.length} (${batch.length} file(s))`);
+        spawn([...nodeOptions, ...batch]);
+    });
+    quarantined.forEach((file, index) => {
+        log(`run-unit-tests: quarantined ${index + 1}/${quarantined.length} ${file} (single-file, --test-force-exit)`);
+        spawn([...nodeOptions, "--test-force-exit", file]);
+    });
+    return aggregateExit;
+}