@bridge_gpt/mcp-server 0.2.60 → 0.2.62

package/build/executor/credentials.js

@@ -17,7 +17,7 @@
  * never resolves or stores it, and `ANTHROPIC_API_KEY` remains absolutely denied
  * to a worker (`executor/env.ts`).
  */
-import { resolveBapiCredentials } from "../credential-store.js";
+import { readStoredBinding, resolveBapiCredentials } from "../credential-store.js";
 import { normalizeBaseUrlCandidate } from "../base-url.js";
 /**
  * The documented production Bridge API base URL — the value an operator pastes
@@ -79,6 +79,22 @@ export async function resolveExecutorApiAccess(repoName, deps, explicitBaseUrl)
             error: `could not resolve Bridge API credentials for repo '${trimmed}' (${result.kind})`,
         };
     }
+    // BAPI-1260: a stored key that guided setup approved for ONE endpoint is never
+    // sent to another. A restarted executor re-reads the binding here, so a unit
+    // whose --base-url drifted from the approved target refuses before its first
+    // authenticated request. An unbound (legacy) entry keeps today's behavior —
+    // the explicit-target requirement above still applies to it.
+    if (result.credentials.source === "file") {
+        const bound = await readStoredBinding(`bapi:${trimmed}`, storeDeps);
+        if (bound !== null && bound !== url.baseUrl) {
+            return {
+                ok: false,
+                error: `the stored credential for repo '${trimmed}' is approved for a different Bridge API ` +
+                    "endpoint than this executor's base URL; it was not sent. Re-run guided setup " +
+                    "(install conductor) to re-bind it, or correct --base-url.",
+            };
+        }
+    }
     return {
         ok: true,
         apiKey: result.credentials.apiKey,

package/build/executor/http-client.js

@@ -9,6 +9,30 @@
  */
 import { RECONCILER_LIVENESS_VALUES } from "./types.js";
 import { readEpicRunCompletionState, } from "../conductor/bridge-api-client.js";
+/** BAPI-1258 — the server's stable `error_code` for refused capacity evidence. */
+export const UNSUPPORTED_TERMINAL_CAPACITY_ERROR_CODE = "UNSUPPORTED_TERMINAL_CAPACITY";
+/**
+ * Whether a `/fail` response refused the capacity evidence it carried: a 422
+ * (malformed envelope) or a 409 whose `error_code` is the stable unsupported
+ * code. A 409 `STALE_CLAIM` is NOT a refusal — the claim is gone, and resending
+ * cannot help. The body is inspected only for that one closed token.
+ */
+function isCapacityEvidenceRefusal(status, bodyText) {
+    if (status === 422)
+        return true;
+    if (status !== 409)
+        return false;
+    try {
+        const parsed = JSON.parse(bodyText);
+        const detail = parsed && typeof parsed === "object" ? parsed.detail : undefined;
+        return (!!detail &&
+            typeof detail === "object" &&
+            detail.error_code === UNSUPPORTED_TERMINAL_CAPACITY_ERROR_CODE);
+    }
+    catch {
+        return false;
+    }
+}
 /** Bound a server-provided diagnostic snippet included in error strings. */
 function boundedDetail(text) {
     const trimmed = (text ?? "").trim();
@@ -269,7 +293,7 @@ export function createExecutorHttpClient(config) {
             };
             return mutate(`/${job.id}/complete`, body, true, job.repo_name);
         },
-        fail(job, failure) {
+        async fail(job, failure) {
             const body = {
                 repo_name: job.repo_name,
                 claim_token: job.claim_token,
@@ -280,6 +304,26 @@ export function createExecutorHttpClient(config) {
                 last_commit_sha: failure.last_commit_sha,
                 telemetry: failure.telemetry,
             };
+            if (failure.capacity_evidence === undefined) {
+                return mutate(`/${job.id}/fail`, body, false, job.repo_name);
+            }
+            // BAPI-1258 — send the evidence once. If the server refuses it (unsupported
+            // protocol, or a malformed envelope), re-send the SAME ordinary failure
+            // without it, exactly once, so the job still reaches a terminal state and
+            // the original error kind/classification are preserved. Refused evidence
+            // never becomes an automatic recovery.
+            let first;
+            try {
+                first = await post(`/${job.id}/fail`, { ...body, capacity_evidence: failure.capacity_evidence }, job.repo_name);
+            }
+            catch {
+                return { outcome: "fatal_http_error" };
+            }
+            if (!isCapacityEvidenceRefusal(first.status, first.text)) {
+                return mapMutationResponse(first.status, first.text, false);
+            }
+            (config.warn ?? ((message) => console.error(message)))(`executor: server refused terminal capacity evidence for job ${job.id} ` +
+                `(HTTP ${first.status}); reporting an ordinary failure without automatic recovery.`);
             return mutate(`/${job.id}/fail`, body, false, job.repo_name);
         },
         /**