cloving 1.1.0 → 1.3.0

package/dist/src/daemon/github-ci-rerun.js

@@ -0,0 +1,92 @@
+import { field, repositoryPath } from "./github-operation.js";
+import { githubRead } from "./github-retry.js";
+import { operationKey, writeRecord } from "./operation-journal.js";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+function isRerun(value) {
+    return (typeof field(value, "run") === "string" &&
+        /^\d+$/.test(String(field(value, "run"))) &&
+        typeof field(value, "requestedAt") === "number" &&
+        typeof field(value, "output") === "string");
+}
+export async function ciWait(operation, commit) {
+    const text = await readFile(join(operation.folder, `ci-${operationKey(commit)}.json`), "utf8").catch((error) => {
+        if (field(error, "code") === "ENOENT")
+            return undefined;
+        throw error;
+    });
+    if (text === undefined)
+        return { commit, startedAt: Date.now(), reruns: [] };
+    const stored = JSON.parse(text);
+    const startedAt = field(stored, "startedAt");
+    const reruns = field(stored, "reruns");
+    if (field(stored, "commit") !== commit ||
+        typeof startedAt !== "number" ||
+        !Array.isArray(reruns) ||
+        !reruns.every(isRerun))
+        throw new Error("github-call-failed");
+    return { commit, startedAt, reruns };
+}
+export async function workflowAttempt(operation, run) {
+    const value = JSON.parse(await githubRead(operation, [
+        "api",
+        `${repositoryPath}/actions/runs/${run}`,
+    ]));
+    const attempt = field(value, "run_attempt");
+    const status = field(value, "status");
+    if (typeof attempt !== "number" ||
+        !Number.isSafeInteger(attempt) ||
+        attempt < 1 ||
+        typeof status !== "string")
+        throw new Error("github-call-failed");
+    return { attempt, status };
+}
+export async function attemptChecks(operation, workflow) {
+    const pages = JSON.parse(await githubRead(operation, [
+        "api",
+        "--paginate",
+        "--slurp",
+        `${repositoryPath}/actions/runs/${workflow.run}/attempts/${String(workflow.attempt)}/jobs?per_page=100`,
+    ]));
+    if (!Array.isArray(pages) || pages.length === 0)
+        throw new Error("github-call-failed");
+    const ids = new Set();
+    for (const page of pages) {
+        const jobs = field(page, "jobs");
+        if (!Array.isArray(jobs))
+            throw new Error("github-call-failed");
+        for (const job of jobs) {
+            const id = /\/check-runs\/(\d+)$/.exec(String(field(job, "check_run_url")))?.[1];
+            if (id === undefined)
+                throw new Error("github-call-failed");
+            ids.add(Number(id));
+        }
+    }
+    return ids;
+}
+export async function rerunCi(operation, request) {
+    const { wait, rerun } = request;
+    wait.reruns.push(rerun);
+    await writeRecord(operation.folder, {
+        name: `ci-${operationKey(wait.commit)}.json`,
+        value: wait,
+        permissions: "private",
+    });
+    if (Date.now() >= request.deadline)
+        return;
+    try {
+        await operation.calls.gh(["run", "rerun", rerun.run, "--failed"]);
+    }
+    catch (error) {
+        operation.signal.throwIfAborted();
+        throw Object.assign(new Error("github-network-failed", { cause: error }), {
+            detail: field(error, "detail"),
+        });
+    }
+}
+export function attemptOutput(attempts) {
+    const allowance = Math.floor(6_000 / attempts.length) - 40;
+    return attempts
+        .map((output, index) => `Attempt ${String(index + 1)}:\n${output.length <= allowance ? output : output.slice(0, 400) + "\n…\n" + output.slice(-(allowance - 404))}`)
+        .join("\n");
+}

package/dist/src/daemon/github-ci.d.ts

@@ -0,0 +1,6 @@
+import { type Operation } from "./github-operation.ts";
+export interface CiResult {
+    readonly reason: "ci-failed" | "ci-pending";
+    readonly output: string;
+}
+export declare function waitForCi(operation: Operation, commit: string): Promise<CiResult | undefined>;

package/dist/src/daemon/github-ci.js

@@ -0,0 +1,251 @@
+import { settingsEnvironment } from "../cli/project-settings.js";
+import { setTimeout as delay } from "node:timers/promises";
+import { githubText } from "./github-calls.js";
+import { githubRead } from "./github-retry.js";
+import { ciWait, workflowAttempt, attemptChecks, rerunCi, attemptOutput, } from "./github-ci-rerun.js";
+import { field, githubTiming, repositoryPath, } from "./github-operation.js";
+function isCheckRun(value) {
+    const conclusion = field(value, "conclusion");
+    const details = field(value, "details_url");
+    const app = field(value, "app");
+    return (typeof field(value, "id") === "number" &&
+        typeof field(value, "name") === "string" &&
+        typeof field(value, "status") === "string" &&
+        (conclusion === null || typeof conclusion === "string") &&
+        (details === null || typeof details === "string") &&
+        (app === null || typeof field(app, "slug") === "string"));
+}
+const passing = new Set(["success", "neutral", "skipped"]);
+function latestRuns(checks, required) {
+    const latest = new Map();
+    for (const check of checks) {
+        const name = check.name;
+        if (required === undefined
+            ? check.app?.slug !== "github-actions"
+            : !required.has(name))
+            continue;
+        const previous = latest.get(name);
+        if (previous === undefined || check.id > previous.id)
+            latest.set(name, check);
+    }
+    return [...latest.values()];
+}
+function list(value) {
+    return Array.isArray(value) ? value.map((item) => item) : [];
+}
+async function checkRuns(operation, commit) {
+    const pages = JSON.parse(await githubRead(operation, [
+        "api",
+        "--paginate",
+        "--slurp",
+        `${repositoryPath}/commits/${commit}/check-runs?filter=all&per_page=100`,
+    ]));
+    if (!Array.isArray(pages) || pages.length === 0)
+        throw new Error("github-call-failed");
+    return list(pages).flatMap((page) => {
+        const checks = field(page, "check_runs");
+        if (!Array.isArray(checks) || !checks.every(isCheckRun))
+            throw new Error("github-call-failed");
+        return checks;
+    });
+}
+function unavailable(operation, error) {
+    operation.signal.throwIfAborted();
+    const detail = field(error, "detail");
+    return `CI diagnostics unavailable: ${githubText(typeof detail === "string" ? detail : "GitHub logs could not be read", operation.settings)}`;
+}
+async function failedSteps(operation, place) {
+    try {
+        const view = JSON.parse(await operation.calls.gh(["run", "view", place.run, "--json", "jobs"]));
+        return list(field(view, "jobs"))
+            .filter((job) => String(field(job, "databaseId")) === place.job)
+            .flatMap((job) => list(field(job, "steps")))
+            .filter((step) => typeof field(step, "conclusion") === "string" &&
+            !passing.has(String(field(step, "conclusion"))))
+            .map((step) => `Failed step: ${String(field(step, "name"))}`)
+            .join("\n");
+    }
+    catch (error) {
+        return unavailable(operation, error);
+    }
+}
+async function failedCheck(operation, check) {
+    const summary = [
+        `Failed check: ${check.name} (${check.conclusion ?? "null"})`,
+    ];
+    const details = check.details_url ?? "";
+    const run = /\/actions\/runs\/(\d+)/.exec(details)?.[1];
+    let log = "Failed log unavailable.";
+    if (run !== undefined) {
+        const job = /\/job\/(\d+)/.exec(details)?.[1];
+        summary.push(await failedSteps(operation, { run, job }));
+        log = await failedLog(operation, { run, job });
+    }
+    return {
+        summary: githubText(summary.join("\n"), operation.settings),
+        log: githubText(log, operation.settings),
+    };
+}
+async function failedLog(operation, place) {
+    try {
+        return await operation.calls.gh([
+            "run",
+            "view",
+            place.run,
+            "--log-failed",
+            ...(place.job === undefined ? [] : ["--job", place.job]),
+        ]);
+    }
+    catch (error) {
+        operation.signal.throwIfAborted();
+        if (place.job === undefined)
+            return unavailable(operation, error);
+        return operation.calls
+            .gh(["api", `${repositoryPath}/actions/jobs/${place.job}/logs`])
+            .catch((failure) => unavailable(operation, failure));
+    }
+}
+async function failedOutput(operation, checks) {
+    const reports = [];
+    for (const check of checks)
+        reports.push(await failedCheck(operation, check));
+    const summary = reports.map((report) => report.summary).join("\n");
+    const available = Math.max(0, 6_000 - summary.length - reports.length);
+    const allowance = Math.floor(available / reports.length);
+    return [
+        summary,
+        ...reports.map((report) => allowance === 0 ? "" : report.log.slice(-allowance)),
+    ]
+        .join("\n")
+        .slice(0, 6_000);
+}
+function requiredCheckNames(operation) {
+    if (operation.settings.requiredChecks !== undefined)
+        return operation.settings.requiredChecks === null
+            ? undefined
+            : operation.settings.requiredChecks;
+    const setting = settingsEnvironment({ ...process.env, ...operation.settings.environment }, operation.settings.repository)["CLOVING_REQUIRED_CHECKS"];
+    return setting === undefined ? undefined : JSON.parse(setting);
+}
+function requiredChecks(operation) {
+    const names = requiredCheckNames(operation);
+    if (names === undefined)
+        return undefined;
+    if (!Array.isArray(names) ||
+        !names.every((name) => typeof name === "string" && name.trim() !== ""))
+        throw new Error("invalid-payload");
+    return new Set(names);
+}
+function pendingChecks(checks, names) {
+    return [...names].filter((name) => !checks.some((check) => check.name === name && check.status === "completed"));
+}
+function runOf(check) {
+    return check.app?.slug === "github-actions"
+        ? /\/actions\/runs\/(\d+)/.exec(check.details_url ?? "")?.[1]
+        : undefined;
+}
+async function rerunBeforeDeadline(operation, request) {
+    if (Date.now() >= request.deadline)
+        return;
+    const output = await failedOutput(operation, request.checks);
+    const requestedAt = Date.now();
+    if (requestedAt >= request.deadline)
+        return;
+    await rerunCi(operation, {
+        wait: request.wait,
+        rerun: { run: request.run, requestedAt, output },
+        deadline: request.deadline,
+    });
+}
+async function rerunFailedChecks(operation, input) {
+    const { wait, failed } = input;
+    const failures = failed.filter((check) => runOf(check) === undefined);
+    const pending = [];
+    const runs = new Set(failed.flatMap((check) => runOf(check) ?? []));
+    for (const run of runs) {
+        const checks = failed.filter((check) => runOf(check) === run);
+        const recorded = wait.reruns.find((rerun) => rerun.run === run);
+        const workflow = await workflowAttempt(operation, run);
+        if (workflow.attempt === 1 &&
+            recorded === undefined &&
+            workflow.status === "completed")
+            await rerunBeforeDeadline(operation, {
+                wait,
+                run,
+                checks,
+                deadline: input.deadline,
+            });
+        if (workflow.attempt === 1) {
+            pending.push(`workflow ${run} rerun`);
+            continue;
+        }
+        const ids = await attemptChecks(operation, {
+            run,
+            attempt: workflow.attempt,
+        });
+        const current = checks.filter((check) => ids.has(check.id));
+        if (current.length === 0) {
+            pending.push(`workflow ${run} rerun`);
+            continue;
+        }
+        failures.push(...current);
+    }
+    return { failures, pending };
+}
+async function ciFailureOutput(operation, input) {
+    const { wait, failed } = input;
+    const previous = wait.reruns.filter((rerun) => failed.some((check) => runOf(check) === rerun.run));
+    const current = await failedOutput(operation, failed);
+    return previous.length === 0
+        ? current
+        : attemptOutput([
+            previous.map((rerun) => rerun.output).join("\n"),
+            current,
+        ]);
+}
+export async function waitForCi(operation, commit) {
+    const { pollMilliseconds: poll, ciGraceMilliseconds: grace, ciLimitMilliseconds: limit, } = {
+        ...githubTiming,
+        ciGraceMilliseconds: 60_000,
+        ciLimitMilliseconds: 5_400_000,
+        ...operation.settings.timing,
+    };
+    const wait = await ciWait(operation, commit);
+    const started = wait.startedAt;
+    const required = requiredChecks(operation);
+    const names = new Set(required);
+    for (;;) {
+        const checks = latestRuns(await checkRuns(operation, commit), required);
+        for (const check of checks)
+            names.add(check.name);
+        const failed = checks.filter((check) => check.status === "completed" && !passing.has(check.conclusion ?? ""));
+        const retried = await rerunFailedChecks(operation, {
+            wait,
+            failed,
+            deadline: started + limit,
+        });
+        if (retried.failures.length > 0)
+            return {
+                reason: "ci-failed",
+                output: await ciFailureOutput(operation, {
+                    wait,
+                    failed: retried.failures,
+                }),
+            };
+        const pending = [...pendingChecks(checks, names), ...retried.pending];
+        if (pending.length === 0 &&
+            (required !== undefined ||
+                names.size > 0 ||
+                Date.now() - started >= grace))
+            return undefined;
+        const remaining = limit - (Date.now() - started);
+        if (remaining <= 0)
+            return {
+                reason: "ci-pending",
+                output: `CI wait limit reached for ${commit}. Pending checks: ${pending.join(", ") || "waiting for GitHub Actions checks"}`,
+            };
+        await delay(Math.min(poll, remaining), undefined, {
+            signal: operation.signal,
+        });
+    }
+}

package/dist/src/daemon/github-merge-call.d.ts

@@ -0,0 +1,16 @@
+import { type Operation } from "./github-operation.ts";
+export type MergeCheck = "beforeMerge" | null;
+export interface ReviewedPull {
+    readonly number: number;
+    readonly commit: string;
+    readonly check?: MergeCheck | undefined;
+}
+export declare function knownMerge(operation: Operation, expected: ReviewedPull & {
+    readonly updated: string;
+}): Promise<{
+    readonly head: string;
+    readonly merged: string | undefined;
+}>;
+export declare function mergePull(operation: Operation, pull: ReviewedPull & {
+    readonly updated: string;
+}): Promise<string>;

package/dist/src/daemon/github-merge-call.js

@@ -0,0 +1,73 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { field, githubTiming, repositoryPath, } from "./github-operation.js";
+import { githubRead, retryGithub } from "./github-retry.js";
+function commitOf(value, name) {
+    if (typeof value !== "object" || value === null)
+        throw new Error("github-call-failed");
+    const commit = Reflect.get(value, name);
+    if (typeof commit !== "string")
+        throw new Error("github-call-failed");
+    return commit;
+}
+export async function knownMerge(operation, expected) {
+    const pull = JSON.parse(await githubRead(operation, [
+        "api",
+        `${repositoryPath}/pulls/${String(expected.number)}`,
+    ]));
+    const head = commitOf(field(pull, "head"), "sha");
+    if (field(pull, "merged") !== true)
+        return { head, merged: undefined };
+    if (head !== expected.commit && head !== expected.updated)
+        throw new Error("merged-other-commit");
+    return { head, merged: commitOf(pull, "merge_commit_sha") };
+}
+async function mergedNow(operation, pull) {
+    const reply = JSON.parse(await operation.calls.gh([
+        "api",
+        "-X",
+        "PUT",
+        `${repositoryPath}/pulls/${String(pull.number)}/merge`,
+        "-f",
+        "merge_method=merge",
+        "-f",
+        `sha=${pull.commit}`,
+    ]));
+    return commitOf(reply, "sha");
+}
+async function waitForHead(operation, pull) {
+    const timing = operation.settings.timing ?? githubTiming;
+    for (let attempt = 0; attempt < 30; attempt += 1) {
+        if (attempt > 0)
+            await delay(timing.pollMilliseconds, undefined, {
+                signal: operation.signal,
+            });
+        const current = JSON.parse(await githubRead(operation, [
+            "api",
+            `${repositoryPath}/pulls/${String(pull.number)}`,
+        ]));
+        if (commitOf(field(current, "head"), "sha") === pull.commit)
+            return;
+    }
+    throw new Error("head-not-updated");
+}
+export function mergePull(operation, pull) {
+    return retryGithub(operation, {
+        action: async (attempt) => {
+            const known = attempt > 0 ? await knownMerge(operation, pull) : undefined;
+            if (known?.merged !== undefined)
+                return known.merged;
+            const updated = { number: pull.number, commit: pull.updated };
+            if (pull.updated !== pull.commit)
+                await waitForHead(operation, updated);
+            return mergedNow(operation, updated);
+        },
+        statuses: pull.updated === pull.commit ? [] : [405, 409],
+    }).catch(async (error) => {
+        if (!(error instanceof Error) || error.message !== "github-network-failed")
+            throw error;
+        const known = await knownMerge(operation, pull);
+        if (known.merged !== undefined)
+            return known.merged;
+        throw error;
+    });
+}

package/dist/src/daemon/github-merge.d.ts

@@ -1,8 +1,6 @@
 import { type Operation } from "./github-operation.ts";
-interface ReviewedPull {
-    readonly number: number;
-    readonly commit: string;
-}
+import { type CiResult } from "./github-ci.ts";
+import { type ReviewedPull } from "./github-merge-call.ts";
 interface SuccessfulMerge {
     readonly number: number;
     readonly commit: string;
@@ -13,6 +11,6 @@ interface MergeRepair {
     readonly reason: "check-failed" | "merge-conflict";
     readonly output: string;
 }
-export type MergeResult = SuccessfulMerge | MergeRepair;
+export type MergeResult = SuccessfulMerge | MergeRepair | CiResult;
 export declare function merge(operation: Operation, pull: ReviewedPull): Promise<MergeResult>;
 export {};