@bridge_gpt/mcp-server 0.2.69 → 0.2.70

package/build/ticket-delivery.js

@@ -0,0 +1,205 @@
+/**
+ * BAPI-1426 — the thin client for the server's ticket delivery authority.
+ *
+ * The Bridge API decides whether a managed ticket is ready to publish, merge, or
+ * complete. This module only carries requests to `/ticket-delivery/...` and hands
+ * the server's answer back. It holds no readiness policy: it never counts ledger
+ * records, never decides an outcome, and never turns a failed call into a green
+ * result.
+ *
+ * Every function returns a result object instead of throwing on an HTTP or
+ * network failure, so a caller can keep local work and retry later. Messages are
+ * sanitized and never carry the API key or any request header.
+ */
+import { redactSecrets } from "./secret-redaction.js";
+export const READINESS_BOUNDARIES = ["publish", "merge", "complete"];
+const STATUS_CODES = {
+    400: "BAD_REQUEST",
+    401: "UNAUTHORIZED",
+    403: "FORBIDDEN",
+    404: "NOT_FOUND",
+    409: "CONFLICT",
+    422: "VALIDATION_ERROR",
+    429: "RATE_LIMITED",
+    500: "INTERNAL_ERROR",
+    502: "BAD_GATEWAY",
+    503: "SERVICE_UNAVAILABLE",
+    504: "GATEWAY_TIMEOUT",
+};
+const MAX_MESSAGE_LENGTH = 500;
+/** Strip credentials and bound the length of any text that leaves this module. */
+export function sanitizeDeliveryMessage(raw, apiKey) {
+    let text = typeof raw === "string" ? raw : raw instanceof Error ? raw.message : String(raw);
+    if (apiKey && apiKey.length >= 4)
+        text = text.split(apiKey).join("[REDACTED]");
+    text = redactSecrets(text);
+    return text.length > MAX_MESSAGE_LENGTH ? `${text.slice(0, MAX_MESSAGE_LENGTH)}…` : text;
+}
+function deliveryUrl(baseUrl, path, query) {
+    const url = new URL(`${baseUrl.replace(/\/+$/, "")}/ticket-delivery${path}`);
+    for (const [key, value] of Object.entries(query ?? {}))
+        url.searchParams.set(key, value);
+    return url.toString();
+}
+async function request(deps, method, path, options = {}) {
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    let headers = {};
+    try {
+        headers = await deps.headers();
+    }
+    catch (err) {
+        return {
+            ok: false,
+            status: 0,
+            error: "CREDENTIALS_UNAVAILABLE",
+            message: sanitizeDeliveryMessage(err),
+        };
+    }
+    const apiKey = headers["X-API-Key"];
+    let resp;
+    try {
+        resp = await fetchImpl(deliveryUrl(deps.baseUrl, path, options.query), {
+            method,
+            headers: options.body === undefined ? headers : { ...headers, "Content-Type": "application/json" },
+            ...(options.body === undefined ? {} : { body: JSON.stringify(options.body) }),
+        });
+    }
+    catch (err) {
+        return {
+            ok: false,
+            status: 0,
+            error: "NETWORK_ERROR",
+            message: sanitizeDeliveryMessage(err, apiKey),
+        };
+    }
+    let raw = "";
+    try {
+        raw = await resp.text();
+    }
+    catch (err) {
+        return {
+            ok: false,
+            status: resp.status,
+            error: "INVALID_RESPONSE",
+            message: sanitizeDeliveryMessage(err, apiKey),
+        };
+    }
+    if (resp.ok) {
+        try {
+            const body = JSON.parse(raw);
+            if (body === null || typeof body !== "object" || Array.isArray(body)) {
+                throw new Error("response body is not a JSON object");
+            }
+            return { ok: true, status: resp.status, body: body };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                status: resp.status,
+                error: "INVALID_RESPONSE",
+                message: sanitizeDeliveryMessage(err, apiKey),
+            };
+        }
+    }
+    let error = STATUS_CODES[resp.status] ?? "UNKNOWN_ERROR";
+    let message = raw ? raw : `HTTP ${resp.status}`;
+    let detail;
+    try {
+        const parsed = JSON.parse(raw);
+        detail = parsed?.detail;
+        if (detail !== null && typeof detail === "object" && !Array.isArray(detail)) {
+            const d = detail;
+            if (typeof d.error === "string")
+                error = d.error;
+            message = typeof d.message === "string" ? d.message : JSON.stringify(d);
+        }
+        else if (typeof detail === "string") {
+            message = detail;
+        }
+        else if (detail !== undefined) {
+            message = JSON.stringify(detail);
+        }
+    }
+    catch {
+        // Not JSON: keep the raw text as the message.
+    }
+    return {
+        ok: false,
+        status: resp.status,
+        error,
+        message: sanitizeDeliveryMessage(message, apiKey),
+        ...(detail !== undefined ? { detail: JSON.parse(sanitizeDeliveryDetail(detail, apiKey)) } : {}),
+    };
+}
+function sanitizeDeliveryDetail(detail, apiKey) {
+    let text = JSON.stringify(detail);
+    if (apiKey && apiKey.length >= 4)
+        text = text.split(apiKey).join("[REDACTED]");
+    return redactSecrets(text);
+}
+// ---------------------------------------------------------------------------
+// Operations
+// ---------------------------------------------------------------------------
+/** Bind a managed execution. Replaying the same registration key resumes it. */
+export function registerExecution(deps, body) {
+    return request(deps, "POST", "/executions", { body });
+}
+/** Find the active attempt for a ticket and branch. A 404 means there is none. */
+export function recoverExecution(deps, query) {
+    return request(deps, "GET", "/executions/recover", { query });
+}
+const RUN_RECOVERY_CODES = {
+    TICKET_DELIVERY_RUN_UNMANAGED: "unmanaged",
+    TICKET_DELIVERY_RUN_NO_RECOVERABLE_EXECUTION: "no_recoverable_execution",
+    TICKET_DELIVERY_RUN_AMBIGUOUS: "ambiguous",
+    TICKET_DELIVERY_RUN_LOOKUP_FAILED: "lookup_failed",
+};
+const RUN_RECOVERY_MESSAGES = {
+    unmanaged: "The server confirmed no managed execution exists for this run and ticket.",
+    no_recoverable_execution: "The ticket belongs to the run but has no active or completed execution to read.",
+    ambiguous: "More than one active execution exists for this run and ticket.",
+    lookup_failed: "The run-scoped lookup failed. This is not proof the ticket is unmanaged.",
+};
+/**
+ * Find a run child's execution by run id and ticket, with no branch. Only an
+ * allowlisted server code maps to `unmanaged`, `no_recoverable_execution` or
+ * `ambiguous`. Every other failure, including a bare 404 from an older server,
+ * a 5xx, an unreadable body and a transport error, is `lookup_failed`.
+ */
+export async function recoverExecutionForRun(deps, query) {
+    const result = await request(deps, "GET", "/executions/recover", {
+        query,
+    });
+    if (result.ok)
+        return { ok: true, body: result.body };
+    const detail = result.detail;
+    const code = typeof detail?.error === "string" ? detail.error : undefined;
+    const mapped = code !== undefined ? RUN_RECOVERY_CODES[code] : undefined;
+    const outcome = mapped ?? "lookup_failed";
+    return { ok: false, outcome, status: result.status, message: RUN_RECOVERY_MESSAGES[outcome] };
+}
+/** Whether a branch is held by a managed ticket. Grants no submission authority. */
+export function getBranchHold(deps, query) {
+    return request(deps, "GET", "/holds", { query });
+}
+/** Upload one durable evidence batch. `retryable: true` means nothing was stored. */
+export function submitEvidence(deps, attemptId, body) {
+    return request(deps, "POST", `/executions/${encodeURIComponent(attemptId)}/evidence`, { body });
+}
+/** The server-accepted ledger, which is the only source of post-PR ownership. */
+export function getAcceptedLedger(deps, attemptId, query) {
+    return request(deps, "GET", `/executions/${encodeURIComponent(attemptId)}/ledger`, { query });
+}
+/** The server's readiness decision at one boundary. */
+export function getReadiness(deps, attemptId, query) {
+    const params = { repo_name: query.repo_name };
+    if (query.boundary)
+        params.boundary = query.boundary;
+    return request(deps, "GET", `/executions/${encodeURIComponent(attemptId)}/readiness`, {
+        query: params,
+    });
+}
+/** Ask the server to confirm delivery after merge. Only it can say `delivery_complete`. */
+export function completeDelivery(deps, attemptId, body) {
+    return request(deps, "POST", `/executions/${encodeURIComponent(attemptId)}/complete`, { body });
+}

package/build/ticket-review-summary.js

@@ -0,0 +1,14 @@
+export function ticketReviewSummary(projection, proposed) {
+    if (projection?.enabled === true && projection.provenance === 'enabled')
+        return 'on';
+    if (projection?.enabled === false && projection.provenance === 'recorded' &&
+        typeof projection.actor === 'string' && /^actor_[a-z0-9]{4,32}$/.test(projection.actor) &&
+        typeof projection.recorded_at === 'string' && /^\d{4}-\d{2}-\d{2}T.+(?:Z|\+00:00)$/.test(projection.recorded_at) && Number.isFinite(Date.parse(projection.recorded_at))) {
+        return `off (set by ${projection.actor} on ${projection.recorded_at.slice(0, 10)})`;
+    }
+    if (projection?.enabled === false)
+        return 'off (legacy choice not recorded)';
+    if (proposed?.spec_review_gate === false)
+        return 'off requested (admin key required; choice recorded at create)';
+    return 'on';
+}

package/build/upgrade-cli.js

@@ -783,6 +783,19 @@ export async function runUpgradeCli(argv, injected) {
             stdout(line);
     }
     stdout("Refreshed scaffolded artifacts (commands, agents, pipelines).");
+    // BAPI-1470: `runInit` already printed the notice and any probe warnings in
+    // full. Summarize with counts only. A caller that omits the optional fields has
+    // told us nothing, so absent fields print nothing rather than "none found".
+    const legacyCopyCount = initResult.legacyProcedureCopies?.length ?? 0;
+    const legacyWarningCount = initResult.legacyProcedureProbeWarnings?.length ?? 0;
+    if (legacyCopyCount > 0 || legacyWarningCount > 0) {
+        const parts = [];
+        if (legacyCopyCount > 0)
+            parts.push(`${legacyCopyCount} old fallback ${legacyCopyCount === 1 ? "copy" : "copies"} found`);
+        if (legacyWarningCount > 0)
+            parts.push(`${legacyWarningCount} old ${legacyWarningCount === 1 ? "path" : "paths"} could not be checked`);
+        stdout(`Old procedure copies: ${parts.join(", ")} (details above).`);
+    }
     if (verificationFailures.length > 0) {
         stderr("\nBridge API upgrade did NOT converge:");
         for (const failure of verificationFailures)