@bridge_gpt/mcp-server 0.2.41 → 0.2.43

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

@@ -20,6 +20,20 @@ import { readdirSync } from "fs";
 import { spawnSync } from "child_process";
 import path from "path";
 const DEFAULT_BUILD_DIR = "build";
+// BAPI-877 — the SECOND directory the unit lane discovers. `mcp_server/scripts/`
+// holds hand-authored ESM (`"type": "module"`) that the build itself runs:
+// bundle-version.js, sync-agent-mirrors.js, and friends. They are NOT tsc inputs
+// (tsconfig.json is rootDir "src" / include "src/**/*.ts"), so they compile to
+// nothing and a `*.test.js` beside them has no build/ counterpart to discover.
+// Before this constant existed, such a file ran in NO lane at all: not `npm
+// test` (which walked build/ only), not the integration lane, not the pre-push
+// gate. sync-agent-mirrors.test.js sat unrun for months that way.
+//
+// Discovered from source rather than from build/ for that reason, and unioned
+// into the "normal" group — a `scripts/…` path can never match the
+// build/integration/ prefix, so it needs no filter change to land there.
+const SCRIPT_TEST_DIR = "scripts";
+export const SCRIPTS_DIR_PREFIX = "scripts/";
 // 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
@@ -28,9 +42,9 @@ const DEFAULT_BUILD_DIR = "build";
 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.
+// build/ OR scripts/ 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",
@@ -40,6 +54,8 @@ export const MODULE_MOCK_MANIFEST = [
     "build/conductor/git-inspection.test.js",
     "build/conductor/paths.test.js",
     "build/conductor/pr-ci-producer-emit-seam.test.js",
+    "build/conductor/recovery-cli.test.js",
+    "build/conductor/recovery-operations.test.js",
     "build/conductor/security-regressions.test.js",
     "build/conductor/store-lifecycle.test.js",
     "build/conductor/store-queries.test.js",
@@ -57,6 +73,7 @@ export const MODULE_MOCK_MANIFEST = [
     "build/index-heavy-read-truncation.test.js",
     "build/index-output-path.test.js",
     "build/index.review-rounds.test.js",
+    "build/plane/cli.test.js",
     "build/recovery-formatting.test.js",
     "build/sfcc/client.test.js",
     "build/sfcc/permissions.test.js",
@@ -95,8 +112,24 @@ export const FORCE_EXIT_QUARANTINE = ["build/secret-safety.test.js"];
 // 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/";
+export const INTEGRATION_DIR_PREFIX = "build/integration/";
 const INTEGRATION_DIR_ALLOWLIST = new Set(["build/integration/measure-tools.test.js"]);
+// BAPI-848 — files under build/integration/ that belong to a DIFFERENT lane and
+// must therefore be excluded from integration discovery:
+//
+//  * measure-tools.test.js       runs in the normal unit lane (allowlisted above)
+//  * packaged-cli-smoke.test.js  runs in `npm run test:smoke`
+//
+// This set is the entire registration surface for the integration lane. Adding a
+// new build/integration/*.test.js requires editing NOTHING — which is the point:
+// the old scripts.test:integration named every file explicitly on one line, so
+// every ticket adding an integration test had to edit a line shared with every
+// other integration test, and a file whose name was forgotten ran in no lane at
+// all.
+export const INTEGRATION_DISCOVERY_EXCLUSIONS = [
+    "build/integration/measure-tools.test.js",
+    "build/integration/packaged-cli-smoke.test.js",
+];
 // Compiled test files that live OUTSIDE build/integration/ but still belong to
 // the separately-invoked `npm run test:integration` lane, so the unit lane must
 // skip them. BAPI-683 originally introduced this set as
@@ -112,6 +145,10 @@ const INTEGRATION_DIR_ALLOWLIST = new Set(["build/integration/measure-tools.test
 // discovered into the unit lane automatically and needs no registration —
 // tests/pytest/mcp/test_mcp_server_test_registration_multicomponent.py fails if
 // a *.integration.test.ts ends up in neither lane.
+//
+// BAPI-877 — a `scripts/…` path must NEVER be listed here. This is not a style
+// rule: `discoverIntegrationTestFiles` walks build/ only, so the entry would fail
+// its own presence check below and throw on EVERY `npm run test:integration` run.
 export const INTEGRATION_LANE_ONLY = [
     "build/conductor/conductor-runtime.integration.test.js",
 ];
@@ -144,6 +181,55 @@ export function discoverTestFiles(options) {
     results.sort();
     return results;
 }
+/**
+ * BAPI-877 — hand-authored `scripts/*.test.js`, sorted and package-relative.
+ *
+ * A thin delegation rather than a second walker: `buildDir` already generalizes
+ * (the walk is directory-agnostic and `path.relative(root, …)` yields
+ * `scripts/x.test.js` for free), and duplicating the ENOENT swallow, the sort,
+ * and the separator normalization would be three chances to diverge.
+ *
+ * Deliberately does NOT apply the empty-discovery guard — `discoverUnitTestFiles`
+ * owns that, so this stays a pure query usable in isolation.
+ */
+export function discoverScriptTestFiles(options) {
+    return discoverTestFiles({ ...options, buildDir: SCRIPT_TEST_DIR });
+}
+/**
+ * BAPI-877 — everything the unit lane runs: compiled `build/**` plus authored
+ * `scripts/**`.
+ *
+ * WHY THE EMPTY-SCRIPTS GUARD IS SEPARATE. `selectTestGroup`'s "selected group
+ * is empty" refusal cannot fire for this: ~390 compiled files are always
+ * present, so a scripts-discovery regression would be masked and the lane would
+ * report green over zero scripts tests — the exact "coverage that exists only if
+ * someone runs it by hand" failure BAPI-877 exists to remove. Refusing here
+ * matches `runIntegrationLane` and `discoverIntegrationTestFiles`, which take the
+ * same posture for the same reason.
+ *
+ * The cost is deliberate: deleting every `scripts/*.test.js` breaks `npm test`
+ * until someone edits this file. Deleting all coverage for the build's version
+ * generator and agent-mirror synchronizer SHOULD require touching the line that
+ * says so, rather than silently shrinking the suite.
+ *
+ * WHY IT LIVES HERE and not in `runSelectedGroup`: the guard belongs on the
+ * production path only. Every test that injects its own `discoverFn` supplies a
+ * build-only fixture tree, and firing there would force `scripts/*` entries into
+ * BASELINE_NORMAL_FILES — falsifying the independent historical oracle this
+ * suite is built on.
+ */
+export function discoverUnitTestFiles(options) {
+    const compiled = discoverTestFiles(options);
+    const authored = discoverScriptTestFiles(options);
+    if (authored.length === 0) {
+        throw new Error(`run-unit-tests: discovered zero ${SCRIPTS_DIR_PREFIX}*.test.js under ` +
+            `"${options.root}" — refusing to run. A scripts-lane discovery regression is ` +
+            `invisible beside the compiled tests that still ran, which is the failure ` +
+            `this lane exists to prevent (BAPI-877). If ${SCRIPTS_DIR_PREFIX} genuinely ` +
+            `has no test file any more, remove this guard deliberately.`);
+    }
+    return [...compiled, ...authored].sort();
+}
 /** Throws if the module-mock, force-exit-quarantine, or integration-lane manifest has drifted from the discovered build output. */
 export function validateManifest(discovered) {
     const discoveredSet = new Set(discovered);
@@ -248,8 +334,8 @@ export function runSelectedGroup(mode, options) {
     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 { root, execPath = process.execPath, spawnFn = spawnSync, discoverFn = (opts) => discoverUnitTestFiles(opts), fsImpl, log = console.log, } = options;
+    const discovered = discoverFn({ root, fsImpl });
     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
@@ -284,3 +370,60 @@ export function runSelectedGroup(mode, options) {
     });
     return aggregateExit;
 }
+/**
+ * Returns the integration lane's file list: every compiled `*.test.js` under
+ * `build/integration/` except the files belonging to another lane, plus the
+ * explicitly-registered files that live outside that directory
+ * (:data:`INTEGRATION_LANE_ONLY`). Sorted and package-relative.
+ *
+ * BAPI-848. Discovery replaced a hand-maintained enumeration in
+ * `scripts.test:integration`. A directory glob in the npm script itself was NOT
+ * viable: the MCP suite runs on Windows in CI, where npm runs scripts through
+ * cmd.exe and `*` is never expanded, so the script would have been silently
+ * handed a literal path and run zero tests.
+ */
+export function discoverIntegrationTestFiles(options) {
+    const discovered = discoverTestFiles(options);
+    const excluded = new Set(INTEGRATION_DISCOVERY_EXCLUSIONS);
+    const fromDirectory = discovered.filter((file) => file.startsWith(INTEGRATION_DIR_PREFIX) && !excluded.has(file));
+    // The outside-directory entries stay explicit and are VALIDATED against the
+    // build output, so a renamed or deleted file fails loudly instead of silently
+    // dropping out of every lane.
+    const discoveredSet = new Set(discovered);
+    for (const entry of INTEGRATION_LANE_ONLY) {
+        if (!discoveredSet.has(entry)) {
+            throw new Error(`run-integration-tests: integration-lane entry not found in build output: ${entry} ` +
+                `(rebuild with 'npm run build', or remove it from INTEGRATION_LANE_ONLY if the file was deleted/renamed)`);
+        }
+    }
+    const selected = [...new Set([...fromDirectory, ...INTEGRATION_LANE_ONLY])];
+    selected.sort();
+    return selected;
+}
+/** Discovers, batches, and spawns the integration lane; returns an aggregate exit code. */
+export function runIntegrationLane(options) {
+    const { root, execPath = process.execPath, spawnFn = spawnSync, discoverFn = (opts) => discoverIntegrationTestFiles(opts), log = console.log, } = options;
+    const selected = discoverFn({ root });
+    if (selected.length === 0) {
+        // Refusing beats reporting a green run over zero files — a discovery bug
+        // that silently selected nothing would look exactly like a passing suite.
+        throw new Error("run-integration-tests: discovered zero integration tests — refusing to run " +
+            "(did you forget 'npm run build'?)");
+    }
+    const nodeOptions = ["--test"];
+    const batches = partitionTestBatches(selected, { execPath, nodeOptions });
+    log(`run-integration-tests: files=${selected.length} batches=${batches.length}`);
+    let aggregateExit = 0;
+    batches.forEach((batch, index) => {
+        log(`run-integration-tests: batch ${index + 1}/${batches.length} (${batch.length} file(s))`);
+        const result = spawnFn(execPath, [...nodeOptions, ...batch], {
+            cwd: root,
+            stdio: "inherit",
+            shell: false,
+        });
+        if ((result.status ?? 1) !== 0) {
+            aggregateExit = 1;
+        }
+    });
+    return aggregateExit;
+}

package/build/schedule-run.js

@@ -23,6 +23,7 @@ import { getAgentLauncher, formatValidAgentLauncherNames } from "./agent-launche
 import { resolveCommandOnPath } from "./agent-launchers/claude.js";
 import { discoverCommandCatalog, resolveSchedulableCommand, validateCommandArgv, } from "./command-catalog.js";
 import { buildTargetCommandLine } from "./scheduled-prompt.js";
+import { MCP_PACKAGE_NAME } from "./mcp-identity.js";
 /**
  * Default deps backed by real subprocesses / process state. Subprocess execution
  * uses `execFile` (list-based, never `shell: true`) and supports
@@ -96,7 +97,7 @@ const SCHEDULE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
 export function getScheduleRunUsage() {
     return [
         "Usage:",
-        "  npx -y @bridge_gpt/mcp-server schedule-run <create|list|cancel|doctor> [flags]",
+        `  npx -y ${MCP_PACKAGE_NAME} schedule-run <create|list|cancel|doctor> [flags]`,
         "",
         "Schedules a local, one-shot run of ANY Bridge slash-command automation (from",
         "the repo's .claude/commands/*.md catalog) at a chosen time using an OS-native",
@@ -659,7 +660,7 @@ export async function resolveScheduleCreateInput(options, runAtIso, deps) {
     if (isTransientNpxEntryPath(cliEntryPath)) {
         warnings.push(`The scheduled run re-enters this CLI at '${cliEntryPath}', which is inside an npx cache ` +
             "directory. npx caches can be pruned before a future schedule fires, which would make the " +
-            "run fail with ENOENT. Install the CLI persistently (e.g. `npm i -g @bridge_gpt/mcp-server`) " +
+            `run fail with ENOENT. Install the CLI persistently (e.g. \`npm i -g ${MCP_PACKAGE_NAME}\`) ` +
             "and schedule with the installed binary so the trigger path stays stable.");
     }
     const paths = getSchedulePaths(id, deps.homeDir, deps.platform);