@bridge_gpt/mcp-server 0.2.30 → 0.2.32

package/build/executor/worktree.js

@@ -9,6 +9,7 @@
 import { fetchAndResolveBaseSha } from "../base-ref.js";
 import { commandSucceeded } from "../start-tickets-prereqs.js";
 import { createWorktreeForTicket } from "../worktree-core.js";
+import { provisionCommandsForWorktree } from "../command-provisioning.js";
 /**
  * Resolve the branch for a real spawn job: `expected_branch` wins; else
  * `feature/<ticket_key>`; else a structured contract failure.
@@ -35,6 +36,34 @@ function toWorktreeCoreDeps(deps) {
         cwd: deps.cwd,
     };
 }
+/** Build the command-provisioning boundary from the executor deps (BAPI-664). */
+function toCommandProvisioningDeps(deps) {
+    return {
+        readFile: deps.readFile,
+        writeFile: deps.writeFile,
+        mkdir: deps.mkdir,
+        runCommand: deps.runCommand,
+        platform: deps.platform,
+        cwd: deps.cwd,
+    };
+}
+/**
+ * Finalize a resolved executor worktree by bootstrapping the packaged Claude
+ * command assets into it (BAPI-664) BEFORE the worker process is handed the
+ * worktree path. A provisioning failure is mapped into the executor's existing
+ * bounded non-success worktree result so the affected worker is not launched with
+ * a missing slash command, while the executor process stays available for later
+ * jobs. On success the existing successful ensure-worktree result shape is
+ * preserved unchanged. Errors stay secret-free (no raw filesystem exception, Git
+ * output, or command contents).
+ */
+async function finalizeExecutorWorktree(worktreePath, branch, deps) {
+    const provisioned = await provisionCommandsForWorktree(worktreePath, toCommandProvisioningDeps(deps));
+    if (!provisioned.ok) {
+        return { ok: false, error: provisioned.error };
+    }
+    return { ok: true, worktreePath, branch };
+}
 /**
  * Ensure the worktree for a job exists, delegating to the shared Worktrunk
  * primitive. A create failure is returned as a structured failure that the job
@@ -92,7 +121,7 @@ export async function ensureExecutorWorktree(job, options, deps, policy = {}) {
         // (= `origin/<branch>`) inside the primitive, so both land at origin.
         { freshenFromOrigin: originRef });
         if (row.status === "created" && typeof row.path === "string") {
-            return { ok: true, worktreePath: row.path, branch };
+            return finalizeExecutorWorktree(row.path, branch, deps);
         }
         return { ok: false, error: row.error ?? `worktree creation failed for branch '${branch}'` };
     }
@@ -117,7 +146,7 @@ export async function ensureExecutorWorktree(job, options, deps, policy = {}) {
     const baseSha = resolvedBase.base_sha;
     const row = await createWorktreeForTicket(toWorktreeCoreDeps(deps), key, { [key]: branch }, options.worktrunkBinary, baseSha, guardStaleWorktree, { alignExistingBranchTo: baseSha, verifyHeadMatches: baseSha });
     if (row.status === "created" && typeof row.path === "string") {
-        return { ok: true, worktreePath: row.path, branch };
+        return finalizeExecutorWorktree(row.path, branch, deps);
     }
     return { ok: false, error: row.error ?? `worktree creation failed for branch '${branch}'` };
 }

package/build/git-ignore-utils.js

@@ -4,22 +4,49 @@
  * Two idempotent, exact-line appenders:
  *   - `ensureGitignored` writes the tracked `<cwd>/.gitignore` (shared with the
  *     existing `--init` scaffolding behavior).
- *   - `ensureGitInfoExcluded` writes the UNtracked `<worktreeRoot>/.git/info/exclude`,
- *     used for Tier-3 file credentials that must never enter version control and
- *     must never touch the tracked `.gitignore`.
+ *   - `ensureGitInfoExcluded` writes the UNtracked, repository-common
+ *     `info/exclude`, used for Tier-3 file credentials and (BAPI-664) bootstrapped
+ *     Claude command assets that must never enter version control and must never
+ *     touch the tracked `.gitignore`.
+ *
+ * Linked-worktree note (BAPI-664): a worktree created by `git worktree add` (as
+ * Worktrunk does) does NOT contain a `.git` directory — it contains a `.git`
+ * *file* that points at the common Git directory. So the historical
+ * `<worktreeRoot>/.git/info/exclude` join is WRONG for a linked worktree. When a
+ * list-based `runCommand` and `platform` are injected, this helper asks Git for
+ * the authoritative path with `git rev-parse --git-path info/exclude` (relative
+ * to the worktree root); `info/exclude` lives in the common Git directory shared
+ * by all sibling worktrees, and an ignore rule never hides an already-tracked
+ * file, so the shared scope is safe. When `runCommand`/`platform` are absent the
+ * helper falls back to the legacy `<worktreeRoot>/.git/info/exclude` join, which
+ * remains correct for a main repository whose `.git` is a real directory (the
+ * SFCC dw.json caller relies on this).
  *
  * Both are dependency-injected so they are unit-testable without real I/O, and
- * neither ever includes credential file contents in an error.
+ * neither ever includes credential file contents — or raw Git/command output —
+ * in an error.
  */
 import path from "path";
+/** The `path` API for the target platform (win32 vs posix). */
+function pathApiForPlatform(platform) {
+    return platform === "win32" ? path.win32 : path.posix;
+}
 /** True when `content` already contains `entry` as its own exact (trimmed) line. */
 function hasExactLine(content, entry) {
     return content.split("\n").some((line) => line.trim() === entry);
 }
-/** Append `entry` to `content`, inserting a separating newline only if needed. */
+/** Detect the newline convention of existing content (CRLF wins if present). */
+function detectNewline(content) {
+    return /\r\n/.test(content) ? "\r\n" : "\n";
+}
+/**
+ * Append `entry` to `content`, inserting a separating newline only if needed and
+ * using the file's own newline convention (CRLF preserved when already present).
+ */
 function appendLine(content, entry) {
-    const separator = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
-    return content + separator + entry + "\n";
+    const newline = detectNewline(content);
+    const separator = content.length > 0 && !content.endsWith("\n") ? newline : "";
+    return content + separator + entry + newline;
 }
 /**
  * Idempotently ensure `filePath` is listed in `<cwd>/.gitignore`. An absolute
@@ -41,20 +68,46 @@ export async function ensureGitignored(cwd, filePath, deps) {
     await deps.writeFile(gitignorePath, appendLine(content, entry));
 }
 /**
- * Idempotently ensure `relativePath` is listed in the worktree's local-only
- * `<worktreeRoot>/.git/info/exclude`. Creates `<worktreeRoot>/.git/info` if it
- * does not exist. Matching is exact-line (so `dw.json` is not treated as present
- * just because `dw.json.bak` exists). Never edits the tracked `.gitignore`.
+ * Resolve the worktree's `info/exclude` path. With an injected `runCommand` +
+ * `platform`, ask Git (`git rev-parse --git-path info/exclude`) so linked
+ * worktrees resolve to the common Git directory; a Git failure or empty path
+ * throws a bounded, output-free error. Without them, fall back to the legacy
+ * `<worktreeRoot>/.git/info/exclude` join (correct for a main repository).
  */
-export async function ensureGitInfoExcluded(worktreeRoot, relativePath, deps) {
+async function resolveInfoExcludeLocation(worktreeRoot, deps) {
+    if (deps.runCommand && deps.platform) {
+        const api = pathApiForPlatform(deps.platform);
+        const result = await deps.runCommand("git", ["rev-parse", "--git-path", "info/exclude"], { cwd: worktreeRoot });
+        if (result.exitCode !== 0) {
+            // Never surface raw Git stdout/stderr (it can echo paths / tokens).
+            throw new Error("Failed to resolve the worktree info/exclude path via 'git rev-parse --git-path'.");
+        }
+        const raw = result.stdout.trim();
+        if (raw.length === 0) {
+            throw new Error("'git rev-parse --git-path info/exclude' returned an empty path.");
+        }
+        const excludePath = api.isAbsolute(raw) ? api.normalize(raw) : api.resolve(worktreeRoot, raw);
+        return { excludePath, infoDir: api.dirname(excludePath) };
+    }
     const infoDir = path.join(worktreeRoot, ".git", "info");
-    const excludePath = path.join(infoDir, "exclude");
+    return { excludePath: path.join(infoDir, "exclude"), infoDir };
+}
+/**
+ * Idempotently ensure `relativePath` is listed in the worktree's local-only,
+ * repository-common `info/exclude`. Resolves the exclude path via Git for linked
+ * worktrees (see module docstring) and creates its parent directory if missing.
+ * Matching is exact-line (so `dw.json` is not treated as present just because
+ * `dw.json.bak` exists) and the append respects the file's newline convention.
+ * Never edits the tracked `.gitignore`.
+ */
+export async function ensureGitInfoExcluded(worktreeRoot, relativePath, deps) {
+    const { excludePath, infoDir } = await resolveInfoExcludeLocation(worktreeRoot, deps);
     let content = "";
     try {
         content = await deps.readFile(excludePath);
     }
     catch {
-        /* exclude file (or .git/info) doesn't exist yet */
+        /* exclude file (or info dir) doesn't exist yet */
     }
     if (hasExactLine(content, relativePath))
         return;