@bridge_gpt/mcp-server 0.2.62 → 0.2.65

package/build/executor/worker-finalization.js

@@ -58,6 +58,16 @@
  */
 import { ReconcileOverlapPushUnfinalized, secretFreeErrorMessage, WorkerFinalizationMissingRemoteBranchAndPr, WorkerFinalizationPrBaseMismatch, WorkerFinalizationPrNotAttached, WorkerFinalizationSavedButUnfinalized, } from "./job-errors.js";
 import { isImplementationStyleJobType } from "./job-types.js";
+/** The `runCommand` options for one bounded read; `{ cwd }` alone when unbounded. */
+function callOptions(worktreePath, bound) {
+    return bound && typeof bound.timeoutMs === "number"
+        ? { cwd: worktreePath, timeoutMs: Math.max(1, Math.floor(bound.timeoutMs)) }
+        : { cwd: worktreePath };
+}
+/** True when a bounded call has no time left and must not be issued at all. */
+function callExpired(bound) {
+    return bound !== undefined && typeof bound.timeoutMs === "number" && bound.timeoutMs <= 0;
+}
 /** Bounded settling re-check defaults for the authoritative origin-tip lookup. */
 const DEFAULT_ORIGIN_FINALIZATION_ATTEMPTS = 3;
 const DEFAULT_ORIGIN_FINALIZATION_RETRY_DELAY_MS = 500;
@@ -113,9 +123,11 @@ function parseLsRemoteHeadSha(stdout, expectedRef) {
  * on a recovery worktree. A non-zero exit is treated as "branch not found"
  * without copying raw stderr into diagnostics.
  */
-export async function resolveOriginBranchSha(runCommand, worktreePath, branch) {
+export async function resolveOriginBranchSha(runCommand, worktreePath, branch, bound) {
     const normalizedRef = normalizeBranchRef(branch);
-    const result = await runCommand("git", ["ls-remote", "--exit-code", "--heads", "origin", normalizedRef], { cwd: worktreePath });
+    if (callExpired(bound))
+        return null;
+    const result = await runCommand("git", ["ls-remote", "--exit-code", "--heads", "origin", normalizedRef], callOptions(worktreePath, bound));
     if (result.exitCode !== 0)
         return null;
     return parseLsRemoteHeadSha(result.stdout, normalizedRef);
@@ -129,11 +141,11 @@ export async function resolveOriginBranchSha(runCommand, worktreePath, branch) {
  * yet match. Returns the LAST authoritative observation — the caller decides
  * loud-failure from that final value, so true negatives are preserved.
  */
-async function resolveOriginBranchShaForFinalization(runCommand, worktreePath, branch, trimmedHeadSha, attempts, retryDelayMs, sleep) {
+async function resolveOriginBranchShaForFinalization(runCommand, worktreePath, branch, trimmedHeadSha, attempts, retryDelayMs, sleep, bound) {
     const total = Math.max(1, attempts);
     let remoteSha = null;
     for (let attempt = 0; attempt < total; attempt++) {
-        remoteSha = await resolveOriginBranchSha(runCommand, worktreePath, branch);
+        remoteSha = await resolveOriginBranchSha(runCommand, worktreePath, branch, bound?.());
         if (remoteSha !== null) {
             // Existence-only success when HEAD is unknown; exact-match success otherwise.
             if (!trimmedHeadSha || remoteSha === trimmedHeadSha) {
@@ -170,14 +182,16 @@ const PR_LOOKUP_ABSENT = {
  * collapses to {@link PR_LOOKUP_ABSENT} without copying raw stderr, an
  * authenticated remote, or the command line into anything the caller can render.
  */
-async function resolvePrForFinalization(runCommand, worktreePath, branch) {
+async function resolvePrForFinalization(runCommand, worktreePath, branch, bound) {
     const args = ["pr", "view"];
     if (branch)
         args.push(branch);
     args.push("--json", PR_VIEW_JSON_FIELDS);
+    if (callExpired(bound))
+        return PR_LOOKUP_ABSENT;
     let result;
     try {
-        result = await runCommand("gh", args, { cwd: worktreePath });
+        result = await runCommand("gh", args, callOptions(worktreePath, bound));
     }
     catch {
         return PR_LOOKUP_ABSENT;
@@ -398,6 +412,8 @@ export async function validateWorkerFinalization(input) {
     if (!isImplementationStyleJobType(job.job_type)) {
         return { ok: true };
     }
+    // BAPI-1311: resolved fresh for every call so each read gets only the time left.
+    const bound = () => input.callTimeoutMs ? { timeoutMs: input.callTimeoutMs() } : undefined;
     const hasPrUrl = Boolean(extractPrUrl(result));
     // BAPI-762: `branch`/`headSha` are normalized once here and reused through the
     // rest of the check — including by the diagnostics below — instead of being
@@ -418,7 +434,7 @@ export async function validateWorkerFinalization(input) {
     // unconditional. Their dispositions still differ on purpose (see `PrLookup`),
     // and the ORDER is unchanged: a wrong-base PR is still reported before any
     // origin lookup, exactly as BAPI-586 specified.
-    let pr = await resolvePrForFinalization(runCommand, worktreePath, trimmedBranch);
+    let pr = await resolvePrForFinalization(runCommand, worktreePath, trimmedBranch, bound());
     // BAPI-586: a wrong-base PR (opened against a dependency's feature branch or the
     // repo default instead of the run base) never fires `claude-review.yml` and
     // strands the ticket at `code_review`. When the run base is known, fail loud on
@@ -448,7 +464,7 @@ export async function validateWorkerFinalization(input) {
     const sleep = input.sleep ?? sleepMs;
     let origin;
     try {
-        origin = await resolveOriginBranchShaForFinalization(runCommand, worktreePath, trimmedBranch, trimmedHeadSha, attempts, retryDelayMs, sleep);
+        origin = await resolveOriginBranchShaForFinalization(runCommand, worktreePath, trimmedBranch, trimmedHeadSha, attempts, retryDelayMs, sleep, bound);
     }
     catch (err) {
         return {
@@ -497,7 +513,7 @@ export async function validateWorkerFinalization(input) {
     // base check fail-opened on it, and the PR that has since appeared must not
     // reach success without that check.
     if (origin.attemptsUsed > 1) {
-        pr = await resolvePrForFinalization(runCommand, worktreePath, trimmedBranch);
+        pr = await resolvePrForFinalization(runCommand, worktreePath, trimmedBranch, bound());
         const refreshedBaseVerdict = evaluatePrBase(job, pr, expectedBase);
         if (refreshedBaseVerdict)
             return { ok: false, failure: refreshedBaseVerdict };
@@ -505,7 +521,7 @@ export async function validateWorkerFinalization(input) {
     let contract = evaluatePrContract(pr, trimmedHeadSha);
     for (let attempt = 1; attempt < attempts && !contract.ok && contract.retryable; attempt++) {
         await sleep(retryDelayMs);
-        pr = await resolvePrForFinalization(runCommand, worktreePath, trimmedBranch);
+        pr = await resolvePrForFinalization(runCommand, worktreePath, trimmedBranch, bound());
         contract = evaluatePrContract(pr, trimmedHeadSha);
     }
     if (!contract.ok) {
@@ -514,5 +530,66 @@ export async function validateWorkerFinalization(input) {
             failure: prNotAttachedFailure(job, trimmedBranch, trimmedHeadSha, expectedBase, contract.detail),
         };
     }
-    return { ok: true, prUrl: pr.url ?? undefined, prNumber: pr.prNumber };
+    return {
+        ok: true,
+        prUrl: pr.url ?? undefined,
+        prNumber: pr.prNumber,
+        // BAPI-1311: the verified origin tip — proven equal to the worker's HEAD above
+        // whenever that HEAD was known. Only for a caller that asked for it.
+        ...(input.exposePushedHead === true ? { pushedHeadSha: remoteSha } : {}),
+    };
+}
+// ---------------------------------------------------------------------------
+// BAPI-1311 — the focused rebase wait's pull-request read
+// ---------------------------------------------------------------------------
+/**
+ * The bounded public projection the focused rebase wait asks for. Separate from
+ * {@link PR_VIEW_JSON_FIELDS} on purpose: legacy finalization keeps its exact
+ * field selection, and only the rebase wait pays for state and mergeability.
+ */
+const FOCUSED_PR_VIEW_JSON_FIELDS = "number,state,headRefOid,headRefName,baseRefName,mergeable";
+/**
+ * Read the bound pull request's current state with ONE bounded `gh pr view`.
+ *
+ * Addresses the pull request by NUMBER, never by branch, so a second pull request
+ * opened for the same branch can never be mistaken for the bound one. Parses only
+ * {@link FOCUSED_PR_VIEW_JSON_FIELDS}; raw stdout/stderr never leave this
+ * function. An already-expired bound issues no command at all.
+ */
+export async function readFocusedPullRequest(runCommand, worktreePath, prNumber, bound) {
+    if (!Number.isInteger(prNumber) || prNumber <= 0 || callExpired(bound)) {
+        return { available: false };
+    }
+    let result;
+    try {
+        result = await runCommand("gh", ["pr", "view", String(prNumber), "--json", FOCUSED_PR_VIEW_JSON_FIELDS], callOptions(worktreePath, bound));
+    }
+    catch {
+        return { available: false };
+    }
+    if (result.exitCode !== 0)
+        return { available: false };
+    let parsed;
+    try {
+        parsed = JSON.parse(result.stdout);
+    }
+    catch {
+        return { available: false };
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return { available: false };
+    const obj = parsed;
+    const rawState = nonBlankString(obj.state);
+    const rawHead = nonBlankString(obj.headRefOid);
+    const rawMergeable = nonBlankString(obj.mergeable);
+    const mergeable = rawMergeable === "MERGEABLE" ? "mergeable" : rawMergeable === "CONFLICTING" ? "conflicting" : "unknown";
+    return {
+        available: true,
+        number: typeof obj.number === "number" && Number.isInteger(obj.number) ? obj.number : null,
+        state: rawState === null ? null : rawState.toUpperCase(),
+        headRefOid: rawHead === null ? null : rawHead.toLowerCase(),
+        headRefName: nonBlankString(obj.headRefName),
+        baseRefName: nonBlankString(obj.baseRefName),
+        mergeable,
+    };
 }

package/build/executor/worker-guard-hook.js

@@ -63,6 +63,12 @@ export const WORKER_GUARD_MALFORMED_LINE = `${WORKER_GUARD_REASON_PREFIX}: paylo
  * than a rule a caller is asked to remember.
  */
 export function renderWorkerGuardReason(category, family) {
+    if (category === "git-ambiguous") {
+        return (`${WORKER_GUARD_REASON_PREFIX}: denied ${family} (${category}). ` +
+            "This shell form cannot be safely resolved: substitution, redirection, or " +
+            "stdin-fed arguments hide what git will run. Use literal arguments instead; " +
+            "for a commit message, write it to a file and run git commit -F <file>.");
+    }
     return (`${WORKER_GUARD_REASON_PREFIX}: denied ${family} (${category}). ` +
         "This command family is restricted to the worker's own branch, worktree, and " +
         "read-only network access. Use a different approach and continue.");
@@ -618,11 +624,30 @@ function classify(executable) {
         return "network";
     return null;
 }
+/**
+ * The category an unmodelable `git` segment denies with.
+ *
+ * CLASSIFICATION ONLY. The caller has already decided to deny; this picks the
+ * truthful reason. A literal `push`, `reset`, or `clean` subcommand keeps its own
+ * category, because the worker does need to know it hit that restriction. Anything
+ * else — a literal `commit`, or a subcommand token built from `$…` or a backtick —
+ * is `git-ambiguous`: no dynamic token is ever guessed to be `push`.
+ */
+function unsafeGitCategory(argv) {
+    const { subcommand } = parseGitInvocation(argv, undefined);
+    if (subcommand === "push")
+        return "git-push";
+    if (subcommand === "reset")
+        return "git-reset-hard";
+    if (subcommand === "clean")
+        return "filesystem-clean";
+    return "git-ambiguous";
+}
 /** The category a governed family denies with when its segment is unmodelable. */
-function unsafeSegmentDecision(family) {
+function unsafeSegmentDecision(family, argv) {
     switch (family) {
         case "git":
-            return { kind: "deny", category: "git-push", family: "git" };
+            return { kind: "deny", category: unsafeGitCategory(argv), family: "git" };
         case "rm":
             return { kind: "deny", category: "filesystem-remove", family: "rm" };
         case "database":
@@ -810,11 +835,11 @@ function evaluateSimpleCommand(segment, ctx, payloadCwd, depth = 0, stdinFed = f
     // under `stdinFed` can never be proven safe regardless of how its visible argv
     // looks — the fail-CLOSED rule, applied after every wrapper has been resolved.
     if (stdinFed)
-        return unsafeSegmentDecision(family);
+        return unsafeSegmentDecision(family, segment.argv);
     // A governed family inside a segment carrying substitution or redirection can
     // never be proven safe — deny, per the fail-CLOSED half of the contract.
     if (segment.unsafe)
-        return unsafeSegmentDecision(family);
+        return unsafeSegmentDecision(family, segment.argv);
     const cwd = resolveEffectiveCwd(ctx, payloadCwd);
     if (family === "rm")
         return evaluateRemove(segment.argv, ctx, cwd);

package/build/executor/worktree.js

@@ -95,6 +95,19 @@ async function finalizeExecutorWorktree(worktreePath, branch, expectedHeadSha, d
     }
     return { ok: true, worktreePath, branch, expectedHeadSha };
 }
+/**
+ * BAPI-1300 — finish a RETAINED continuation worktree the same way a created one
+ * is finished: pin its current HEAD as the pre-spawn expectation and provision
+ * its commands. The worktree itself is not touched: no fetch, no reset, no
+ * recreation — its (already verified and checkpointed) local state is the work.
+ */
+export async function finalizeRetainedExecutorWorktree(worktreePath, branch, deps) {
+    const headSha = await resolveCommitSha(deps, worktreePath, "HEAD");
+    if (headSha === null) {
+        return { ok: false, error: `failed to resolve HEAD of the retained worktree for '${branch}'` };
+    }
+    return finalizeExecutorWorktree(worktreePath, branch, headSha, deps);
+}
 /** A full 40-character hex object name. */
 const FULL_SHA_PATTERN = /^[0-9a-f]{40}$/i;
 /**