@bridge_gpt/mcp-server 0.2.16 → 0.2.19

package/build/mcp-server-invocation.js

@@ -0,0 +1,152 @@
+/**
+ * Shared, dependency-injected model for how a dispatched worker launches the
+ * Bridge MCP `mcp-invoke` shim (BAPI-526, Change A).
+ *
+ * The conductor used to register each dispatched worktree's `.mcp.json` against
+ * an EXACT npm version (`npx -y @bridge_gpt/mcp-server@<VERSION> mcp-invoke …`).
+ * When that version was built but not yet published, `npx` returned ETARGET/404
+ * and the worker had NO Bridge MCP tools. This module lets provisioning instead
+ * invoke the conductor's own on-disk build by ABSOLUTE PATH
+ * (`node <abs>/mcp_server/build/index.js mcp-invoke …`) — removing the
+ * npm-registry publish dependency and guaranteeing the worker runs the exact MCP
+ * code the conductor is running. A resolvable npm-channel spec remains the
+ * fallback when an on-disk build entry cannot be resolved (published-package
+ * install).
+ *
+ * SCOPE BOUNDARY (BAPI-526 is detection/registration only): this selects WHICH
+ * server file is invoked (`node <absPath>/index.js` vs `npx @…`). It does NOT
+ * change WHICH Node binary runs that file — the `nodeExecutable` field is kept as
+ * a single substitutable value (never string-concatenated into the command) so
+ * the later Ticket 3 (P2) work can point it at `CONDUCTOR_NODE_PATH` without
+ * re-plumbing argv construction.
+ */
+import path from "node:path";
+export const MCP_SERVER_PACKAGE_NAME = "@bridge_gpt/mcp-server";
+/**
+ * Resolvable npm-channel fallback spec. Deliberately a moving channel (`@latest`)
+ * rather than an exact generated version pin, so the fallback path can never
+ * reintroduce the ETARGET/404 failure the absolute-path form exists to remove.
+ */
+export const DEFAULT_MCP_SERVER_NPM_CHANNEL_SPEC = "@bridge_gpt/mcp-server@latest";
+/**
+ * Build the concrete `{ command, args }` launch pair for a target + worktree from
+ * a structured invocation. Pure — no filesystem or process access. The
+ * `nodeExecutable` is returned as the standalone `command`, never concatenated
+ * with the server entry path, so `CONDUCTOR_NODE_PATH` can substitute it later.
+ */
+export function buildMcpShimCommand(invocation, target, absoluteWorktreePath) {
+    if (invocation.form === "absolute-build-path") {
+        return {
+            command: invocation.nodeExecutable,
+            args: [
+                invocation.serverEntryPath,
+                "mcp-invoke",
+                "--target",
+                target,
+                "--project-root",
+                absoluteWorktreePath,
+            ],
+        };
+    }
+    return {
+        command: "npx",
+        args: [
+            "-y",
+            invocation.packageSpec,
+            "mcp-invoke",
+            "--target",
+            target,
+            "--project-root",
+            absoluteWorktreePath,
+        ],
+    };
+}
+/**
+ * Secret-free, path-free audit label for summaries and diagnostics. Returns ONLY
+ * the registration form; never the server entry path, username, argv, or package
+ * cache path (any of which can leak a username through a filesystem path).
+ */
+export function formatMcpShimInvocationForAudit(invocation) {
+    return invocation.form;
+}
+/**
+ * Resolve the package root from a module URL by walking the module file path and
+ * locating the nearest `src` or `build` path segment; the package root is the
+ * portion BEFORE that segment. Returns forward-slash form so it is deterministic
+ * across platforms (Node accepts forward slashes on Windows). Does NOT consult
+ * `process.cwd()`. Returns `null` when neither `src` nor `build` appears.
+ */
+export function resolvePackageRootFromModuleUrl(moduleUrl) {
+    // Parse the URL's pathname directly rather than via fileURLToPath: on Windows,
+    // fileURLToPath throws ERR_INVALID_FILE_URL_PATH for a drive-less `file:///…`
+    // URL, whereas the pathname (`/repo/mcp_server/…`) is available on every
+    // platform. This keeps resolution deterministic across POSIX and Windows.
+    let pathname;
+    try {
+        pathname = decodeURIComponent(new URL(moduleUrl).pathname);
+    }
+    catch {
+        return null;
+    }
+    // A real Windows `import.meta.url` is `file:///C:/…`, whose pathname is
+    // `/C:/…`; strip the leading slash so the drive letter leads (Node accepts
+    // forward slashes on Windows). Drive-less POSIX pathnames are left unchanged.
+    if (/^\/[A-Za-z]:/.test(pathname)) {
+        pathname = pathname.slice(1);
+    }
+    // Split on both separators so a Windows-materialized path (backslashes) and a
+    // posix path both segment identically.
+    const segments = pathname.split(/[\\/]/);
+    let markerIndex = -1;
+    for (let i = segments.length - 1; i >= 0; i--) {
+        if (segments[i] === "src" || segments[i] === "build") {
+            markerIndex = i;
+            break;
+        }
+    }
+    if (markerIndex <= 0)
+        return null;
+    return segments.slice(0, markerIndex).join("/");
+}
+/** Manual basename that tolerates either path separator. */
+function basenameAnySep(filePath) {
+    const segments = filePath.split(/[\\/]/);
+    return segments[segments.length - 1] ?? "";
+}
+/**
+ * Resolve how the worker MCP shim should be launched, preferring the conductor's
+ * own on-disk build by absolute path and falling back to a resolvable npm channel.
+ *
+ * Resolution order (never uses `process.cwd()`):
+ *   1. `<packageRoot>/build/index.js` derived from `deps.moduleUrl`.
+ *   2. `deps.argv1` when it is absolute, exists, and its basename is `index.js`.
+ *   3. npm-channel fallback (`deps.npmPackageSpec ?? DEFAULT_MCP_SERVER_NPM_CHANNEL_SPEC`).
+ *
+ * NOTE (scope boundary): this ticket changes WHICH server file is invoked, not
+ * WHICH Node runtime runs it. `nodeExecutable` defaults to `"node"` (NOT
+ * `process.execPath`) to preserve today's worker runtime selection; Ticket 3 (P2)
+ * can later inject `CONDUCTOR_NODE_PATH` into this single field.
+ */
+export function resolveMcpShimInvocationForRuntime(deps) {
+    const nodeExecutable = deps.nodeExecutable ?? "node";
+    const packageRoot = resolvePackageRootFromModuleUrl(deps.moduleUrl);
+    if (packageRoot) {
+        const candidate = `${packageRoot}/build/index.js`;
+        if (deps.fileExists(candidate)) {
+            return { form: "absolute-build-path", nodeExecutable, serverEntryPath: candidate };
+        }
+    }
+    const argv1 = deps.argv1;
+    if (typeof argv1 === "string" &&
+        argv1.length > 0 &&
+        path.isAbsolute(argv1) &&
+        basenameAnySep(argv1) === "index.js" &&
+        deps.fileExists(argv1)) {
+        return { form: "absolute-build-path", nodeExecutable, serverEntryPath: argv1 };
+    }
+    return {
+        form: "npm-channel",
+        command: "npx",
+        packageSpec: deps.npmPackageSpec ?? DEFAULT_MCP_SERVER_NPM_CHANNEL_SPEC,
+    };
+}