@bridge_gpt/mcp-server 0.2.38 → 0.2.41

package/build/install-doctor.js

@@ -21,6 +21,7 @@
  */
 import path from "path";
 import { resolveBapiCredentials } from "./credential-store.js";
+import { detectClaudeLogin, formatClaudeLoginAdvisory } from "./claude-login.js";
 /** Default production base URL (mirrors install-bridge's DEFAULT_BAPI_BASE_URL). */
 const DEFAULT_BASE_URL = "https://bridgegpt-api.com";
 /**
@@ -181,6 +182,18 @@ function readGithubConfiguredFlag(body) {
  */
 export async function collectInstallStatusChecks(deps) {
     const checks = [];
+    // Advisory-only Claude login marker (BAPI-791), independent of Bridge repo
+    // identity/credential resolution below — a worker authenticates through the
+    // executor host's own interactive `claude login`, not through anything this
+    // install-status section resolves. Bridge stores or diagnoses no Anthropic
+    // credential of its own, so this can only ever advise, never confirm.
+    const loginResult = await detectClaudeLogin({ homedir: deps.homedir, readFile: deps.readFile });
+    checks.push({
+        id: "claude-login",
+        label: "Claude login",
+        status: loginResult.detected ? "PASS" : "INFO",
+        detail: formatClaudeLoginAdvisory(loginResult),
+    });
     const target = await resolveInstallDoctorTarget(deps);
     if (!target.repoName) {
         checks.push({

package/build/install-reexec.js

@@ -163,9 +163,11 @@ export async function runInstallBridgeWithLatestCli(argv, deps = {}) {
     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") {
+    // Terminating condition, the nested-conductor bypass, and `--dry-run`
+    // (BAPI-818, R2) all skip the registry entirely. A dry run's documented
+    // contract is "no network" — a version-freshness lookup is still a network
+    // call, so it cannot run first even though it is fail-open and unauthenticated.
+    if (sentinelPresent || cleanedArgs[0] === "conductor" || cleanedArgs.includes("--dry-run")) {
         return runLocal(cleanedArgs);
     }
     // Default the comparison target to the local version: an unusable registry

package/build/mcp-install-state.js

@@ -15,6 +15,7 @@
  * All filesystem access is through injected dependencies so the module is fully
  * unit-testable with in-memory fakes.
  */
+import { executorIdFromLaunchdFilename, executorIdFromSystemdFilename, } from "./executor/service-unit.js";
 import { HOST_PLATFORM_ORDER, isHostPlatformId, } from "./mcp-host-targets.js";
 /** Current on-disk schema version. */
 export const MCP_INSTALL_STATE_VERSION = 1;
@@ -60,6 +61,74 @@ function normalizeProjectPaths(paths) {
     return out;
 }
 // ---------------------------------------------------------------------------
+// Executor service-unit locators (BAPI-779)
+// ---------------------------------------------------------------------------
+/** Home-relative prefix of the darwin LaunchAgents convention. */
+const EXECUTOR_LAUNCHD_LOCATOR_PREFIX = "~/Library/LaunchAgents/";
+/** Home-relative prefix of the linux systemd `--user` convention. */
+const EXECUTOR_SYSTEMD_LOCATOR_PREFIX = "~/.config/systemd/user/";
+/**
+ * Accept ONLY the two generated-unit conventions, and only in home-relative
+ * form.
+ *
+ * Everything else is rejected: an arbitrary absolute path (`/tmp/evil.service`),
+ * a system-domain unit (`/etc/systemd/system/x.service`), a traversal segment,
+ * a wrong extension, or a filename the generator's own parsers do not recognize
+ * as one of its units. Install state is a diagnostic record of what THIS tool
+ * generated — letting it name any path on the filesystem would turn a
+ * secret-free inventory into an attacker-influenced pointer list.
+ */
+function isGeneratedExecutorUnitLocator(value) {
+    if (typeof value !== "string" || value.length === 0)
+        return false;
+    if (value.includes("..") || value.includes("\\") || value.includes("\0"))
+        return false;
+    if (value.startsWith(EXECUTOR_LAUNCHD_LOCATOR_PREFIX)) {
+        const filename = value.slice(EXECUTOR_LAUNCHD_LOCATOR_PREFIX.length);
+        return filename.length > 0 && executorIdFromLaunchdFilename(filename) !== null;
+    }
+    if (value.startsWith(EXECUTOR_SYSTEMD_LOCATOR_PREFIX)) {
+        const filename = value.slice(EXECUTOR_SYSTEMD_LOCATOR_PREFIX.length);
+        return filename.length > 0 && executorIdFromSystemdFilename(filename) !== null;
+    }
+    return false;
+}
+/** Validate, dedupe, and stably order generated-unit locators. */
+function normalizeExecutorServiceUnitPaths(paths) {
+    const seen = new Set();
+    const out = [];
+    for (const candidate of paths) {
+        if (typeof candidate !== "string")
+            continue;
+        if (!isGeneratedExecutorUnitLocator(candidate))
+            continue;
+        if (seen.has(candidate))
+            continue;
+        seen.add(candidate);
+        out.push(candidate);
+    }
+    out.sort();
+    return out;
+}
+/**
+ * Convert an absolute generated-unit path into its canonical home-relative
+ * locator, or `null` when it is not one of this tool's generated units.
+ *
+ * Returning `null` rather than a best-effort string is deliberate: a caller that
+ * cannot produce a canonical locator must record nothing, not record a path the
+ * schema would have rejected anyway.
+ */
+export function canonicalExecutorServiceUnitLocator(unitPath, homeDir) {
+    if (typeof unitPath !== "string" || typeof homeDir !== "string" || homeDir.length === 0) {
+        return null;
+    }
+    const normalizedHome = homeDir.endsWith("/") ? homeDir.slice(0, -1) : homeDir;
+    if (!unitPath.startsWith(`${normalizedHome}/`))
+        return null;
+    const locator = `~/${unitPath.slice(normalizedHome.length + 1)}`;
+    return isGeneratedExecutorUnitLocator(locator) ? locator : null;
+}
+// ---------------------------------------------------------------------------
 // Read
 // ---------------------------------------------------------------------------
 function isEnoent(err) {
@@ -116,12 +185,24 @@ export async function readMcpInstallState(cwd, deps) {
     const projectConfigPaths = Array.isArray(rawPaths)
         ? rawPaths.filter((p) => typeof p === "string")
         : [];
+    // An ABSENT field is the ordinary legacy-document case and must read as an
+    // empty roster, not as an invalid document — every state file written before
+    // BAPI-779 lacks it. A present-but-wrong-type field is a real schema
+    // violation and is reported as such.
+    const rawUnitPaths = doc.executorServiceUnitPaths;
+    if (rawUnitPaths !== undefined && !Array.isArray(rawUnitPaths)) {
+        return { status: "invalid", reason: "executorServiceUnitPaths is not an array" };
+    }
     return {
         status: "valid",
         state: {
             version: MCP_INSTALL_STATE_VERSION,
             selectedPlatforms: normalizePlatforms(rawPlatforms),
             projectConfigPaths: normalizeProjectPaths(projectConfigPaths),
+            // Entries that are not generated-unit locators are DROPPED rather than
+            // failing the read: they cannot be acted on, and losing the whole
+            // document over one bad entry would take the platform roster with it.
+            executorServiceUnitPaths: normalizeExecutorServiceUnitPaths(Array.isArray(rawUnitPaths) ? rawUnitPaths : []),
         },
     };
 }
@@ -135,6 +216,10 @@ export function serializeMcpInstallState(state) {
         version: state.version,
         selectedPlatforms: state.selectedPlatforms,
         projectConfigPaths: state.projectConfigPaths,
+        // Re-normalized at serialization time, not trusted from the input object:
+        // this function is the last gate before bytes hit disk, and a caller could
+        // hand it a hand-built state carrying an arbitrary path.
+        executorServiceUnitPaths: normalizeExecutorServiceUnitPaths(state.executorServiceUnitPaths ?? []),
     };
     return JSON.stringify(ordered, null, 2) + "\n";
 }
@@ -146,10 +231,16 @@ export function serializeMcpInstallState(state) {
  * secret-free error without reporting success.
  */
 export async function writeMcpInstallState(cwd, input, deps) {
+    const existing = await readMcpInstallState(cwd, deps);
+    const priorUnitPaths = existing.status === "valid" ? existing.state.executorServiceUnitPaths : [];
     const state = {
         version: MCP_INSTALL_STATE_VERSION,
         selectedPlatforms: normalizePlatforms(input.selectedPlatforms),
         projectConfigPaths: normalizeProjectPaths(input.projectConfigPaths),
+        executorServiceUnitPaths: normalizeExecutorServiceUnitPaths([
+            ...priorUnitPaths,
+            ...(input.executorServiceUnitPaths ?? []),
+        ]),
     };
     const finalPath = installStatePath(cwd);
     return persistMcpInstallState(cwd, state, finalPath, deps);
@@ -198,10 +289,49 @@ export async function recordInstalledProjectArtifact(cwd, relPath, deps) {
     const existing = await readMcpInstallState(cwd, deps);
     const priorPlatforms = existing.status === "valid" ? existing.state.selectedPlatforms : [];
     const priorPaths = existing.status === "valid" ? existing.state.projectConfigPaths : [];
+    const priorUnitPaths = existing.status === "valid" ? existing.state.executorServiceUnitPaths : [];
     const state = {
         version: MCP_INSTALL_STATE_VERSION,
         selectedPlatforms: normalizePlatforms(priorPlatforms),
         projectConfigPaths: normalizeProjectPaths([...priorPaths, relPath]),
+        // Preserved, not rebuilt: recording a workflow file must not drop the
+        // executor units a previous conductor run recorded (the same additive rule
+        // that motivated this helper for the platform roster).
+        executorServiceUnitPaths: normalizeExecutorServiceUnitPaths(priorUnitPaths),
+    };
+    return persistMcpInstallState(cwd, state, installStatePath(cwd), deps);
+}
+/**
+ * Record a generated executor service unit WITHOUT clobbering existing state.
+ *
+ * Mirrors {@link recordInstalledProjectArtifact}: read the current document,
+ * write back the union of every dimension. The caller supplies the ABSOLUTE
+ * unit path the generator returned plus the home directory it was rendered
+ * against; this helper canonicalizes them into the home-relative locator the
+ * schema accepts, and refuses anything that is not one of the two generated
+ * conventions.
+ *
+ * No secret can reach the file: the locator is a fixed-shape path under two
+ * known directories, and the serializer emits only schema-approved keys.
+ */
+export async function recordInstalledExecutorServiceUnit(cwd, unitPath, homeDir, deps) {
+    const locator = canonicalExecutorServiceUnitLocator(unitPath, homeDir);
+    if (locator === null) {
+        return {
+            ok: false,
+            error: "the unit path is not a generated executor service unit under the supported " +
+                "darwin LaunchAgents or linux systemd --user convention; nothing was recorded.",
+        };
+    }
+    const existing = await readMcpInstallState(cwd, deps);
+    const priorPlatforms = existing.status === "valid" ? existing.state.selectedPlatforms : [];
+    const priorPaths = existing.status === "valid" ? existing.state.projectConfigPaths : [];
+    const priorUnitPaths = existing.status === "valid" ? existing.state.executorServiceUnitPaths : [];
+    const state = {
+        version: MCP_INSTALL_STATE_VERSION,
+        selectedPlatforms: normalizePlatforms(priorPlatforms),
+        projectConfigPaths: normalizeProjectPaths(priorPaths),
+        executorServiceUnitPaths: normalizeExecutorServiceUnitPaths([...priorUnitPaths, locator]),
     };
     return persistMcpInstallState(cwd, state, installStatePath(cwd), deps);
 }

package/build/mcp-profile.js

@@ -14,16 +14,19 @@ const VALID_GROUPS = new Set([
     "conductor",
     "pipeline-authoring",
     "sfcc",
+    "sfcc-write",
 ]);
 /**
  * Resolve the active MCP groups from a raw env-var string.
  *
  * - `undefined` or blank → `{"core"}` (fail-safe to smallest surface).
- * - `"full"` (any case) → all four groups.
+ * - `"full"` (any case) → all five groups, `sfcc-write` included.
  * - 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"}`.
+ * - No group implies another beyond the `"core"` baseline — in particular
+ *   `sfcc` and `sfcc-write` are independent in both directions (BAPI-817).
  * - Raw input is never echoed in the output (security NFR).
  */
 export function resolveProfiles(raw) {
@@ -35,7 +38,13 @@ export function resolveProfiles(raw) {
         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"]);
+        return new Set([
+            "core",
+            "conductor",
+            "pipeline-authoring",
+            "sfcc",
+            "sfcc-write",
+        ]);
     }
     for (const token of tokens) {
         if (VALID_GROUPS.has(token)) {

package/build/mcp-provisioning.js

@@ -307,6 +307,21 @@ function withWarnings(row, warnings) {
 /**
  * Provision MCP registrations for one created worktree row.
  *
+ * FAIL-OPEN, and BAPI-790 makes that posture worth stating explicitly, because a
+ * fail-CLOSED requirement now sits directly downstream of it. This function
+ * ATTEMPTS the write and degrades to warnings; the executor then separately
+ * VERIFIES that a usable `.mcp.json` exists and registers `bridge-api`, and
+ * refuses to spawn when it does not (`verifyRequiredWorktreeMcpRegistration` in
+ * `executor/job-runner.ts`). The split is deliberate: a provisioning hiccup on a
+ * Tier-2 target must not kill a job, but a worker that loads MCP servers strictly
+ * from this file must not start if the file cannot serve that role. Keep the two
+ * postures distinct — folding the requirement in here would put it behind this
+ * function's fail-open catch and silently disarm it.
+ *
+ * The same file is also the source of the `--mcp-config` path and of the expected
+ * server-name set the per-spawn init-event assertion checks, so what this writes
+ * is exactly what a worker is later held to.
+ *
  * - Non-`created` rows and rows without a path are returned unchanged.
  * - A missing / malformed manifest yields a non-fatal warning and leaves the row
  *   status unchanged.