@bridge_gpt/mcp-server 0.2.66 → 0.2.68

package/build/repair-assets.js

@@ -0,0 +1,93 @@
+import { access, lstat, realpath, readFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import os from "node:os";
+import { WORKFLOW_HOSTS, buildPackagedAssetCatalog } from "./generated-assets-catalog.js";
+import { authorizeAssetRepair, assetRootBinding } from "./generated-assets-context.js";
+import { validateAssetRoot } from "./generated-assets-paths.js";
+import { readMcpInstallState } from "./mcp-install-state.js";
+import { repairPackagedAssets } from "./generated-assets-repair.js";
+import { createConfinedAssetPublisher } from "./generated-assets-publisher.js";
+import { MCP_PACKAGE_NAME } from "./mcp-identity.js";
+import { VERSION } from "./version.generated.js";
+export const REPAIR_ASSETS_HELP = `Usage: repair-assets [--project-root <directory>] [--host <claude|cursor|codex|copilot>]
+Fill missing packaged workflow files only; preserve existing customized files.
+Explicit --project-root plus --host authorizes provisioning without inventory.
+Implicit selection requires root-bound inventory at exact cwd; subdirectories must
+select --project-root. Never infer installed hosts from folders or selectedPlatforms.
+Reports restored/preserved/unreadable/failed files; incomplete repair exits 1.
+Linux procfs supports confined exclusive publication. Other platforms refuse writes
+when a confined adapter is unavailable. Existing readable files remain preserved.
+Excludes custom pipelines/instructions, registrations, credentials, generated outputs,
+onboarding, API setup, and Windsurf. Refresh/reconnect after repair, then run doctor.
+Unpinned npx -y ${MCP_PACKAGE_NAME} repair-assets intentionally selects the latest
+package; use @${VERSION} to repair from this running version.\n`;
+export async function runRepairAssetsCli(argv, options = {}) {
+    const log = options.log ?? (text => process.stdout.write(`${text}\n`));
+    const error = options.error ?? (text => process.stderr.write(`${text}\n`));
+    if (argv.length === 1 && (argv[0] === "--help" || argv[0] === "-h")) {
+        log(REPAIR_ASSETS_HELP);
+        return 0;
+    }
+    let requestedRoot;
+    const hosts = [];
+    for (let i = 0; i < argv.length; i++) {
+        const flag = argv[i];
+        const value = argv[++i];
+        if (!value || value.startsWith("--")) {
+            error("repair-assets: missing option value; use --help.");
+            return 1;
+        }
+        if (flag === "--project-root" && !requestedRoot)
+            requestedRoot = value;
+        else if (flag === "--host" && WORKFLOW_HOSTS.includes(value))
+            hosts.push(value);
+        else {
+            error("repair-assets: unknown, duplicate, or invalid option; use --help.");
+            return 1;
+        }
+    }
+    const fs = options.fs ?? { lstat, realpath, readFile: (p) => readFile(p, "utf-8"), access: (p) => access(p, constants.R_OK) };
+    const root = await validateAssetRoot(requestedRoot ?? options.cwd ?? process.cwd(), options.home ?? os.homedir(), fs);
+    if (!root) {
+        error("repair-assets: select an existing canonical project directory, excluding home and filesystem roots.");
+        return 1;
+    }
+    const state = await readMcpInstallState(root, fs);
+    const inventory = state.status === "valid" ? state.state.packagedAssets : undefined;
+    const explicitPair = requestedRoot !== undefined && hosts.length > 0;
+    const selected = [...new Set(hosts.length ? hosts : inventory?.assets.map(a => a.host) ?? [])];
+    if (!authorizeAssetRepair(root, selected, explicitPair, inventory)) {
+        error("repair-assets: installation context is uncertain. Supply both --project-root and --host for explicit provisioning.");
+        return 1;
+    }
+    log(`Selected project root: ${root}`);
+    log(`Invoking package: ${VERSION}; ${explicitPair ? "explicit fill-only provisioning" : "inventory-authorized repair"}.`);
+    const boundInventory = inventory?.rootBinding === assetRootBinding(root) ? inventory : undefined;
+    if (boundInventory)
+        log(`Recorded package: ${boundInventory.packageVersion}; invoking bundle may differ.`);
+    const catalog = buildPackagedAssetCatalog();
+    if (boundInventory) {
+        const historical = new Set(boundInventory.assets.map(a => a.id));
+        const introduced = catalog.assets.filter(a => a.hosts.some(h => selected.includes(h)) && !historical.has(a.id));
+        log(`Newly introduced catalog assets: ${introduced.length} (provisioning, not historical loss).`);
+    }
+    try {
+        const result = await (options.repair ?? repairPackagedAssets)({ root, hosts: selected, explicitPair, inventory: boundInventory, fs,
+            catalog, publisher: options.publisher ?? createConfinedAssetPublisher(options.platform) });
+        for (const status of ["restored", "preserved", "unreadable", "failed"]) {
+            const items = result.findings.filter(f => f.status === status);
+            log(`${status}: ${items.length}${items.length ? ` (${items.slice(0, 5).map(f => `${f.destination}: ${f.reason}`).join(", ")}${items.length > 5 ? ", …" : ""})` : ""}`);
+        }
+        if (result.packageProblems.length)
+            error(`Package problems: ${result.packageProblems.join(", ")}`);
+        if (result.cleanupFailures.length)
+            error("Some owned temporary files could not be removed. Inspect .bridge-repair-*.tmp in the reported asset parents; do not remove other files.");
+        if (!result.complete)
+            error("repair-assets: requested availability restoration is incomplete. Resolve reported permission/path/platform problems before retrying.");
+        return result.complete ? 0 : 1;
+    }
+    catch {
+        error("repair-assets: repair failed; no unsafe fallback was attempted.");
+        return 1;
+    }
+}

package/build/review-generation.js

@@ -193,6 +193,28 @@ export class ReviewGenerationRegistry {
             return null;
         return { baseline: entry.baseline, expectedLegCount: entry.expectedLegCount };
     }
+    /**
+     * Consecutive all-`404` wait windows recorded for the live submission
+     * (BAPI-1382), or `0` when there is none or no live entry.
+     */
+    notFoundWindowCount(repoName, ticketNumber) {
+        this.evictExpired();
+        return this.entries.get(baselineKey(repoName, ticketNumber))?.notFoundWindows ?? 0;
+    }
+    /** Count one more all-`404` wait window for the live submission. No-op without one. */
+    noteNotFoundWindow(repoName, ticketNumber) {
+        this.evictExpired();
+        const entry = this.entries.get(baselineKey(repoName, ticketNumber));
+        if (!entry)
+            return;
+        entry.notFoundWindows = (entry.notFoundWindows ?? 0) + 1;
+    }
+    /** A non-`404` observation resets the count. No-op without a live entry. */
+    resetNotFoundWindows(repoName, ticketNumber) {
+        const entry = this.entries.get(baselineKey(repoName, ticketNumber));
+        if (entry)
+            entry.notFoundWindows = 0;
+    }
     /**
      * Consume a baseline. Clearing means "durable persistence has happened",
      * not "a terminal envelope was received" (BAPI-1129) — the anchor is

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

@@ -16,7 +16,8 @@
  * 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 { readdirSync, mkdtempSync, mkdirSync, readFileSync, writeFileSync, renameSync, rmSync, existsSync } from "fs";
+import { tmpdir } from "os";
 import { spawnSync } from "child_process";
 import path from "path";
 const DEFAULT_BUILD_DIR = "build";
@@ -76,6 +77,7 @@ export const MODULE_MOCK_MANIFEST = [
     "build/connect-github.test.js",
     "build/council-submission.test.js",
     "build/council-wait-recovery.test.js",
+    "build/generated-assets-publisher.test.js",
     "build/index-artifacts.test.js",
     "build/index-council-filenames.test.js",
     "build/index-generate-decision-page.integration.test.js",
@@ -314,27 +316,31 @@ export function selectTestGroup(mode, discovered) {
  */
 export function partitionTestBatches(files, options = {}) {
     const { execPath = process.execPath, nodeOptions = [], maxLength = MAX_COMMAND_LENGTH } = options;
-    const prefixLength = [execPath, ...nodeOptions].join(" ").length;
+    const size = (batch, index) => {
+        const args = options.argumentBuilder?.(batch, index) ?? [...nodeOptions, ...batch];
+        // Quoted serialization conservatively includes spaces/backslashes/quotes on
+        // Windows; legacy callers without an argument builder keep their old budget.
+        return options.argumentBuilder
+            ? [execPath, ...args].map((arg) => JSON.stringify(arg)).join(" ").length
+            : [execPath, ...args].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 (size([file], batches.length) > maxLength) {
+            throw new Error(`run-unit-tests: single file alone exceeds the command-length budget`);
         }
-        if (current.length > 0 && currentLength + addition > maxLength) {
+        if (current.length && size([...current, file], batches.length) > maxLength) {
             batches.push(current);
             current = [];
-            currentLength = prefixLength;
+            if (size([file], batches.length) > maxLength) {
+                throw new Error(`run-unit-tests: single file alone exceeds the command-length budget`);
+            }
         }
         current.push(file);
-        currentLength += addition;
     }
-    if (current.length > 0) {
+    if (current.length)
         batches.push(current);
-    }
     return batches;
 }
 /** Discovers, selects, batches, and spawns the requested test group; returns an aggregate exit code. */
@@ -355,30 +361,7 @@ export function runSelectedGroup(mode, options) {
     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;
+    return runWithReports(mode, options, batchable, quarantined, [...extraFlags, "--test"], log);
 }
 /**
  * Returns the integration lane's file list: every compiled `*.test.js` under
@@ -420,20 +403,118 @@ export function runIntegrationLane(options) {
         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}`);
+    return runWithReports("integration", options, selected, [], ["--test"], log);
+}
+/** Shared reporter argument builder: sizing and execution cannot diverge. */
+export function reporterArguments(nodeOptions, files, destination, forceExit = false) {
+    return [...nodeOptions, ...(forceExit ? ["--test-force-exit"] : []),
+        "--test-reporter=spec", "--test-reporter-destination=stdout",
+        "--test-reporter=junit", `--test-reporter-destination=${destination}`, ...files];
+}
+function runWithReports(group, options, ordinary, quarantined, nodeOptions, log) {
+    const { root, execPath = process.execPath, spawnFn = spawnSync } = options;
+    const retained = options.reportOutputDirectory !== undefined;
+    let directory;
     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;
+    try {
+        if (retained) {
+            if (!options.reportOutputDirectory?.trim())
+                throw new Error("empty report directory");
+            directory = path.resolve(options.reportOutputDirectory);
+            // Exclusive allocation refuses stale reports and concurrent invocations.
+            mkdirSync(directory, { recursive: false });
         }
-    });
+        else {
+            directory = mkdtempSync(path.join(tmpdir(), "bridge-junit-"));
+        }
+        const outputDirectory = directory;
+        const reportName = (index) => `report-${index}.xml`;
+        const args = (files, index, forceExit = false) => reporterArguments(nodeOptions, files, path.join(outputDirectory, reportName(index)), forceExit);
+        // Source mapping comes from the build's actual rootDir/outDir, including
+        // authored scripts (which do not pass through tsc).
+        const config = JSON.parse(readFileSync(new URL("../tsconfig.json", import.meta.url), "utf8"));
+        const { rootDir, outDir } = config.compilerOptions;
+        if (rootDir !== "src" || outDir !== "build")
+            throw new Error("unsupported build source mapping");
+        const sourceFor = (file) => {
+            const posix = file.replaceAll("\\", "/");
+            if (posix.startsWith(`${outDir}/`) && posix.endsWith(".js")) {
+                return `mcp_server/${rootDir}/${posix.slice(outDir.length + 1, -3)}.ts`;
+            }
+            if (posix.startsWith("scripts/") && posix.endsWith(".js"))
+                return `mcp_server/${posix}`;
+            throw new Error("unmapped test source");
+        };
+        // Node 24.16 discovery confirmed explicit testcase file attribution.
+        // Older local/scheduled runtimes use one source per invocation, so the
+        // inventory provides an unambiguous fallback without adding concurrency.
+        const [major, minor] = process.versions.node.split(".").map(Number);
+        const explicitAttribution = major > 24 || (major === 24 && minor >= 16);
+        const batches = explicitAttribution
+            ? partitionTestBatches(ordinary, { execPath, nodeOptions, argumentBuilder: args })
+            : ordinary.map((file, index) => {
+                partitionTestBatches([file], { execPath, argumentBuilder: (files) => args(files, index) });
+                return [file];
+            });
+        const plans = [];
+        const addPlan = (files, forceExit) => {
+            const index = plans.length;
+            partitionTestBatches(files, { execPath, argumentBuilder: (values) => args(values, index, forceExit) });
+            const sources = Object.fromEntries(files.map((file) => [`mcp_server/${file}`, sourceFor(file)]));
+            // integrationSuite declares skipped suites inside the shared harness;
+            // Node attributes those cases to the wrapper, rather than its caller.
+            // Map that real declaration source using the same verified build config.
+            // Older runtimes still need exactly one entry for invocation attribution.
+            const harness = `${outDir}/integration/harness.js`;
+            if (group === "integration" && explicitAttribution &&
+                existsSync(path.join(root, harness)) &&
+                existsSync(path.join(root, rootDir, "integration/harness.ts"))) {
+                sources[`mcp_server/${harness}`] = sourceFor(harness);
+            }
+            plans.push({ report: reportName(index), files, forceExit, state: "planned", status: null,
+                sources });
+        };
+        batches.forEach((batch) => addPlan(batch, false));
+        quarantined.forEach((file) => addPlan([file], true));
+        const inventory = { version: 1, lane: group === "integration" ? "integration" : "unit", group,
+            nodeVersion: process.version, attribution: explicitAttribution ? "reporter-file" : "single-source", spawns: plans };
+        const publish = () => {
+            const temporary = path.join(outputDirectory, "inventory.json.tmp");
+            writeFileSync(temporary, JSON.stringify(inventory, null, 2));
+            renameSync(temporary, path.join(outputDirectory, "inventory.json"));
+        };
+        publish(); // Complete expected inventory is durable before the first spawn.
+        log(`run-unit-tests: group="${group}" files=${ordinary.length + quarantined.length} batches=${plans.length}`);
+        for (const [index, plan] of plans.entries()) {
+            plan.state = "started";
+            publish();
+            try {
+                const result = spawnFn(execPath, args(plan.files, index, plan.forceExit), { cwd: root, stdio: "inherit", shell: false });
+                plan.status = result.status;
+                plan.state = result.status === null || !existsSync(path.join(outputDirectory, plan.report)) ? "failed" : "completed";
+            }
+            catch {
+                plan.state = "failed";
+            }
+            if (plan.state !== "completed" || plan.status !== 0)
+                aggregateExit = 1;
+            publish();
+        }
+    }
+    catch {
+        // No exception/environment dump reaches CI logs or exported evidence.
+        log("run-unit-tests: report allocation, inventory publication, or execution failed");
+        aggregateExit = 1;
+    }
+    finally {
+        if (!retained && directory) {
+            try {
+                rmSync(directory, { recursive: true, force: true });
+            }
+            catch {
+                aggregateExit = 1;
+            }
+        }
+    }
     return aggregateExit;
 }

package/build/secret-redaction.js

@@ -0,0 +1,33 @@
+/** Shared leaf scrubber for durable untrusted text. */
+const REDACTED = "[REDACTED]";
+/**
+ * Patterns for values that must never reach durable state or a log line.
+ *
+ * Each rewrites only the secret itself and keeps the surrounding key or scheme, so a
+ * redacted record still shows *that* a credential was involved — useful for audit,
+ * and materially different from dropping the field.
+ */
+const SECRET_PATTERNS = [
+    // Bearer / token schemes in an Authorization header or bare.
+    [/\b(Bearer|Basic|Token)\s+[A-Za-z0-9._~+/=-]{8,}/gi, `$1 ${REDACTED}`],
+    // authorization: <anything>
+    [/\b(authorization)\s*[:=]\s*\S+/gi, `$1: ${REDACTED}`],
+    // Well-known provider key shapes.
+    [/\b(sk|pk|rk)-[A-Za-z0-9_-]{16,}/g, REDACTED],
+    [/\bgh[pousr]_[A-Za-z0-9]{16,}/g, REDACTED],
+    // key/secret/password/token assignments in prose, env, JSON, or CLI form.
+    [
+        /\b([A-Za-z0-9_-]*(?:api[_-]?key|secret|password|passwd|token|credential)[A-Za-z0-9_-]*)\s*[:=]\s*("[^"]*"|'[^']*'|\S+)/gi,
+        `$1=${REDACTED}`,
+    ],
+    // Credentials embedded in a URL.
+    [/\b([a-z][a-z0-9+.-]*:\/\/)[^/\s:@]+:[^/\s@]+@/gi, `$1${REDACTED}@`],
+];
+/** Redact secret-bearing substrings while leaving safe technical text intact. */
+export function redactSecrets(value) {
+    let output = value;
+    for (const [pattern, replacement] of SECRET_PATTERNS) {
+        output = output.replace(pattern, replacement);
+    }
+    return output;
+}