@bridge_gpt/mcp-server 0.2.10 → 0.2.13

package/build/init.js

@@ -78,6 +78,63 @@ export function buildBridgeConfigManifest(repoName) {
         "",
     ].join("\n");
 }
+/**
+ * Merge a group token (e.g. "sfcc") into the BRIDGE_MCP_PROFILE env value of the
+ * `bridge-api` entry in each present MCP config file (.mcp.json, .vscode/mcp.json,
+ * .cursor/mcp.json). Existing tokens are preserved; the merge is idempotent.
+ *
+ * Only files where a `bridge-api` entry already exists are modified — new files
+ * are never created by this helper.
+ *
+ * Returns the final resolved profile string (comma-joined) after merging, or an
+ * empty string if no config file was found or updated.
+ */
+export async function mergeBridgeApiProfileToken(cwd, token) {
+    const targets = [
+        { path: ".mcp.json", topLevelKey: "mcpServers" },
+        { path: ".vscode/mcp.json", topLevelKey: "servers" },
+        { path: ".cursor/mcp.json", topLevelKey: "mcpServers" },
+    ];
+    let lastProfile = "";
+    for (const target of targets) {
+        const fullPath = path.join(cwd, target.path);
+        let raw;
+        try {
+            raw = await readFile(fullPath, "utf-8");
+        }
+        catch {
+            continue; // file doesn't exist — skip
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            continue; // invalid JSON — skip
+        }
+        const topLevel = parsed[target.topLevelKey];
+        if (!topLevel || !topLevel["bridge-api"]) {
+            continue; // no bridge-api entry — skip
+        }
+        const entry = topLevel["bridge-api"];
+        if (!entry.env)
+            entry.env = {};
+        const existing = entry.env.BRIDGE_MCP_PROFILE;
+        // Use raw string splitting (not resolveProfiles) so we don't force-inject
+        // "core" into the stored value. The runtime always adds "core" implicitly
+        // when it reads the value, so storing it would cause duplication.
+        const existingTokens = existing
+            ? existing.split(",").map((t) => t.trim()).filter((t) => t.length > 0)
+            : [];
+        const tokenSet = new Set(existingTokens);
+        tokenSet.add(token);
+        const merged = Array.from(tokenSet).join(",");
+        entry.env.BRIDGE_MCP_PROFILE = merged;
+        await writeFile(fullPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+        lastProfile = merged;
+    }
+    return lastProfile;
+}
 async function ensureGitignored(cwd, filePath) {
     await ensureGitignoredShared(cwd, filePath, {
         readFile: (p) => readFile(p, "utf-8"),

package/build/install-bridge.js

@@ -34,10 +34,12 @@
  * gitignored) and the user-scoped credential store (Step 4).
  */
 import { readFile, writeFile, mkdir, stat, rename, chmod, unlink } from "fs/promises";
+import { spawn } from "child_process";
 import os from "os";
 import path from "path";
 import readline from "readline";
 import { runInit, buildBridgeApiEntry } from "./init.js";
+import { VERSION } from "./version.generated.js";
 import { validateRepoName } from "./bridge-config.js";
 import { resolveStartTicketsRepoName } from "./start-tickets-repo.js";
 import { upsertBapiCredential, getPrimaryCredentialStorePath, } from "./credential-store.js";
@@ -45,6 +47,23 @@ import { DEFAULT_AGENT_NAME, resolveAgentSpec, isAgentName, formatValidAgentName
 import { buildGenericAgentShellCommand, getDefaultSpawnTerminalTabForPlatform, detectTerminal, createDefaultStartTicketsDeps, } from "./start-tickets.js";
 /** Redaction sentinel — the API-key value is NEVER printed; this stands in. */
 export const REDACTED_API_KEY = "<REDACTED>";
+/**
+ * Always-surfaced success-path note (BAPI-451 W3, E-3). The pinned launcher's
+ * FIRST cold launch can resolve/download the package inline; if the MCP client's
+ * connect deadline is very short it may time out before the handshake. Pre-warming
+ * (below) makes this rare, but the note is surfaced unconditionally so the
+ * fail-soft backstop is always discoverable.
+ */
+export const MCP_TIMEOUT_GUIDANCE = "Note: if your MCP client has a very short connect deadline, raise MCP_TIMEOUT for the first launch " +
+    "(the initial npx package resolution/download can exceed a short connect timeout).";
+/** The exact, version-pinned launcher spec the pre-warm spawns (fast-exiting --version). */
+export function buildPrewarmArgs() {
+    return ["-y", `@bridge_gpt/mcp-server@${VERSION}`, "--version"];
+}
+/** Secret-free preview of the pre-warm command (no env, no key). */
+export function buildPrewarmCommandPreview() {
+    return `npx ${buildPrewarmArgs().join(" ")}`;
+}
 /** The natural-language sequential prompt handed to the spawned agent session. */
 export const INSTALL_BRIDGE_AGENT_PROMPT = "Please execute the /install-bridge command. Once it completes successfully, execute the /learn-repository command.";
 /** Default base URL when `BAPI_BASE_URL` is unset (mirrors index.ts). */
@@ -198,6 +217,44 @@ function promptLineViaReadline(promptText) {
         });
     });
 }
+/**
+ * Default pre-warm spawner (BAPI-451 W3). Spawns array-based (`shell: false`) so
+ * no argument is ever shell-interpreted, ignores all child stdio (node-gyp /
+ * download noise stays out of the CLI UX), bounds the run with a 60s timeout, and
+ * passes a SANITIZED env clone with `BAPI_API_KEY` deleted — the `--version`
+ * pre-warm never needs the key, and it must never reach an npm lifecycle script.
+ * Always resolves (never rejects): a spawn error / non-zero exit / timeout becomes
+ * `{ ok: false, warning }` with secret-free warning text.
+ */
+function spawnPrewarmDefault(command, args, env) {
+    return new Promise((resolve) => {
+        const sanitizedEnv = { ...env };
+        delete sanitizedEnv.BAPI_API_KEY;
+        try {
+            const child = spawn(command, args, {
+                shell: false,
+                stdio: "ignore",
+                timeout: 60_000,
+                env: sanitizedEnv,
+            });
+            child.on("error", () => resolve({ ok: false, warning: "the pre-warm process could not be started" }));
+            child.on("close", (code, signal) => {
+                if (signal) {
+                    resolve({ ok: false, warning: `the pre-warm process timed out or was terminated (${signal})` });
+                }
+                else if (code === 0) {
+                    resolve({ ok: true });
+                }
+                else {
+                    resolve({ ok: false, warning: `the pre-warm process exited with code ${code}` });
+                }
+            });
+        }
+        catch {
+            resolve({ ok: false, warning: "the pre-warm process could not be started" });
+        }
+    });
+}
 /** Build default deps from the live process. */
 export function createDefaultInstallBridgeDeps() {
     const isTTY = Boolean(process.stdin.isTTY);
@@ -217,6 +274,7 @@ export function createDefaultInstallBridgeDeps() {
         promptSecret: isTTY ? promptSecretViaReadline : undefined,
         promptLine: isTTY ? promptLineViaReadline : undefined,
         fetch: (...args) => fetch(...args),
+        spawnPrewarm: spawnPrewarmDefault,
         runInit,
         upsertCredential: upsertBapiCredential,
         buildShellCommand: buildGenericAgentShellCommand,
@@ -472,6 +530,8 @@ export function buildDryRunPreview(plan) {
         ...(plan.manualEditors.length > 0
             ? [`  ${plan.manualEditors.join(" + ")}: detected (global config) — manual setup instructions would be printed.`]
             : []),
+        `Step 3b — pre-warm the version-pinned launcher bucket (fail-open, env sanitized — BAPI_API_KEY removed): ${plan.prewarmCommand}`,
+        MCP_TIMEOUT_GUIDANCE,
         `Step 4 — persist routing credential: target ${plan.credentialTarget} at ${plan.credentialStorePath}`,
         `Step 5 — spawn agent session: ${plan.spawnCommand}`,
     ];
@@ -590,6 +650,7 @@ export async function runInstallBridgeCli(argv, overrides = {}) {
         credentialTarget: `bapi:${repoName}`,
         credentialStorePath,
         pingUrl: buildPingUrl(baseUrl, repoName),
+        prewarmCommand: buildPrewarmCommandPreview(),
         spawnCommand,
     };
     // ---- --dry-run: preview every step, strictly no side effects ----
@@ -639,6 +700,25 @@ export async function runInstallBridgeCli(argv, overrides = {}) {
     const manualInstructions = buildManualHostInstructions(entry, manualEditors);
     if (manualInstructions)
         log(manualInstructions);
+    // ---- Step 3b — pre-warm the @${VERSION}-pinned _npx bucket (BAPI-451 W3) ----
+    // The launcher just written is pinned to @${VERSION}, a DIFFERENT _npx bucket
+    // than the @latest bucket this `npx … install-bridge` invocation warmed. Spawn
+    // the exact pinned launcher once with the fast-exiting `--version` flag so the
+    // first real MCP launch resolves from a warm bucket instead of paying the cold
+    // install inline (which can exceed the client's connect deadline). Strictly
+    // fail-open: a failure warns (secret-free) but never fails the install.
+    log("  pre-warming the version-pinned launcher bucket…");
+    const prewarm = await deps.spawnPrewarm("npx", buildPrewarmArgs(), deps.env);
+    if (prewarm.ok) {
+        log("  launcher bucket warmed (the first MCP launch will not pay a cold install).");
+        log(`  ${MCP_TIMEOUT_GUIDANCE}`);
+    }
+    else {
+        // Escalate to a stronger, still secret-free warning when pre-warm didn't
+        // complete cleanly — but the install itself still succeeds (exit unaffected).
+        errorLog(`Warning: could not pre-warm the version-pinned launcher bucket${prewarm.warning ? ` (${prewarm.warning})` : ""}. ` +
+            `The first MCP launch may pay a one-time cold install and could be slow. ${MCP_TIMEOUT_GUIDANCE}`);
+    }
     // ---- Step 4 — persist routing credential (non-blocking / fail-open) ----
     log("Step 4/5 — persisting routing credential…");
     try {

package/build/mcp-profile.js

@@ -1,43 +1,46 @@
 /**
- * MCP profile resolver (BAPI-434 Phase 2a).
+ * MCP profile resolver (BAPI-453).
  *
- * Defines the four startup-time tool registration profiles and provides pure,
- * unit-testable helpers for resolving the active profile from an env-var string
- * and for checking group membership.
+ * Generalizes the startup-time tool registration model from a single-string
+ * profile to a multi-valued group set. BRIDGE_MCP_PROFILE accepts a
+ * comma-separated list of group tokens; unknown tokens are silently dropped
+ * (security sentinel — raw input is never echoed). "core" is always implicitly
+ * included. "full" is an input shortcut that expands to every known group.
  *
- * Profiles are static — they gate which tools are registered at process startup
- * and cannot be changed mid-session via tools/list_changed.
+ * Groups are resolved once at process startup and cannot change mid-session.
  */
-const VALID_PROFILES = new Set([
+const VALID_GROUPS = new Set([
     "core",
     "conductor",
     "pipeline-authoring",
-    "full",
+    "sfcc",
 ]);
 /**
- * Resolve the active MCP profile from a raw env-var string.
+ * Resolve the active MCP groups from a raw env-var string.
  *
- * - `undefined` or blank → `"core"` (fail-safe to smallest surface).
- * - Known values (case-insensitive, whitespace-trimmed) → normalized profile.
- * - Unknown / malformed values → `"core"` (fail-safe).
+ * - `undefined` or blank → `{"core"}` (fail-safe to smallest surface).
+ * - `"full"` (any case) → all four groups.
+ * - Comma-separated list: each token is trimmed, lowercased, and checked
+ *   against VALID_GROUPS. Unknown tokens are dropped. Known tokens are unioned
+ *   with the implicit `"core"` baseline.
+ * - All-unknown tokens → `{"core"}`.
+ * - Raw input is never echoed in the output (security NFR).
  */
-export function resolveProfile(raw) {
+export function resolveProfiles(raw) {
+    const baseline = new Set(["core"]);
     if (raw === undefined)
-        return "core";
-    const normalized = raw.trim().toLowerCase();
-    if (normalized === "")
-        return "core";
-    if (VALID_PROFILES.has(normalized))
-        return normalized;
-    return "core";
-}
-/**
- * Return true when `profile` should include tools from the given gated group.
- *
- * - `"full"` includes every group.
- * - Any other profile includes only its own matching group.
- * - `"core"` includes neither gated group.
- */
-export function profileIncludes(profile, group) {
-    return profile === "full" || profile === group;
+        return baseline;
+    const trimmed = raw.trim();
+    if (trimmed === "")
+        return baseline;
+    const tokens = trimmed.split(",").map((t) => t.trim().toLowerCase());
+    if (tokens.some((t) => t === "full")) {
+        return new Set(["core", "conductor", "pipeline-authoring", "sfcc"]);
+    }
+    for (const token of tokens) {
+        if (VALID_GROUPS.has(token)) {
+            baseline.add(token);
+        }
+    }
+    return baseline;
 }