@bridge_gpt/mcp-server 0.2.68 → 0.2.70

package/build/conductor/launch-need-probes.js

@@ -0,0 +1,337 @@
+/**
+ * BAPI-1506 — read-only launch-need probes for the `drive-epic` create preview.
+ *
+ * Two probes live here: whether every self-hosted label set behind the
+ * repository's required checks has an online runner, and how far the epic
+ * branch is behind its base. Both are bookkeeping reads (design principle 5):
+ * every subprocess has a bounded timeout, and every failure, timeout, missing
+ * tool, or unreadable output becomes `unverifiable`. Nothing here can refuse a
+ * launch, and nothing from a subprocess, a workflow file, or a path reaches the
+ * returned facts — only closed classifications and bounded counts.
+ */
+import path from "node:path";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { validateBranchName } from "../base-ref.js";
+import { PLANE_FRESHNESS_TIMEOUT_MS } from "../plane/plane-freshness.js";
+/** One deadline for the whole runner probe, however many pages it reads. */
+export const LAUNCH_RUNNER_PROBE_DEADLINE_MS = PLANE_FRESHNESS_TIMEOUT_MS;
+/** Bound on each git read the behind-base probe runs. */
+export const LAUNCH_BRANCH_PROBE_TIMEOUT_MS = PLANE_FRESHNESS_TIMEOUT_MS;
+const RUNNER_PAGE_SIZE = 100;
+const RUNNER_MAX_PAGES = 10;
+const WORKFLOW_MAX_FILES = 200;
+const WORKFLOW_MAX_BYTES = 512 * 1024;
+export function createWorkflowSource() {
+    return {
+        list: (dir) => readdir(dir),
+        read: async (file) => {
+            const entry = await stat(file);
+            if (!entry.isFile() || entry.size > WORKFLOW_MAX_BYTES)
+                throw new Error("workflow unreadable");
+            return readFile(file, "utf8");
+        },
+    };
+}
+function stripComment(value) {
+    // A `#` starts a comment only at the start or after whitespace, outside quotes.
+    let quote = null;
+    for (let i = 0; i < value.length; i += 1) {
+        const ch = value[i];
+        if (quote !== null) {
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === "'" || ch === '"')
+            quote = ch;
+        else if (ch === "#" && (i === 0 || /\s/.test(value[i - 1] ?? "")))
+            return value.slice(0, i);
+    }
+    return value;
+}
+function unquote(value) {
+    const v = value.trim();
+    if (v.length >= 2 && ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'")))) {
+        return v.slice(1, -1);
+    }
+    if (/^["']/.test(v) || /["']$/.test(v))
+        return null;
+    return v;
+}
+function plainScalar(raw) {
+    const value = stripComment(raw).trim();
+    if (value === "" || value.includes("${{") || /^[|>&*!{[]/.test(value))
+        return null;
+    const text = unquote(value);
+    return text === null || text === "" ? null : text;
+}
+function runsOnLabels(raw) {
+    const value = stripComment(raw).trim();
+    if (value === "" || value.includes("${{"))
+        return null;
+    if (value.startsWith("[")) {
+        if (!value.endsWith("]"))
+            return null;
+        const inner = value.slice(1, -1).trim();
+        if (inner === "")
+            return null;
+        const labels = [];
+        for (const part of inner.split(",")) {
+            const label = unquote(part);
+            if (label === null || label === "" || /[[\]{}:]/.test(label))
+                return null;
+            labels.push(label);
+        }
+        return labels;
+    }
+    const label = plainScalar(value);
+    return label === null ? null : [label];
+}
+/**
+ * Read the jobs out of one workflow file. A deliberately small reader: it
+ * understands only the top-level `jobs:` mapping and, inside each job, the
+ * `name:` and `runs-on:` keys at the job's own indent. Anything it cannot read
+ * plainly is reported as unreadable rather than guessed.
+ */
+export function parseWorkflowJobs(text) {
+    const lines = text.split(/\r?\n/);
+    const jobs = [];
+    let inJobs = false;
+    let jobIndent = null;
+    let current = null;
+    const flush = () => {
+        if (current !== null) {
+            jobs.push({ id: current.id, name: current.name, nameUnreadable: current.nameUnreadable, runsOn: current.runsOn });
+        }
+        current = null;
+    };
+    for (const line of lines) {
+        if (line.trim() === "" || line.trimStart().startsWith("#"))
+            continue;
+        const indent = line.length - line.trimStart().length;
+        if (indent === 0) {
+            flush();
+            inJobs = /^jobs:\s*(#.*)?$/.test(line);
+            jobIndent = null;
+            continue;
+        }
+        if (!inJobs)
+            continue;
+        if (jobIndent === null)
+            jobIndent = indent;
+        if (indent < jobIndent)
+            continue;
+        if (indent === jobIndent) {
+            flush();
+            const match = /^\s*(["']?)([A-Za-z_][A-Za-z0-9_-]*)\1:\s*(#.*)?$/.exec(line);
+            if (match !== null) {
+                current = { id: match[2], name: null, nameUnreadable: false, runsOn: null, propIndent: null };
+            }
+            continue;
+        }
+        if (current === null)
+            continue;
+        const job = current;
+        if (job.propIndent === null)
+            job.propIndent = indent;
+        if (indent !== job.propIndent)
+            continue;
+        const key = /^\s*([A-Za-z_-]+):(.*)$/.exec(line);
+        if (key === null)
+            continue;
+        if (key[1] === "name") {
+            const name = plainScalar(key[2] ?? "");
+            if (name === null)
+                job.nameUnreadable = true;
+            else
+                job.name = name;
+        }
+        else if (key[1] === "runs-on") {
+            job.runsOn = runsOnLabels(key[2] ?? "");
+        }
+    }
+    flush();
+    return jobs;
+}
+function parseRunnerPage(stdout) {
+    let body;
+    try {
+        body = JSON.parse(stdout);
+    }
+    catch {
+        return null;
+    }
+    if (body === null || typeof body !== "object" || Array.isArray(body))
+        return null;
+    const { total_count: total, runners } = body;
+    if (typeof total !== "number" || !Number.isSafeInteger(total) || total < 0 || !Array.isArray(runners))
+        return null;
+    const out = [];
+    for (const runner of runners) {
+        if (runner === null || typeof runner !== "object")
+            return null;
+        const { status, labels } = runner;
+        if (typeof status !== "string" || !Array.isArray(labels))
+            return null;
+        const names = new Set();
+        for (const label of labels) {
+            const name = label?.name;
+            if (typeof name !== "string" || name === "")
+                return null;
+            names.add(name.toLowerCase());
+        }
+        out.push({ online: status === "online", labels: names });
+    }
+    return { total, runners: out };
+}
+const PROVIDER_REPOSITORY = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})\/[A-Za-z0-9._-]{1,100}$/;
+/**
+ * Whether every self-hosted label set behind the required checks has an
+ * online runner. Reads only the jobs behind `gate_profile.provider_checks`.
+ * NEVER throws.
+ */
+export async function inspectRequiredSelfHostedRunners(input) {
+    try {
+        return await probeRunners(input);
+    }
+    catch {
+        return { state: "unverifiable", reason: "probe_failed" };
+    }
+}
+async function probeRunners(input) {
+    const now = input.now ?? Date.now;
+    const deadline = now() + LAUNCH_RUNNER_PROBE_DEADLINE_MS;
+    const profile = input.gateProfile;
+    if (profile === null || profile === undefined || profile.read_failed || !Array.isArray(profile.provider_checks)) {
+        return { state: "unverifiable", reason: "no_gate_profile" };
+    }
+    const required = profile.provider_checks
+        .map((check) => check.name)
+        .filter((name) => typeof name === "string" && name !== "");
+    if (required.length !== profile.provider_checks.length) {
+        return { state: "unverifiable", reason: "no_gate_profile" };
+    }
+    if (required.length === 0)
+        return { state: "not_applicable" };
+    // Every workflow job, from both `.yml` and `.yaml` files.
+    const dir = path.join(input.repoRoot, ".github", "workflows");
+    let files;
+    try {
+        files = (await input.workflows.list(dir)).filter((file) => /\.ya?ml$/.test(file)).sort();
+    }
+    catch {
+        return { state: "unverifiable", reason: "workflows_unreadable" };
+    }
+    if (files.length > WORKFLOW_MAX_FILES)
+        return { state: "unverifiable", reason: "workflows_unreadable" };
+    const jobs = [];
+    for (const file of files) {
+        try {
+            jobs.push(...parseWorkflowJobs(await input.workflows.read(path.join(dir, file))));
+        }
+        catch {
+            return { state: "unverifiable", reason: "workflows_unreadable" };
+        }
+    }
+    // Map each required check to exactly one job: its literal name, else its id.
+    const labelSets = new Map();
+    for (const check of new Set(required)) {
+        const matches = jobs.filter((job) => (job.name ?? (job.nameUnreadable ? null : job.id)) === check);
+        if (matches.length !== 1) {
+            return { state: "unverifiable", reason: "check_not_mapped" };
+        }
+        const runsOn = matches[0]?.runsOn ?? null;
+        if (runsOn === null)
+            return { state: "unverifiable", reason: "runs_on_unreadable" };
+        const lowered = runsOn.map((label) => label.toLowerCase());
+        if (!lowered.includes("self-hosted"))
+            continue;
+        const key = [...new Set(lowered)].sort().join("\u0000");
+        labelSets.set(key, [...new Set(lowered)]);
+    }
+    if (labelSets.size === 0)
+        return { state: "not_applicable" };
+    const repository = input.providerRepository;
+    if (typeof repository !== "string" || !PROVIDER_REPOSITORY.test(repository)) {
+        return { state: "unverifiable", reason: "no_provider_repository" };
+    }
+    // A complete runner listing, page by page, inside the one deadline.
+    const runners = [];
+    let total = null;
+    for (let page = 1; page <= RUNNER_MAX_PAGES; page += 1) {
+        const remaining = deadline - now();
+        if (remaining <= 0)
+            return { state: "unverifiable", reason: "runner_list_unavailable" };
+        const result = await input.execFile("gh", ["api", `repos/${repository}/actions/runners?per_page=${RUNNER_PAGE_SIZE}&page=${page}`], { cwd: input.repoRoot, timeoutMs: remaining, env: { GH_PROMPT_DISABLED: "1" } });
+        if (!result.ok)
+            return { state: "unverifiable", reason: "runner_list_unavailable" };
+        const parsed = parseRunnerPage(result.stdout);
+        if (parsed === null)
+            return { state: "unverifiable", reason: "runner_list_malformed" };
+        if (total === null)
+            total = parsed.total;
+        else if (total !== parsed.total)
+            return { state: "unverifiable", reason: "runner_list_malformed" };
+        runners.push(...parsed.runners);
+        if (runners.length >= total)
+            break;
+        if (parsed.runners.length === 0)
+            return { state: "unverifiable", reason: "runner_list_malformed" };
+    }
+    if (total === null || runners.length !== total)
+        return { state: "unverifiable", reason: "runner_list_malformed" };
+    let unsatisfied = 0;
+    for (const labels of labelSets.values()) {
+        const served = runners.some((runner) => runner.online && labels.every((label) => runner.labels.has(label)));
+        if (!served)
+            unsatisfied += 1;
+    }
+    return unsatisfied > 0
+        ? { state: "present", unsatisfied_label_sets: unsatisfied, label_sets: labelSets.size }
+        : { state: "absent", label_sets: labelSets.size };
+}
+/**
+ * How many commits `origin/<branch>` is behind `origin/<base>`. Information
+ * only: integration's `sync_base` merges the base into the epic branch. Uses
+ * the remote-tracking refs the preview already has; it fetches nothing.
+ * NEVER throws.
+ */
+export async function inspectEpicBranchBehindBase(input) {
+    try {
+        const { branch, baseBranch } = input;
+        if (branch === null || branch === "")
+            return { state: "not_applicable", reason: "no_epic_branch" };
+        if (baseBranch === null || baseBranch === "")
+            return { state: "unverifiable", reason: "no_base_branch" };
+        if (validateBranchName(branch) !== null || validateBranchName(baseBranch) !== null) {
+            return { state: "unverifiable", reason: "invalid_branch_name" };
+        }
+        if (branch === baseBranch)
+            return { state: "not_applicable", reason: "no_epic_branch" };
+        const git = (args) => input.execFile("git", args, {
+            cwd: input.repoRoot,
+            timeoutMs: LAUNCH_BRANCH_PROBE_TIMEOUT_MS,
+            env: { GIT_TERMINAL_PROMPT: "0" },
+        });
+        // `for-each-ref` exits 0 with no output for a ref that does not exist, so a
+        // missing branch is told apart from a git failure.
+        const ref = `refs/remotes/origin/${branch}`;
+        const listed = await git(["for-each-ref", "--format=%(refname)", ref]);
+        if (!listed.ok)
+            return { state: "unverifiable", reason: "git_failed" };
+        if (!listed.stdout.split(/\r?\n/).some((line) => line.trim() === ref)) {
+            return { state: "not_applicable", reason: "branch_not_on_origin" };
+        }
+        const counted = await git(["rev-list", "--count", `refs/remotes/origin/${branch}..refs/remotes/origin/${baseBranch}`]);
+        if (!counted.ok)
+            return { state: "unverifiable", reason: "git_failed" };
+        const text = counted.stdout.trim();
+        if (!/^\d{1,9}$/.test(text))
+            return { state: "unverifiable", reason: "git_failed" };
+        const behind = Number.parseInt(text, 10);
+        return behind === 0 ? { state: "absent" } : { state: "present", behind };
+    }
+    catch {
+        return { state: "unverifiable", reason: "git_failed" };
+    }
+}