cloving 0.3.20 → 1.1.0

package/dist/src/daemon/github-ticket-status.js

@@ -0,0 +1,268 @@
+import { issuePrivacy } from "./github-issue-privacy.js";
+import { field, text } from "./github-operation.js";
+import { ticketLimits } from "./ticket-source.js";
+const privateRemaining = "Remaining work is in the private run report.";
+const issueBodyBytes = ticketLimits.textBytes - 2_048;
+const workflowLabels = [
+    "cloving: ready",
+    "cloving: blocked",
+    "cloving: in progress",
+];
+function positiveInteger(operation, name) {
+    const value = operation.payload[name];
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1)
+        throw new Error("invalid-payload");
+    return value;
+}
+function issuePath(operation) {
+    const repository = `${text(operation, "owner")}/${text(operation, "repository")}`;
+    if (!/^[\w.-]+\/[\w.-]+$/.test(repository))
+        throw new Error("invalid-payload");
+    return `repos/${repository}/issues/${String(positiveInteger(operation, "number"))}`;
+}
+function labelsOf(issue) {
+    const labels = field(issue, "labels");
+    if (!Array.isArray(labels))
+        throw new Error("github-call-failed");
+    return labels.map((item) => {
+        const name = typeof item === "string" ? item : field(item, "name");
+        if (typeof name !== "string")
+            throw new Error("github-call-failed");
+        return name;
+    });
+}
+async function readIssue(operation, path) {
+    const issue = JSON.parse(await operation.calls.gh(["api", path]));
+    const body = field(issue, "body");
+    if ((body !== null && typeof body !== "string") ||
+        field(issue, "number") !== positiveInteger(operation, "number") ||
+        !["open", "closed"].includes(String(field(issue, "state"))) ||
+        field(issue, "pull_request") !== undefined)
+        throw new Error("github-call-failed");
+    return {
+        state: field(issue, "state"),
+        reason: field(issue, "state_reason"),
+        body: typeof body === "string" ? body : "",
+        labels: labelsOf(issue),
+    };
+}
+function isPositiveInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function isRemaining(value) {
+    return (Array.isArray(value) &&
+        value.length > 0 &&
+        value.every((item) => typeof item === "string" && item.trim() !== "" && !/[\r\n]/.test(item)));
+}
+function isPartialRun(value) {
+    return (isPositiveInteger(field(value, "pullRequest")) &&
+        isRemaining(field(value, "remaining")));
+}
+function historyOf(json) {
+    try {
+        const value = JSON.parse(json);
+        const partialRuns = field(value, "partialRuns");
+        const completedPullRequest = field(value, "completedPullRequest");
+        if (field(value, "version") !== 1 ||
+            !Array.isArray(partialRuns) ||
+            !partialRuns.every(isPartialRun) ||
+            new Set(partialRuns.map((run) => run.pullRequest)).size !==
+                partialRuns.length ||
+            (completedPullRequest !== undefined &&
+                !isPositiveInteger(completedPullRequest)))
+            return undefined;
+        return {
+            version: 1,
+            partialRuns,
+            ...(completedPullRequest === undefined ? {} : { completedPullRequest }),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function statusText(history) {
+    const lines = history.partialRuns.map((run) => `- Pull request #${String(run.pullRequest)}: partial. Remaining: ${run.remaining.join("; ")}`);
+    if (history.completedPullRequest !== undefined)
+        lines.push(`Completed in pull request #${String(history.completedPullRequest)}.`);
+    return `## Cloving status\n${lines.join("\n")}\n\n`;
+}
+function statusSection(body) {
+    const empty = { version: 1, partialRuns: [] };
+    const marker = /^<!-- cloving-status(?=\s|-->|$)/gm;
+    const start = [...body.matchAll(marker)].at(-1)?.index;
+    if (start === undefined)
+        return { outside: body, history: empty };
+    const tail = body.slice(start);
+    const end = tail.indexOf("-->");
+    if (end !== -1 && tail.slice(end + 3).trim() !== "")
+        return { outside: body, history: empty };
+    const outside = body.slice(0, start);
+    if (end === -1)
+        return { outside, history: empty };
+    const history = historyOf(tail.slice("<!-- cloving-status".length, end).trim());
+    if (history === undefined)
+        return { outside, history: empty };
+    const section = statusText(history);
+    return {
+        outside: outside.endsWith(section)
+            ? outside.slice(0, -section.length)
+            : outside,
+        history,
+    };
+}
+function withStatus(outside, history) {
+    const separator = "\n".repeat(Math.max(0, 2 - (outside.match(/\n*$/)?.[0].length ?? 0)));
+    const json = JSON.stringify(history)
+        .replace(/--/g, "\\u002d\\u002d")
+        .replace(/>/g, "\\u003e");
+    return `${outside}${outside === "" ? "" : separator}${statusText(history)}<!-- cloving-status\n${json}\n-->\n`;
+}
+async function writeIssue(operation, update) {
+    const { path, body, labels } = update;
+    const latest = await readIssue(operation, path);
+    if (latest.body !== update.originalBody)
+        throw new Error("github-issue-conflict");
+    const fields = update.fields ?? [];
+    if (body !== latest.body || fields.length > 0)
+        await operation.calls.gh([
+            "api",
+            "-X",
+            "PATCH",
+            path,
+            "-f",
+            `body=${body}`,
+            ...fields,
+        ]);
+    const add = workflowLabels.filter((name) => labels.includes(name) && !latest.labels.includes(name));
+    const remove = workflowLabels.filter((name) => !labels.includes(name) && latest.labels.includes(name));
+    if (add.length === 0 && remove.length === 0)
+        return;
+    await operation.calls.gh([
+        "issue",
+        "edit",
+        String(positiveInteger(operation, "number")),
+        "--repo",
+        `${text(operation, "owner")}/${text(operation, "repository")}`,
+        ...add.flatMap((name) => ["--add-label", name]),
+        ...remove.flatMap((name) => ["--remove-label", name]),
+    ]);
+}
+function sameLabels(first, second) {
+    return JSON.stringify(first.toSorted()) === JSON.stringify(second.toSorted());
+}
+export async function closeIssue(operation) {
+    const path = issuePath(operation);
+    const pull = positiveInteger(operation, "pullRequest");
+    const issue = await readIssue(operation, path);
+    const section = statusSection(issue.body);
+    const body = withStatus(section.outside, {
+        ...section.history,
+        completedPullRequest: pull,
+    });
+    const labels = issue.labels.filter((name) => !["cloving: ready", "cloving: blocked", "cloving: in progress"].includes(name));
+    if (body === issue.body &&
+        sameLabels(issue.labels, labels) &&
+        issue.state === "closed" &&
+        issue.reason === "completed")
+        return {
+            number: positiveInteger(operation, "number"),
+            ticketStatus: "complete",
+        };
+    await writeIssue(operation, {
+        path,
+        originalBody: issue.body,
+        body,
+        labels,
+        fields: issue.state === "closed" && issue.reason === "completed"
+            ? []
+            : ["-f", "state=closed", "-f", "state_reason=completed"],
+    });
+    return {
+        number: positiveInteger(operation, "number"),
+        ticketStatus: "complete",
+    };
+}
+function remainingItems(operation) {
+    const items = operation.payload["remaining"];
+    if (!Array.isArray(items) ||
+        items.length === 0 ||
+        items.some((item) => typeof item !== "string" || item.trim() === "" || /[\r\n]/.test(item)))
+        throw new Error("invalid-payload");
+    return items.map(String);
+}
+function publicRemaining(operation) {
+    const remaining = remainingItems(operation);
+    try {
+        issuePrivacy(remaining.join("; "), {
+            settings: operation.settings,
+            repository: `${text(operation, "owner")}/${text(operation, "repository")}`,
+        });
+        return remaining;
+    }
+    catch {
+        return [privateRemaining];
+    }
+}
+function partialHistory(section, status) {
+    const recorded = section.history.partialRuns.some((run) => run.pullRequest === status.pull);
+    for (const remaining of [status.remaining, [privateRemaining]]) {
+        const history = {
+            ...section.history,
+            partialRuns: recorded
+                ? section.history.partialRuns
+                : [
+                    ...section.history.partialRuns,
+                    { pullRequest: status.pull, remaining },
+                ],
+        };
+        if (Buffer.byteLength(withStatus(section.outside, history)) <= issueBodyBytes)
+            return history;
+    }
+    throw new Error("github-issue-too-large");
+}
+export async function partialIssue(operation) {
+    const path = issuePath(operation);
+    const pull = positiveInteger(operation, "pullRequest");
+    const remaining = publicRemaining(operation);
+    const issue = await readIssue(operation, path);
+    const section = statusSection(issue.body);
+    const history = partialHistory(section, { pull, remaining });
+    const count = history.partialRuns.length;
+    const label = count >= 3 ? "cloving: blocked" : "cloving: ready";
+    const body = withStatus(section.outside, history);
+    const labels = [
+        ...issue.labels.filter((name) => ![
+            "cloving: ready",
+            "cloving: blocked",
+            "cloving: in progress",
+        ].includes(name)),
+        label,
+    ];
+    if (body === issue.body && sameLabels(issue.labels, labels))
+        return {
+            number: positiveInteger(operation, "number"),
+            ticketStatus: "partial",
+        };
+    const repository = `${text(operation, "owner")}/${text(operation, "repository")}`;
+    await operation.calls.gh([
+        "label",
+        "create",
+        label,
+        "--repo",
+        repository,
+        "--color",
+        "ededed",
+        "--force",
+    ]);
+    await writeIssue(operation, {
+        path,
+        originalBody: issue.body,
+        body,
+        labels,
+    });
+    return {
+        number: positiveInteger(operation, "number"),
+        ticketStatus: "partial",
+    };
+}

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

@@ -0,0 +1,17 @@
+import type { Delivery } from "../broker/actor/delivery-intents.ts";
+import { type MethodSettings } from "./github-methods.ts";
+import { type WorkerReport } from "./operation-journal.ts";
+export type { GithubTiming } from "./github-methods.ts";
+export interface GithubWorkerSettings extends MethodSettings {
+    readonly journal: string;
+    readonly document: (digest: string) => Promise<string | undefined>;
+    readonly report: (report: WorkerReport) => Promise<unknown>;
+    readonly operationStatus: (operationId: string) => Promise<string | undefined>;
+    readonly runStatus: (runId: string) => Promise<string | undefined>;
+}
+export interface GithubWorker extends Delivery {
+    readonly stop: NonNullable<Delivery["stop"]>;
+    readonly scan: () => Promise<void>;
+    readonly close: () => Promise<void>;
+}
+export declare function githubWorker(settings: GithubWorkerSettings): GithubWorker;

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

@@ -0,0 +1,281 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { calls } from "./github-calls.js";
+import { methodReasons, methods, } from "./github-methods.js";
+import { interrupted, located, readRecord, replied, reportOf, writeRecord, } from "./operation-journal.js";
+const worker = "github";
+const closing = "github-worker-closed";
+const endedRuns = new Set([
+    "cancelled",
+    "failed",
+    "completed",
+]);
+const unsettledOperations = new Set([
+    "dispatch-pending",
+    "running",
+    "recovering",
+    "blocked",
+]);
+const outcomes = ["completed", "failed", "stopped"];
+function placed(parts, intent) {
+    return located(parts.settings.journal, intent.operationId);
+}
+async function reconciled(parts, intent) {
+    const { key, folder } = placed(parts, intent);
+    const identity = { receipt: key, worker };
+    const result = await readRecord(folder, "result.json");
+    if (result !== undefined)
+        return replied(identity, result);
+    if (parts.active.has(key))
+        return { kind: "accepted", ...identity };
+    if ((await readRecord(folder, "started.json")) === undefined)
+        return { kind: "absent" };
+    const ending = interrupted("github-call-interrupted");
+    await writeRecord(folder, { name: "result.json", value: ending });
+    return replied(identity, ending);
+}
+async function outcome(parts, run) {
+    const { intent, method, payload, signal } = run;
+    const { settings } = parts;
+    if (intent.target.startsWith("branch:"))
+        return interrupted("branch-target-not-supported");
+    try {
+        const result = await method({
+            settings,
+            folder: run.folder,
+            calls: calls(settings, signal),
+            target: intent.target,
+            payload,
+            signal,
+        });
+        return {
+            outcome: "completed",
+            result: JSON.stringify(result),
+            endedAt: new Date().toISOString(),
+        };
+    }
+    catch (error) {
+        if (signal.aborted)
+            return { outcome: "stopped", endedAt: new Date().toISOString() };
+        const reason = String(Reflect.get(Object(error), "message"));
+        const detail = Reflect.get(Object(error), "detail");
+        return {
+            ...interrupted(methodReasons.has(reason) ? reason : "github-call-failed"),
+            ...(typeof detail === "string" ? { detail } : {}),
+        };
+    }
+}
+async function reported(parts, ending) {
+    const { start, recorded } = ending;
+    const { key, intent } = start;
+    await parts.settings.report(reportOf({ intent, commandId: `github:${key}`, worker }, recorded));
+}
+async function ended(parts, ending) {
+    const { start, recorded } = ending;
+    await writeRecord(start.folder, { name: "result.json", value: recorded });
+    await reported(parts, ending);
+}
+function begun(parts, start) {
+    const { key } = start;
+    const stopping = new AbortController();
+    const concluded = (async () => {
+        const recorded = await outcome(parts, {
+            ...start,
+            signal: stopping.signal,
+        });
+        if (stopping.signal.reason === closing)
+            return;
+        await ended(parts, { start, recorded });
+    })()
+        .catch(() => undefined)
+        .finally(() => parts.active.delete(key));
+    parts.active.set(key, { stopping, concluded });
+}
+function ownIntent(intent) {
+    return (intent.capability === worker &&
+        intent.method !== undefined &&
+        intent.target !== undefined &&
+        intent.payload !== undefined &&
+        intent.leaseGeneration !== undefined);
+}
+function payloadOf(text) {
+    try {
+        const value = JSON.parse(text);
+        return typeof value === "object" && value !== null && !Array.isArray(value)
+            ? { ...value }
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function failure(reason) {
+    return { kind: "failed", reason };
+}
+async function delivered(parts, intent) {
+    if (!ownIntent(intent))
+        return failure("unsupported-effect");
+    if (intent.target.startsWith("branch:"))
+        return failure("branch-target-not-supported");
+    const method = methods.get(intent.method);
+    if (method === undefined)
+        return failure("unsupported-effect");
+    const known = await reconciled(parts, intent);
+    if (known.kind !== "absent")
+        return known;
+    const text = await parts.settings.document(intent.payload);
+    if (text === undefined)
+        return failure("payload-not-available");
+    const payload = payloadOf(text);
+    if (payload === undefined)
+        return failure("invalid-payload");
+    const place = placed(parts, intent);
+    await writeRecord(place.folder, {
+        name: "started.json",
+        value: {
+            operationId: intent.operationId,
+            method: intent.method,
+            target: intent.target,
+            startedAt: new Date().toISOString(),
+            runId: intent.runId,
+            inputDigest: intent.inputDigest,
+            leaseGeneration: intent.leaseGeneration,
+            payloadText: text,
+        },
+    });
+    begun(parts, { ...place, intent, method, payload });
+    return { receipt: place.key, worker };
+}
+async function halted(active, reason) {
+    active.stopping.abort(reason);
+    await active.concluded;
+}
+async function stopped(parts, intent) {
+    const active = parts.active.get(placed(parts, intent).key);
+    if (active !== undefined)
+        await halted(active, "github-operation-stopped");
+    return reconciled(parts, intent);
+}
+function textOf(value, name) {
+    const item = Reflect.get(Object(value), name);
+    return typeof item === "string" ? item : "";
+}
+function keptOf(value) {
+    const leaseGeneration = Reflect.get(Object(value), "leaseGeneration");
+    const kept = {
+        operationId: textOf(value, "operationId"),
+        runId: textOf(value, "runId"),
+        inputDigest: textOf(value, "inputDigest"),
+        method: textOf(value, "method"),
+        target: textOf(value, "target"),
+        payloadText: textOf(value, "payloadText"),
+    };
+    if (typeof leaseGeneration !== "number" || Object.values(kept).includes(""))
+        return undefined;
+    return { ...kept, leaseGeneration };
+}
+function startOf(parts, value) {
+    const kept = keptOf(value);
+    if (kept === undefined)
+        return undefined;
+    const method = methods.get(kept.method);
+    const payload = payloadOf(kept.payloadText);
+    if (method === undefined || payload === undefined)
+        return undefined;
+    const place = located(parts.settings.journal, kept.operationId);
+    return { ...place, intent: kept, method, payload };
+}
+function recordOf(value) {
+    const outcome = outcomes.find((item) => item === textOf(value, "outcome"));
+    if (outcome === undefined)
+        return undefined;
+    const result = Reflect.get(Object(value), "result");
+    const reason = Reflect.get(Object(value), "reason");
+    return {
+        outcome,
+        endedAt: textOf(value, "endedAt"),
+        ...(typeof result === "string" ? { result } : {}),
+        ...(typeof reason === "string" ? { reason } : {}),
+    };
+}
+async function unsettled(parts, kept) {
+    const status = await parts.settings.operationStatus(kept.operationId);
+    return unsettledOperations.has(status ?? "");
+}
+async function live(parts, kept) {
+    if (!(await unsettled(parts, kept)))
+        return false;
+    const run = await parts.settings.runStatus(kept.runId);
+    return run !== undefined && !endedRuns.has(run);
+}
+async function resent(parts, saved) {
+    const recorded = recordOf(saved.result);
+    if (recorded === undefined)
+        return;
+    if (!(await unsettled(parts, saved.start.intent)))
+        return;
+    await reported(parts, { start: saved.start, recorded });
+}
+async function continued(parts, start) {
+    if (await live(parts, start.intent)) {
+        begun(parts, start);
+        return;
+    }
+    const recorded = {
+        outcome: "stopped",
+        endedAt: new Date().toISOString(),
+    };
+    await ended(parts, { start, recorded });
+}
+async function resumed(parts, folder) {
+    const started = await readRecord(folder, "started.json");
+    if (started === undefined)
+        return;
+    const result = await readRecord(folder, "result.json");
+    const start = startOf(parts, started);
+    if (start !== undefined && result !== undefined) {
+        await resent(parts, { start, result });
+        return;
+    }
+    if (start !== undefined) {
+        await continued(parts, start);
+        return;
+    }
+    if (result !== undefined)
+        return;
+    const ending = interrupted("github-call-interrupted");
+    await writeRecord(folder, { name: "result.json", value: ending });
+}
+async function scanned(parts) {
+    const { journal } = parts.settings;
+    const entries = await readdir(journal).catch(() => []);
+    await Promise.all(entries.map((entry) => resumed(parts, join(journal, entry)).catch(() => undefined)));
+}
+function scanning(parts) {
+    const scan = scanned(parts).finally(() => {
+        parts.scanned.resolve();
+    });
+    parts.scans.push(scan);
+    return scan;
+}
+export function githubWorker(settings) {
+    if (settings.gh.length === 0)
+        throw new Error("invalid-github-command");
+    const parts = {
+        settings,
+        active: new Map(),
+        scanned: Promise.withResolvers(),
+        scans: [],
+    };
+    const after = (call) => parts.scanned.promise.then(call);
+    return {
+        deliver: (intent) => after(() => delivered(parts, intent)),
+        reconcile: (intent) => after(() => reconciled(parts, intent)),
+        stop: (intent) => after(() => stopped(parts, intent)),
+        scan: () => scanning(parts),
+        close: async () => {
+            await Promise.all(parts.scans);
+            await Promise.all([...parts.active.values()].map((active) => halted(active, closing)));
+        },
+    };
+}

package/dist/src/daemon/host-environment.d.ts

@@ -0,0 +1,8 @@
+export interface HostPlace {
+    readonly directory: string;
+    readonly concurrency: number;
+    readonly leaseSeconds?: number;
+}
+export declare const ownershipLeaseSeconds = 15;
+export declare function worldDirectory(directory: string): string;
+export declare function hostEnvironment(place: HostPlace): Readonly<Record<string, string>>;

package/dist/src/daemon/host-environment.js

@@ -0,0 +1,14 @@
+import { join } from "node:path";
+export const ownershipLeaseSeconds = 15;
+export function worldDirectory(directory) {
+    return join(directory, "world");
+}
+export function hostEnvironment(place) {
+    return {
+        WORKFLOW_TARGET_WORLD: "local",
+        WORKFLOW_LOCAL_DATA_DIR: worldDirectory(place.directory),
+        WORKFLOW_LOCAL_BASE_URL: "http://127.0.0.1:1",
+        WORKFLOW_LOCAL_QUEUE_CONCURRENCY: String(place.concurrency),
+        WORKFLOW_INLINE_OWNERSHIP_LEASE_SECONDS: String(place.leaseSeconds ?? ownershipLeaseSeconds),
+    };
+}

package/dist/src/daemon/issue-queue.d.ts

@@ -0,0 +1,10 @@
+interface QueueSettings {
+    readonly directory: string;
+    readonly runtimeDirectory: string;
+    readonly intervalMilliseconds: number;
+    readonly resetQueue?: boolean;
+}
+export declare function issueQueue(settings: QueueSettings): {
+    readonly stop: () => Promise<void>;
+};
+export {};