@bridge_gpt/mcp-server 0.2.67 → 0.2.68

package/build/executor/guarded-fast-forward-push.js

@@ -0,0 +1,129 @@
+export const PUSH_TIMEOUT_MS = 180_000;
+export const PUSH_AUTH_FAILURE_RE = /authentication failed|could not read username|permission denied|terminal prompts disabled|invalid username or password|returned error: 403|requested url returned error: 401/i;
+const PUSH_LEASE_FAILURE_RE = /stale info|\[rejected\]|non-fast-forward|fetch first/i;
+const SHA = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i;
+export function isSafePublicationBranch(branch) {
+    return branch.length > 0 && !branch.startsWith("-") && !branch.startsWith("/") &&
+        !branch.endsWith("/") && !branch.endsWith(".") && branch !== "@" &&
+        !/[\x00-\x20\x7f~^:?*\[\\+]/.test(branch) && !branch.includes("..") &&
+        !branch.includes("@{") && !branch.includes("//") &&
+        branch.split("/").every(part => !part.startsWith(".") && !part.endsWith(".lock"));
+}
+/** No command text, remote URL, or environment escapes this closed outcome. */
+export async function guardedFastForwardPush(input) {
+    const refuse = (reason) => ({ status: "refused", reason });
+    if (!isSafePublicationBranch(input.branch) || !SHA.test(input.expectedOriginSha) ||
+        input.trustedExcludedShas?.some(sha => !SHA.test(sha)) ||
+        (input.candidateSha !== undefined && (!SHA.test(input.candidateSha) || input.candidateSha === input.expectedOriginSha)))
+        return refuse("invalid_input");
+    let timedOut = false;
+    const git = async (args) => {
+        const timeoutMs = Math.min(PUSH_TIMEOUT_MS, input.remainingMs());
+        if (timeoutMs <= 0 || (!input.mayMutate() || input.signal?.aborted)) {
+            timedOut = true;
+            return { exitCode: 124, stdout: "", stderr: "" };
+        }
+        return input.runCommand("git", args, { cwd: input.worktreePath, timeoutMs, signal: input.signal,
+            env: { ...input.env, GIT_TERMINAL_PROMPT: "0" } });
+    };
+    try {
+        if ((await git(["check-ref-format", "--branch", input.branch])).exitCode !== 0)
+            return refuse("invalid_input");
+        const branch = await git(["symbolic-ref", "--quiet", "--short", "HEAD"]);
+        if (branch.exitCode !== 0 || branch.stdout.trim() !== input.branch)
+            return refuse("branch_mismatch");
+        const head = await git(["rev-parse", "HEAD"]);
+        const candidate = head.stdout.trim().toLowerCase();
+        if (head.exitCode !== 0 || !SHA.test(candidate))
+            return refuse("ancestry_unknown");
+        if (candidate === input.expectedOriginSha.toLowerCase() ||
+            (input.candidateSha !== undefined && candidate !== input.candidateSha.toLowerCase()))
+            return refuse("invalid_input");
+        const ancestor = await git(["merge-base", "--is-ancestor", input.expectedOriginSha, "HEAD"]);
+        if (ancestor.exitCode === 1)
+            return refuse("not_fast_forward");
+        if (ancestor.exitCode !== 0)
+            return refuse("ancestry_unknown");
+        for (const sha of input.trustedExcludedShas ?? []) {
+            if ((await git(["cat-file", "-e", `${sha}^{commit}`])).exitCode !== 0 ||
+                (await git(["merge-base", "--is-ancestor", sha, "HEAD"])).exitCode !== 0)
+                return refuse("range_unreadable");
+        }
+        const range = await git(["rev-list", "HEAD", `^${input.expectedOriginSha}`, ...(input.trustedExcludedShas ?? []).map(sha => `^${sha}`)]);
+        const commits = range.stdout.trim().split(/\s+/);
+        if (range.exitCode !== 0 || commits.length === 0 || commits.some(sha => !SHA.test(sha)))
+            return refuse("range_unreadable");
+        const workflow = (paths) => paths.split("\0").some(path => path.startsWith(".github/workflows/"));
+        for (const commit of commits) {
+            const parentsResult = await git(["rev-list", "--parents", "-n", "1", commit]);
+            const ids = parentsResult.stdout.trim().split(/\s+/);
+            if (parentsResult.exitCode !== 0 || ids[0] !== commit || ids.some(sha => !SHA.test(sha)))
+                return refuse("range_unreadable");
+            const parents = ids.slice(1);
+            let paths;
+            if (parents.length > 1) {
+                if (parents.length !== 2)
+                    return refuse("range_unreadable");
+                // Compare the candidate resolution to Git's automatic merge, rather than
+                // attributing already-published excluded parent changes to the worker.
+                const merge = await git(["merge-tree", "--write-tree", "-z", "--name-only", "--messages", parents[0], parents[1]]);
+                const tokens = merge.stdout.split("\0");
+                const tree = tokens[0]?.trim() ?? "";
+                if (![0, 1].includes(merge.exitCode) || !SHA.test(tree) || !merge.stdout.endsWith("\0"))
+                    return refuse("range_unreadable");
+                const endPaths = tokens.indexOf("", 1);
+                if (endPaths < 0)
+                    return refuse("range_unreadable");
+                const conflicts = tokens.slice(1, endPaths);
+                if (merge.exitCode === 1 && conflicts.length === 0)
+                    return refuse("range_unreadable");
+                if (conflicts.some(path => path.startsWith(".github/workflows/")))
+                    return refuse("workflow_files_in_range");
+                for (let at = endPaths + 1; at < tokens.length - 1;) {
+                    if (tokens[at] === "")
+                        break;
+                    const count = Number(tokens[at]);
+                    if (!Number.isInteger(count) || count < 1 || at + count + 2 >= tokens.length - 1)
+                        return refuse("range_unreadable");
+                    at += count + 3;
+                }
+                paths = await git(["diff-tree", "-r", "--no-commit-id", "--name-only", "--no-renames", "-z", tree, commit]);
+            }
+            else {
+                paths = await git(["diff-tree", "--root", "-r", "--no-commit-id", "--name-only", "--no-renames", "-z", commit]);
+            }
+            if (paths.exitCode !== 0)
+                return refuse("range_unreadable");
+            if (workflow(paths.stdout))
+                return refuse("workflow_files_in_range");
+        }
+        // Re-check HEAD and ownership immediately before mutation.
+        const latest = await git(["rev-parse", "HEAD"]);
+        if (latest.exitCode !== 0 || latest.stdout.trim().toLowerCase() !== candidate)
+            return refuse("ancestry_unknown");
+        if ((!input.mayMutate() || input.signal?.aborted) || input.remainingMs() <= 0)
+            return refuse("timeout");
+        const destination = `refs/heads/${input.branch}`;
+        const push = await git(["push", "--no-verify", "--porcelain",
+            `--force-with-lease=${destination}:${input.expectedOriginSha}`, "origin", `HEAD:${destination}`]);
+        const text = `${push.stdout}\n${push.stderr}`;
+        if (timedOut || push.exitCode === 124 || /timed out|timeout/i.test(text))
+            return refuse("timeout");
+        if (PUSH_AUTH_FAILURE_RE.test(text))
+            return refuse("auth_failed");
+        if (PUSH_LEASE_FAILURE_RE.test(text))
+            return refuse("lease_rejected");
+        if (push.exitCode !== 0)
+            return refuse("remote_rejected");
+        const update = push.stdout.split("\n").some(line => {
+            const parts = line.split("\t");
+            return parts[0] === " " && parts[1] === `HEAD:${destination}`;
+        });
+        if (!update)
+            return refuse("lease_rejected");
+        return { status: "published", from_sha: input.expectedOriginSha.toLowerCase(), to_sha: candidate };
+    }
+    catch {
+        return refuse(timedOut || input.remainingMs() <= 0 ? "timeout" : "remote_rejected");
+    }
+}

package/build/executor/integration-job.js

@@ -14,7 +14,12 @@
  *   epic branch through the provider's merge API. No checkout, no force.
  * * `mark_ready` — finds the ONE open pull request from the epic branch to the
  *   base (creating it only after conclusive absence), confirms its head is the
- *   expected epic head, and takes it out of draft.
+ *   expected epic head, and takes it out of draft. BAPI-1399: first it lists the
+ *   workaround folder `.bridge/epic-workarounds/` (the canonical path, imported
+ *   from `../epic-workarounds-path.ts`) at the expected epic head. While the folder is
+ *   present it only finds or creates the draft and reports `already_satisfied`
+ *   with `detail_code: "workarounds_present"`, so a stale coordinator
+ *   observation can never take the pull request out of draft.
  * * `correct` — runs ONE worker through the executor's existing locked spawn
  *   path under a driver that prepares the epic branch, verifies the worker's
  *   edits, makes the one commit, and performs the one push. The worker has no
@@ -46,7 +51,8 @@
  * and this module chooses no next ticket and no gate.
  */
 import { buildLocalMergeChildEnv, resolveLocalMergeCredential, sanitizeLocalMergeOutput, } from "../conductor/local-merge.js";
-import { createProductionEpicIntegrationGhRunner, ensureEpicIntegrationPullRequest, } from "../epic-integration-pr.js";
+import { EPIC_INTEGRATION_PR_READ_TIMEOUT_MS, createProductionEpicIntegrationGhRunner, ensureEpicIntegrationPullRequest, } from "../epic-integration-pr.js";
+import { EPIC_WORKAROUNDS_DIR_PATH } from "../epic-workarounds-path.js";
 import { INTEGRATION_ACTION_OPERATIONS, INTEGRATION_ACTION_OUTCOMES, INTEGRATION_ACTION_PROTOCOL_VERSION, } from "./types.js";
 /** The route prefix, mirrored from `api/routes/__init__.py`. */
 export const INTEGRATION_ACTION_ROUTE_PREFIX = "/epic-integration-actions";
@@ -386,20 +392,128 @@ function mapPullRequestOutcome(outcome) {
             return { outcome: "indeterminate", detail_code: safeDetail(outcome.reason) };
     }
 }
-async function performMarkReady(action, deps, env, seams) {
+// ---------------------------------------------------------------------------
+// BAPI-1399: the workaround folder re-check
+// ---------------------------------------------------------------------------
+/** The `detail_code` a held `mark_ready` reports on its `already_satisfied` outcome. */
+export const WORKAROUNDS_PRESENT_DETAIL_CODE = "workarounds_present";
+/**
+ * Classify one contents-API answer for `.bridge/epic-workarounds/`. Pure, and
+ * the twin of `classify_workaround_listing` in
+ * `api/library/github/github_webhooks_lib.py`; both suites read the shared
+ * parity vectors. `absent` needs a 404 AND proof that the repository and the
+ * epic head were readable with the same credential; anything the reader cannot
+ * establish — an unproven 404, any other status, no status, an empty array, an
+ * object, or entries that are not directory records — is `failed`.
+ */
+export function classifyWorkaroundListing(status, body, accessProven) {
+    if (status === 404)
+        return accessProven === true ? "absent" : "failed";
+    if (status !== 200)
+        return "failed";
+    if (!Array.isArray(body) || body.length === 0)
+        return "failed";
+    for (const entry of body) {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+            return "failed";
+        const name = entry.name;
+        if (typeof name !== "string" || name.length === 0)
+            return "failed";
+    }
+    return "present";
+}
+/**
+ * List the workaround folder at the expected epic head through the restricted
+ * credentialed `gh` environment, with a bounded timeout. `accessProven` is true
+ * only when the caller read the epic head with this same credential in this
+ * attempt. Never throws; a failure is `failed`, never absence.
+ */
+async function listEpicWorkarounds(deps, credential, env, repository, expectedEpicHeadSha, accessProven) {
+    if (!PROVIDER_REPOSITORY_RE.test(repository) || !SHA_RE.test(expectedEpicHeadSha))
+        return "failed";
+    const r = await runCredentialed(deps, credential, env, "gh", [
+        "api", "--include",
+        `repos/${repository}/contents/${EPIC_WORKAROUNDS_DIR_PATH}?ref=${expectedEpicHeadSha}`,
+    ], { timeoutMs: READ_TIMEOUT_MS });
+    const status = parseGhHttpStatus(r.stdout, r.stderr);
+    if (status === 200 && r.exitCode !== 0)
+        return "failed";
+    return classifyWorkaroundListing(status, status === 200 ? parseIncludedBody(r.stdout) : null, accessProven);
+}
+/**
+ * Read one pull request's draft flag, branches, and head, bounded. The draft-only
+ * path of {@link ensureEpicIntegrationPullRequest} does not bind the head, so the
+ * held path proves the binding itself before it reports a hold. `null` when the
+ * read fails or the answer is not well formed.
+ */
+async function readPullRequestBinding(gh, prNumber, repository, cwd) {
+    try {
+        const r = await gh([
+            "pr", "view", String(prNumber), "--repo", repository,
+            "--json", "isDraft,headRefName,baseRefName,headRefOid",
+        ], { cwd, timeoutMs: EPIC_INTEGRATION_PR_READ_TIMEOUT_MS });
+        if (r.exitCode !== 0)
+            return null;
+        const parsed = JSON.parse(r.stdout);
+        if (typeof parsed !== "object" || parsed === null)
+            return null;
+        const { isDraft, headRefName, baseRefName, headRefOid } = parsed;
+        if (typeof isDraft !== "boolean" || typeof headRefName !== "string" || typeof baseRefName !== "string") {
+            return null;
+        }
+        const sha = typeof headRefOid === "string" ? headRefOid.toLowerCase() : "";
+        return { isDraft, headRefName, baseRefName, headSha: SHA_RE.test(sha) ? sha : null };
+    }
+    catch {
+        return null;
+    }
+}
+async function performMarkReady(action, deps, credential, env, seams) {
     const createGh = seams.createGhRunner ?? ((e) => createProductionEpicIntegrationGhRunner(undefined, e));
-    const outcome = await ensureEpicIntegrationPullRequest({
+    const gh = createGh(env);
+    const ensure = (requestReady) => ensureEpicIntegrationPullRequest({
         epicKey: action.epic_key,
         epicBranch: action.epic_branch,
         baseBranch: action.base_branch,
         command: "executor integration",
-        gh: createGh(env),
+        gh,
         cwd: deps.cwd,
-        requestReady: true,
+        requestReady,
         expectedHeadSha: action.expected_epic_head_sha,
         repo: action.provider_repository,
     });
-    return mapPullRequestOutcome(outcome);
+    // The caller read the live epic head with this same credential immediately
+    // before this call, so a 404 here can only mean the folder is absent.
+    const listing = await listEpicWorkarounds(deps, credential, env, action.provider_repository, action.expected_epic_head_sha, true);
+    if (listing === "failed") {
+        // Unreadable is never absence: report indeterminate, which spends one
+        // reconciliation probe exactly as any other unreadable observation does.
+        return { outcome: "indeterminate", detail_code: "probe_inconclusive" };
+    }
+    if (listing === "absent")
+        return mapPullRequestOutcome(await ensure(true));
+    // Present: find or create the draft and leave it a draft. `not_requested` is
+    // never passed through `mapPullRequestOutcome`, which would read it as failed.
+    const outcome = await ensure(false);
+    if (outcome.kind !== "already_open" && outcome.kind !== "created") {
+        return mapPullRequestOutcome(outcome);
+    }
+    if (outcome.prNumber === null)
+        return { outcome: "indeterminate", detail_code: "probe_inconclusive" };
+    const pr = outcome.prNumber;
+    const binding = await readPullRequestBinding(gh, pr, action.provider_repository, deps.cwd);
+    if (binding === null)
+        return { outcome: "indeterminate", pr_number: pr, detail_code: "probe_inconclusive" };
+    if (binding.headRefName !== action.epic_branch || binding.baseRefName !== action.base_branch) {
+        return { outcome: "pr_ambiguous", pr_number: pr, detail_code: "probe_ambiguous" };
+    }
+    if (binding.headSha !== action.expected_epic_head_sha) {
+        return { outcome: "head_drift", pr_number: pr, detail_code: "pr_head_moved" };
+    }
+    // A non-draft PR is never claimed as held: it is already ready, as today.
+    if (!binding.isDraft)
+        return { outcome: "already_satisfied", pr_number: pr };
+    return { outcome: "already_satisfied", pr_number: pr, detail_code: WORKAROUNDS_PRESENT_DETAIL_CODE };
 }
 /**
  * Perform one claimed integration action and report its facts.
@@ -469,7 +583,7 @@ export async function runIntegrationAction(action, client, deps, seams = {}) {
                 report = await performSyncBase(action, deps, credential, env, reads);
             }
             else if (action.operation === "mark_ready") {
-                report = await performMarkReady(action, deps, env, seams);
+                report = await performMarkReady(action, deps, credential, env, seams);
             }
             else if (seams.runCorrection === undefined) {
                 report = { outcome: "failed", detail_code: "correction_unsupported" };

package/build/executor/job-errors.js

@@ -39,7 +39,7 @@
  *    origin, but not this worker's latest commit. Distinct from
  *    `WorkerFinalizationMissingRemoteBranchAndPr` (which covers "no evidence any
  *    work reached origin") because this case has positive proof of recoverable
- *    state: an operator can resume/finalize from the existing branch rather than
+ *    state: an operator can preserve the newer local worktree commit rather than
  *    re-running from scratch; see `worker-finalization.ts`.
  *  - `WorkerFinalizationOriginUnverifiable` — an implementation-style job
  *    (BAPI-1357) exited cleanly, but the origin branch lookup could not be
@@ -164,6 +164,13 @@ export const WorkerFinalizationOriginUnverifiable = "WorkerFinalizationOriginUnv
  * no event text, command, path, or output.
  */
 export const WorkerEndedWithPendingBackgroundWork = "WorkerEndedWithPendingBackgroundWork";
+/**
+ * BAPI-1392: a recognized Bridge command's packaged recipe could not be delivered
+ * to the worker. Refused before spawn rather than silently running the committed
+ * copy, which may be stale. The message carries a fixed `reason=<code>` token and
+ * a command name only — never prompt text, arguments, or recipe bytes.
+ */
+export const PackagedRecipeUndeliverable = "ContractError.PackagedRecipeUndeliverable";
 export const WorkerConfigIsolation = "ContractError.WorkerConfigIsolation";
 export const PreSpawnVerification = "ContractError.PreSpawnVerification";
 export const BridgeCredentialUnavailable = "ContractError.BridgeCredentialUnavailable";