@bridge_gpt/mcp-server 0.2.34 → 0.2.37

package/build/mcp-invoke.js

@@ -25,6 +25,7 @@ import path from "path";
 import os from "os";
 import { resolveRepoNameForProjectRoot, readBridgeConfig, validateMcpTarget, } from "./bridge-config.js";
 import { resolveBapiCredentials } from "./credential-store.js";
+import { describeBaseUrlRejection, validateHttpBaseUrl } from "./base-url.js";
 import { getThirdPartyTargetDefinition, resolveThirdPartyTargetEnv, validateThirdPartyTargetManifestEntry, } from "./third-party-mcp-targets.js";
 // ---------------------------------------------------------------------------
 // Usage / argument parsing
@@ -47,18 +48,30 @@ export function getMcpInvokeUsage() {
         "                               API server; a configured third-party target from",
         "                               .bridge/config (e.g. sfcc) launches that server.",
         "  --project-root <ABS_PATH>    Absolute path to the worktree (required)",
+        "  --base-url <HTTP(S)_URL>     Optional. Bridge API endpoint for the spawned",
+        "                               server; applies ONLY to --target bapi. When",
+        "                               omitted, the child inherits BAPI_BASE_URL",
+        "                               unchanged. Must be an absolute http/https URL",
+        "                               with no embedded username or password.",
         "  -h, --help                   Show this help",
     ].join("\n");
 }
-const KNOWN_FLAGS = new Set(["--target", "--project-root"]);
+const KNOWN_FLAGS = new Set(["--target", "--project-root", "--base-url"]);
 /**
- * Parse `--target` and `--project-root` (split or `=` form). Rejects unknown
- * flags, positional arguments, missing values, and duplicates. Requires a safe
- * non-empty `--target` identifier and a host-platform-absolute `--project-root`.
+ * Parse `--target`, `--project-root`, and the optional `--base-url` (split or `=`
+ * form). Rejects unknown flags, positional arguments, missing values, and
+ * duplicates. Requires a safe non-empty `--target` identifier and a
+ * host-platform-absolute `--project-root`.
+ *
+ * `--base-url` is validated strictly and is valid ONLY with `--target bapi`;
+ * pairing it with any other target is an error rather than a silent no-op, so a
+ * misgenerated registration fails loudly instead of quietly routing a Tier-2
+ * server nowhere. No rejection message ever echoes the supplied URL.
  */
 export function parseMcpInvokeArgs(argv) {
     let target;
     let projectRoot;
+    let baseUrl;
     for (let i = 0; i < argv.length; i++) {
         const token = argv[i];
         if (token === "-h" || token === "--help") {
@@ -91,6 +104,16 @@ export function parseMcpInvokeArgs(argv) {
             }
             target = value;
         }
+        else if (flag === "--base-url") {
+            if (baseUrl !== undefined) {
+                return { status: "error", message: "Duplicate --base-url flag" };
+            }
+            const validation = validateHttpBaseUrl(value);
+            if (!validation.ok) {
+                return { status: "error", message: describeBaseUrlRejection("--base-url", validation.reason) };
+            }
+            baseUrl = validation.baseUrl;
+        }
         else {
             if (projectRoot !== undefined) {
                 return { status: "error", message: "Duplicate --project-root flag" };
@@ -111,7 +134,15 @@ export function parseMcpInvokeArgs(argv) {
     if (!path.isAbsolute(projectRoot)) {
         return { status: "error", message: "--project-root must be an absolute path" };
     }
-    return { status: "ok", target: targetValidation.value, projectRoot };
+    if (baseUrl !== undefined && targetValidation.value !== "bapi") {
+        return {
+            status: "error",
+            message: "--base-url is only valid with --target bapi",
+        };
+    }
+    return baseUrl === undefined
+        ? { status: "ok", target: targetValidation.value, projectRoot }
+        : { status: "ok", target: targetValidation.value, projectRoot, baseUrl };
 }
 // ---------------------------------------------------------------------------
 // Validation, env construction, signals
@@ -284,6 +315,15 @@ export async function resolveBapiInvocation(projectRoot, deps) {
     if (typeof conductorNodePath === "string" && conductorNodePath.trim().length > 0) {
         overlay.CONDUCTOR_NODE_PATH = conductorNodePath;
     }
+    // BAPI-727: overlay the endpoint ONLY when `--base-url` was supplied, mirroring
+    // the conditional `CONDUCTOR_NODE_PATH` overlay directly above. The absent case
+    // must add, delete, normalize, and override nothing — `buildChildEnv` already
+    // inherits the parent's `BAPI_BASE_URL`, and the server keeps its own production
+    // default for callers that were never given a URL. Like `CONDUCTOR_NODE_PATH`,
+    // this is non-secret routing metadata, not a credential.
+    if (typeof deps.baseUrl === "string" && deps.baseUrl.length > 0) {
+        overlay.BAPI_BASE_URL = deps.baseUrl;
+    }
     const env = buildChildEnv(deps.env, overlay);
     return {
         ok: true,
@@ -356,7 +396,7 @@ export async function runMcpInvokeCli(argv, overrides = {}) {
         stderr(getMcpInvokeUsage());
         return 1;
     }
-    const { target, projectRoot } = parsed;
+    const { target, projectRoot, baseUrl } = parsed;
     const statFn = overrides.stat ?? ((p) => stat(p));
     const dirCheck = await validateProjectRootDirectory(projectRoot, statFn);
     if (!dirCheck.ok) {
@@ -379,12 +419,15 @@ export async function runMcpInvokeCli(argv, overrides = {}) {
             }));
         const resolveCredentials = overrides.resolveCredentials ??
             ((rn) => resolveBapiCredentials(rn, credentialDeps));
+        // The parsed URL reaches ONLY this branch; the parser already rejected
+        // `--base-url` for every other target, so the Tier-2 path below cannot see it.
         const resolved = await resolveBapiInvocation(projectRoot, {
             env,
             execPath: process.execPath,
             scriptPath: process.argv[1],
             resolveRepoName,
             resolveCredentials,
+            baseUrl,
         });
         if (!resolved.ok) {
             stderr(`Error: ${resolved.error}`);

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,13 +72,35 @@ 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`).
+ *
+ * BAPI-727 extends the BAPI-527 note above rather than contradicting it. The
+ * optional `bridgeApiBaseUrl` is appended as the ARGUMENT `--base-url <url>`, and
+ * only for the `bapi` target. A Bridge API endpoint is non-secret ROUTING
+ * metadata — the same value that appears in an operator's `--base-url` flag and in
+ * generated executor service units — so persisting it does not weaken the
+ * no-`env`, no-credential registration invariant. The entry keeps exactly
+ * `command` and `args`; credentials continue to be resolved by the `mcp-invoke`
+ * shim at launch and are never written into the worktree.
  */
-export function buildShimMcpServerEntry(target, absoluteWorktreePath, invocation) {
-    return buildMcpShimCommand(invocation, target, absoluteWorktreePath);
+export function buildShimMcpServerEntry(target, absoluteWorktreePath, invocation, bridgeApiBaseUrl) {
+    const entry = buildMcpShimCommand(invocation, target, absoluteWorktreePath);
+    // Tier-2 targets are structurally unchanged: `--base-url` is a `bapi`-only flag
+    // and `mcp-invoke` rejects it for any other target, so appending it elsewhere
+    // would generate a registration that refuses to launch.
+    if (target !== "bapi" || bridgeApiBaseUrl === undefined)
+        return entry;
+    // Clone/extend the generated args; never add a property beyond command/args.
+    return { command: entry.command, args: [...entry.args, "--base-url", bridgeApiBaseUrl] };
 }
 /** Back-compat wrapper around `buildShimMcpServerEntry("bapi", ...)`. */
-export function buildBridgeApiShimMcpServerEntry(absoluteWorktreePath, invocation) {
-    return buildShimMcpServerEntry("bapi", absoluteWorktreePath, invocation);
+export function buildBridgeApiShimMcpServerEntry(absoluteWorktreePath, invocation, bridgeApiBaseUrl) {
+    return buildShimMcpServerEntry("bapi", absoluteWorktreePath, invocation, bridgeApiBaseUrl);
 }
 /**
  * Convert all supported manifest `mcp` entries into a map of server name -> shim
@@ -84,12 +109,14 @@ export function buildBridgeApiShimMcpServerEntry(absoluteWorktreePath, invocatio
  * or incomplete non-`bapi` targets are skipped with a secret-free warning (they
  * never appear in the returned entries).
  */
-export function buildMcpServerEntriesForManifest(manifest, absoluteWorktreePath, invocation) {
+export function buildMcpServerEntriesForManifest(manifest, absoluteWorktreePath, invocation, bridgeApiBaseUrl) {
     const entries = {};
     const warnings = [];
     for (const mcp of manifest.mcp) {
         if (mcp.target === "bapi") {
-            entries[serverNameForMcpTarget("bapi")] = buildShimMcpServerEntry("bapi", absoluteWorktreePath, invocation);
+            // The optional base URL reaches ONLY this branch — Tier-2 entries below are
+            // built without it and stay byte-identical to their pre-BAPI-727 shape.
+            entries[serverNameForMcpTarget("bapi")] = buildShimMcpServerEntry("bapi", absoluteWorktreePath, invocation, bridgeApiBaseUrl);
             continue;
         }
         const definition = getThirdPartyTargetDefinition(mcp.target);
@@ -153,6 +180,11 @@ export function mergeEnabledMcpjsonServers(existing, serverNames) {
  * Unrelated top-level fields and unrelated MCP servers are preserved; only the
  * generated server names are replaced. Any legacy secret-embedded entry for a
  * generated server name is force-upgraded to the secret-free shim shape.
+ *
+ * Deliberately UNCHANGED by BAPI-727: because a generated name is replaced rather
+ * than merged field-by-field, re-provisioning an existing worktree automatically
+ * upgrades an older `bridge-api` entry that lacks `--base-url` to the URL-bearing
+ * one. No migration step is needed.
  */
 export function mergeMcpRegistrations(existing, topLevelKey, entries) {
     const result = existing && typeof existing === "object" && !Array.isArray(existing)
@@ -284,6 +316,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
@@ -305,7 +344,7 @@ export async function provisionMcpRegistrationForWorktree(row, deps) {
     if (!normalized.ok) {
         return { ...row, status: "spawn-failed", error: `MCP provisioning failed: ${normalized.error}` };
     }
-    const built = buildMcpServerEntriesForManifest(read.manifest, normalized.path, deps.mcpServerInvocation);
+    const built = buildMcpServerEntriesForManifest(read.manifest, normalized.path, deps.mcpServerInvocation, deps.bridgeApiBaseUrl);
     if (Object.keys(built.entries).length === 0) {
         // Nothing supported to write (e.g. a manifest with no bapi target and no
         // supported Tier-2 targets). Surface any warnings but leave status unchanged.

package/build/mcp-registration-doctor.js

@@ -8,17 +8,26 @@
  */
 import path from "path";
 /**
- * Read and parse a JSON file. A read failure (e.g. ENOENT) is `missing`; invalid
- * JSON is `malformed` (carrying only the path, never the raw content); otherwise
- * `present` with the parsed value.
+ * Read and parse a JSON file.
+ *
+ * A read failure whose error carries an `ENOENT` code is `missing` — the file
+ * genuinely is not there. Any OTHER read failure (e.g. `EACCES`) is `unreadable`:
+ * BAPI-727's shadow inspector must not treat "I could not look" as "there is
+ * nothing there", because an unreadable `~/.claude.json` could still be shadowing
+ * a worker's MCP registration. Invalid JSON stays `malformed`; both non-present
+ * failure states carry ONLY the path — never the raw content and never the read
+ * exception's message, which can contain arbitrary text.
  */
 export async function readJsonIfPresent(filePath, deps) {
     let raw;
     try {
         raw = await deps.readFile(filePath);
     }
-    catch {
-        return { state: "missing" };
+    catch (err) {
+        const code = err && typeof err === "object" ? err.code : undefined;
+        if (code === "ENOENT")
+            return { state: "missing" };
+        return { state: "unreadable", path: filePath };
     }
     try {
         return { state: "present", value: JSON.parse(raw) };