@bridge_gpt/mcp-server 0.2.34 → 0.2.36

package/build/install-reexec.js

@@ -0,0 +1,233 @@
+/**
+ * Installer-owned self-re-exec from `@latest` (BAPI-714, Group B).
+ *
+ * WHY THIS EXISTS. The documented setup command dropped `@latest`
+ * (`npx -y @bridge_gpt/mcp-server install`), and an UNPINNED npx spec silently
+ * reuses a stale cached copy — the verified bug recorded in `init.ts:32-38`,
+ * where 0.2.6 persisted across an upgrade. So the install path must do for itself
+ * what `upgrade` already does: look up the latest published version and, when the
+ * local copy is strictly older, hand off to `@latest`.
+ *
+ * THREE PROPERTIES ARE LOAD-BEARING.
+ *
+ *  1. FAIL OPEN, ALWAYS. `upgrade` can afford to fail; `install` is someone's
+ *     first contact with Bridge. An unreachable, slow, non-2xx, or malformed
+ *     registry means "run the local copy" — never an error, prompt, or stall.
+ *  2. `stdio: "inherit"` IS NOT STYLISTIC. `promptSecret`/`promptLine`/
+ *     `promptMultiSelect` are wired only when `process.stdin.isTTY`
+ *     (`install-bridge.ts:1195`, `:1224-1226`); non-inherited stdio silently
+ *     strips all three and turns an interactive install into a non-interactive
+ *     one with no error.
+ *  3. THE SENTINEL IS STRIPPED BEFORE *ANY* ARGV INTERPRETATION. Two verified
+ *     reasons: `parseInstallBridgeArgs` rejects unrecognized arguments, so a
+ *     leftover `--internal-reexec` is an argument error on the child run; and
+ *     `install-bridge.ts:1690` computes `isBareInvocation = argv.length === 0`,
+ *     so a leftover sentinel makes the child take a DIFFERENT onboarding branch
+ *     silently. Its presence is also the terminating condition, so exactly one
+ *     re-exec is possible per invocation.
+ *
+ * SECRET DISCIPLINE. Child argv is process-visible (`ps`), so `--api-key <value>`
+ * and a VALUED `--invite <token>` are lifted out of argv and forwarded only
+ * through the child ENVIRONMENT as `BAPI_API_KEY` / `BAPI_INVITE`. A value-less
+ * `--invite` marker is deliberately RETAINED in child argv: it is what selects
+ * bootstrap-invite mode, and dropping it would leave `argv.length === 0` and send
+ * the child down the bare-onboarding branch instead. The failure diagnostic is a
+ * fixed string — it interpolates no argv, no environment value, and no exception
+ * text.
+ */
+import { spawn } from "child_process";
+import { VERSION } from "./version.generated.js";
+import { isNewerVersion } from "./update-check.js";
+import { fetchLatestVersion } from "./cli-release.js";
+import { runInstallBridgeCli } from "./install-bridge.js";
+/** The sentinel that marks an already-re-exec'd child. Matches `upgrade-cli.ts`. */
+export const INSTALL_REEXEC_SENTINEL = "--internal-reexec";
+/**
+ * The ONLY text emitted when the hand-off itself fails. Fixed by construction —
+ * no argv, no environment value, no raw exception message, no credential.
+ */
+export const INSTALL_REEXEC_FAILURE_MESSAGE = "Bridge API install failed: could not run the latest installer.";
+/**
+ * Remove EVERY `--internal-reexec` occurrence and report whether any was present.
+ *
+ * Called before nested-command detection, before the re-exec decision, and before
+ * anything is handed to `runInstallBridgeCli` — the sentinel must never reach the
+ * installer's strict argument parser or its bare-invocation computation.
+ */
+export function stripInternalReexecSentinels(argv) {
+    const args = [];
+    let sentinelPresent = false;
+    for (const arg of argv) {
+        if (arg === INSTALL_REEXEC_SENTINEL) {
+            sentinelPresent = true;
+            continue;
+        }
+        args.push(arg);
+    }
+    return { args, sentinelPresent };
+}
+/**
+ * Lift secret-valued flags out of argv and into a child-environment overlay.
+ *
+ * Mirrors `parseInstallBridgeArgs` token-for-token so the two never disagree:
+ *
+ *  - `--api-key=<value>` / `--api-key <value>` → `BAPI_API_KEY`, flag AND value
+ *    removed. The installer resolves the key from the environment, and
+ *    `hasEnvApiKey` keeps the bare-interactive chooser suppressed exactly as the
+ *    flag did.
+ *  - `--invite=<token>` / `--invite <token>` → `BAPI_INVITE`, with a VALUE-LESS
+ *    `--invite` left in argv. That marker still selects bootstrap-invite mode and
+ *    the installer falls back to `BAPI_INVITE` for the token.
+ *  - MALFORMED forms (`--api-key` at end of argv, `--api-key=`, `--invite=`) are
+ *    left untouched so the installer's own parser produces the established
+ *    argument error rather than this layer inventing a new one.
+ *
+ * Every other argument is preserved byte-for-byte in its original order. This is
+ * deliberately NOT `sanitizePrewarmEnv()` from `install-bridge.ts`: that helper
+ * STRIPS installer credentials for a `--version` probe and has the opposite
+ * contract from this hand-off.
+ */
+export function prepareInstallReexecArguments(argv) {
+    const forwardedArgs = [];
+    const secretEnv = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--api-key" || arg.startsWith("--api-key=")) {
+            let value;
+            let consumedNext = false;
+            if (arg.startsWith("--api-key=")) {
+                value = arg.slice("--api-key=".length);
+            }
+            else if (i + 1 < argv.length) {
+                value = argv[i + 1];
+                consumedNext = true;
+            }
+            // Blank / absent value == malformed: hand it to the installer's parser.
+            if (value === undefined || value.length === 0) {
+                forwardedArgs.push(arg);
+                continue;
+            }
+            secretEnv.BAPI_API_KEY = value;
+            if (consumedNext)
+                i += 1;
+            continue;
+        }
+        if (arg === "--invite" || arg.startsWith("--invite=")) {
+            if (arg.startsWith("--invite=")) {
+                const value = arg.slice("--invite=".length);
+                if (value.length === 0) {
+                    // Malformed: leave it for the installer's parser.
+                    forwardedArgs.push(arg);
+                    continue;
+                }
+                secretEnv.BAPI_INVITE = value;
+                forwardedArgs.push("--invite");
+                continue;
+            }
+            // Bare `--invite`: only a following NON-flag token is its value, exactly as
+            // `parseInstallBridgeArgs` reads it.
+            const next = argv[i + 1];
+            forwardedArgs.push("--invite");
+            if (typeof next === "string" && !next.startsWith("-") && next.length > 0) {
+                secretEnv.BAPI_INVITE = next;
+                i += 1;
+            }
+            continue;
+        }
+        forwardedArgs.push(arg);
+    }
+    return { forwardedArgs, secretEnv };
+}
+/**
+ * The public `install` / legacy `install-bridge` entry point.
+ *
+ * Fail-open ordering, in the only order that is safe:
+ *
+ *  1. Strip sentinels (before anything reads argv).
+ *  2. If a sentinel was present, or the first remaining token is `conductor`,
+ *     delegate straight to the local installer — no registry lookup, no spawn.
+ *     The nested `install conductor` surface is intercepted inside
+ *     `runInstallBridgeCli`, so it must reach it as `["conductor", ...]` rather
+ *     than being collapsed into bare onboarding.
+ *  3. Otherwise look up the latest version, defaulting the comparison target to
+ *     the local `VERSION` so an unusable answer changes nothing.
+ *  4. Re-exec only for a STRICTLY newer published version.
+ */
+export async function runInstallBridgeWithLatestCli(argv, deps = {}) {
+    const resolveLatest = deps.fetchLatestVersion ?? (() => fetchLatestVersion());
+    const runLocal = deps.runInstallBridgeCli ?? runInstallBridgeCli;
+    const doSpawn = deps.spawn ?? spawn;
+    const env = deps.env ?? process.env;
+    const platform = deps.platform ?? process.platform;
+    const cwd = deps.cwd ?? process.cwd();
+    const errorLog = deps.errorLog ?? ((message) => console.error(message));
+    const localVersion = deps.localVersion ?? VERSION;
+    const { args: cleanedArgs, sentinelPresent } = stripInternalReexecSentinels(argv);
+    // Terminating condition, and the nested-conductor bypass. Both skip the
+    // registry entirely.
+    if (sentinelPresent || cleanedArgs[0] === "conductor") {
+        return runLocal(cleanedArgs);
+    }
+    // Default the comparison target to the local version: an unusable registry
+    // answer must be indistinguishable from "already current".
+    let latestVersion = localVersion;
+    let fetched = null;
+    try {
+        fetched = await resolveLatest();
+    }
+    catch {
+        fetched = null;
+    }
+    if (fetched)
+        latestVersion = fetched;
+    if (!isNewerVersion(localVersion, latestVersion)) {
+        return runLocal(cleanedArgs);
+    }
+    const { forwardedArgs, secretEnv } = prepareInstallReexecArguments(cleanedArgs);
+    const npxCmd = platform === "win32" ? "npx.cmd" : "npx";
+    const childArgs = [
+        "-y",
+        "@bridge_gpt/mcp-server@latest",
+        "install",
+        INSTALL_REEXEC_SENTINEL,
+        ...forwardedArgs,
+    ];
+    return new Promise((resolve) => {
+        let settled = false;
+        const settle = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(code);
+        };
+        const fail = () => {
+            errorLog(INSTALL_REEXEC_FAILURE_MESSAGE);
+            settle(1);
+        };
+        let child;
+        try {
+            child = doSpawn(npxCmd, childArgs, {
+                shell: false,
+                stdio: "inherit",
+                cwd,
+                // Explicit CLI values win over an inherited value of the same key.
+                env: { ...env, ...secretEnv },
+            });
+        }
+        catch {
+            fail();
+            return;
+        }
+        child.on("close", (code) => {
+            // A signal termination or an absent numeric code is an abnormal exit.
+            if (typeof code === "number") {
+                settle(code);
+                return;
+            }
+            fail();
+        });
+        child.on("error", () => {
+            fail();
+        });
+    });
+}

package/build/mcp-host-config.js

@@ -28,6 +28,7 @@
  * rather than reserialize unrelated content.
  */
 import { VERSION } from "./version.generated.js";
+import { refreshBridgeApiPackageSpec } from "./init.js";
 // ---------------------------------------------------------------------------
 // Path helpers (POSIX-normalized; module stays free of node:path).
 // ---------------------------------------------------------------------------
@@ -119,7 +120,16 @@ export function mergeJsonHostConfig(existing, target, adaptedEntry) {
     const root = rootRaw && typeof rootRaw === "object" && !Array.isArray(rootRaw)
         ? { ...rootRaw }
         : {};
-    root["bridge-api"] = adaptedEntry;
+    // BAPI-714 (Group C): an UPDATE to a pre-existing Bridge registration keeps that
+    // registration's own launcher args composition — only the package-spec token is
+    // refreshed — so a global/manual host config written before `serve` existed is
+    // never migrated to it. A registration this path CREATES receives the adapted
+    // template args, `serve` included.
+    const prior = root["bridge-api"];
+    const preservedArgs = prior && typeof prior === "object" && !Array.isArray(prior)
+        ? refreshBridgeApiPackageSpec(prior.args, currentLauncherSpec())
+        : null;
+    root["bridge-api"] = preservedArgs ? { ...adaptedEntry, args: preservedArgs } : adaptedEntry;
     merged[target.topLevelKey] = root;
     return merged;
 }

package/build/mcp-install-state.js

@@ -152,6 +152,10 @@ export async function writeMcpInstallState(cwd, input, deps) {
         projectConfigPaths: normalizeProjectPaths(input.projectConfigPaths),
     };
     const finalPath = installStatePath(cwd);
+    return persistMcpInstallState(cwd, state, finalPath, deps);
+}
+/** Shared serialize-and-atomically-persist tail for the two writers below. */
+async function persistMcpInstallState(cwd, state, finalPath, deps) {
     const tempPath = installStateTempPath(cwd);
     const serialized = serializeMcpInstallState(state);
     try {
@@ -173,3 +177,31 @@ export async function writeMcpInstallState(cwd, input, deps) {
     }
     return { ok: true, path: finalPath, state };
 }
+/**
+ * Record a locally installed project artifact WITHOUT clobbering existing state.
+ *
+ * `writeMcpInstallState` rebuilds the whole document from its `input` — it does
+ * not merge. A caller supplying only `projectConfigPaths` would therefore write
+ * an EMPTY `selectedPlatforms`, silently dropping the platform roster a later
+ * `doctor` run reports from (BAPI-679 review, E-13). This helper reads the
+ * current state first and writes back the union, so the additive record stays
+ * additive.
+ *
+ * Only the repo-relative PATH is stored. No OAuth token, API key, GitHub
+ * credential, or expanded workflow secret can reach the file: the state schema
+ * has no field for one, and the serializer emits only schema-approved keys.
+ */
+export async function recordInstalledProjectArtifact(cwd, relPath, deps) {
+    if (typeof relPath !== "string" || relPath.length === 0) {
+        return { ok: false, error: "artifact path must be a non-empty relative path" };
+    }
+    const existing = await readMcpInstallState(cwd, deps);
+    const priorPlatforms = existing.status === "valid" ? existing.state.selectedPlatforms : [];
+    const priorPaths = existing.status === "valid" ? existing.state.projectConfigPaths : [];
+    const state = {
+        version: MCP_INSTALL_STATE_VERSION,
+        selectedPlatforms: normalizePlatforms(priorPlatforms),
+        projectConfigPaths: normalizeProjectPaths([...priorPaths, relPath]),
+    };
+    return persistMcpInstallState(cwd, state, installStatePath(cwd), deps);
+}

package/build/mcp-provisioning.js

@@ -1,12 +1,15 @@
 /**
  * Worktree MCP registration provisioning.
  *
- * After `start-tickets` creates a worktree, this module writes secret-free MCP
- * registrations into both Claude (`.mcp.json`) and Cursor (`.cursor/mcp.json`)
- * so the configured MCP servers are reachable from either editor. Every
- * generated entry contains NO `env` block — it points at the `mcp-invoke` shim
- * with an absolute `--project-root` and the target name; credentials are
- * resolved at runtime by the shim, never written into the worktree.
+ * Shared by `start-tickets` worktrees AND, since BAPI-724, every Conductor
+ * executor worker worktree (`mcp_server/src/executor/job-runner.ts`, alongside
+ * the executor's deny-layer provisioning) — not start-tickets-only. Both
+ * callers write secret-free MCP registrations into both Claude (`.mcp.json`)
+ * and Cursor (`.cursor/mcp.json`) so the configured MCP servers are reachable
+ * from either editor. Every generated entry contains NO `env` block — it
+ * points at the `mcp-invoke` shim with an absolute `--project-root` and the
+ * target name; credentials are resolved at runtime by the shim, never written
+ * into the worktree.
  *
  * Registrations are driven by `.bridge/config`: the `bapi` target is always
  * provisioned when present, and every supported Tier-2 target (e.g. `sfcc`) is
@@ -69,6 +72,12 @@ export function serverNameForMcpTarget(target) {
  * value. Keeping the shim env-free preserves the credential-safety invariant
  * (secrets are resolved by the `mcp-invoke` shim at launch, not persisted in the
  * worktree) and equally avoids persisting non-secret operational metadata here.
+ *
+ * BAPI-724: the executor caller's `invocation` is resolved BEFORE spawn from its
+ * OWN running process (`resolveMcpShimInvocationForRuntime`, absolute-build-path
+ * form preferred) and never depends on a worker-injected `CONDUCTOR_NODE_PATH`
+ * or any other worker-shell env — the executor worker environment carries no
+ * such key at all (see `executor/env.ts`).
  */
 export function buildShimMcpServerEntry(target, absoluteWorktreePath, invocation) {
     return buildMcpShimCommand(invocation, target, absoluteWorktreePath);
@@ -284,6 +293,13 @@ function withWarnings(row, warnings) {
  *   add a secret-free warning but never abort provisioning.
  * - A required write failure (or a malformed existing registration file) marks
  *   only this row `spawn-failed` with a descriptive error; other rows continue.
+ *   This `spawn-failed` status is the `start-tickets` row contract: that
+ *   caller propagates it verbatim into its summary report. The executor caller
+ *   (BAPI-724) deliberately does NOT propagate it the same way — it constructs
+ *   a synthetic `created` row per job, and its adapter
+ *   (`provisionMcpForPreparedSpawn` in `job-runner.ts`) converts a
+ *   `spawn-failed` result into a logged fail-open warning instead, since a
+ *   provisioning failure must never block an executor worker from spawning.
  * - After the registration files are written, the worktree's
  *   `.claude/settings.local.json` is updated to pre-approve those servers via
  *   `enabledMcpjsonServers` (suppressing Claude Code's per-project trust