cloving 1.3.0 → 1.4.0

package/dist/src/daemon/daemon-loops.js

@@ -3,6 +3,7 @@ import { issueQueue } from "./issue-queue.js";
 import { notifyRuns } from "./notify.js";
 export async function daemonLoops(settings) {
     const schedules = await workflowSchedules(settings);
+    settings.scheduleConnection?.connect(schedules.request);
     try {
         const notifier = settings.notifyCommand === undefined
             ? undefined
@@ -14,7 +15,8 @@ export async function daemonLoops(settings) {
                     ? {}
                     : { intervalMilliseconds: settings.notifyMilliseconds }),
             });
-        const queue = settings.queueMilliseconds === undefined
+        const queue = settings.queueMilliseconds === undefined ||
+            settings.queueWorkflowId === undefined
             ? undefined
             : issueQueue({
                 directory: settings.directory,

package/dist/src/daemon/daemon.js

@@ -1,4 +1,4 @@
-import { adapters, recoverCommands, } from "./daemon-adapters.js";
+import { adapters, recoverCommands, recoverClaude, } from "./daemon-adapters.js";
 import { mkdir, realpath } from "node:fs/promises";
 import { join } from "node:path";
 import { registerStepBridge, sdkStepCall, stepBridge, } from "../host/step-bridge-host.js";
@@ -12,8 +12,9 @@ import { commandEffects } from "./command-journal.js";
 import { worldDirectory } from "./host-environment.js";
 import { pinnedWorkflowHandler } from "./workflow-replay.js";
 import { scheduledDeclarations } from "./workflow-schedules.js";
+import { scheduleConnection } from "./schedule-control.js";
 import { daemonLoops } from "./daemon-loops.js";
-import { ticketRegistrations, ticketRegistrationTable, issueWorkflow, } from "./ticket-registration.js";
+import { ticketRegistrations, ticketRegistrationTable, } from "./ticket-registration.js";
 export const turnLeaseMilliseconds = 4 * 3_600_000;
 export const loopMilliseconds = 250;
 export const bridgeTiming = {
@@ -138,7 +139,12 @@ async function openDaemon(settings) {
     const { worker, github, runs, handoff, commands } = resources;
     await mkdir(join(settings.directory, "state"), { recursive: true });
     await mkdir(settings.runtimeDirectory, { recursive: true, mode: 0o700 });
+    const schedules = scheduleConnection();
     const opening = await startService({
+        schedule: schedules.request,
+        ...(settings.queueDailySpendLimitUsd === undefined
+            ? {}
+            : { queueDailySpendLimitUsd: settings.queueDailySpendLimitUsd }),
         workerHarness: worker.harness,
         commandEffects: commandEffects(join(settings.directory, "commands")),
         stateDirectory: join(settings.directory, "state"),
@@ -164,7 +170,7 @@ async function openDaemon(settings) {
         await closeWorkers(resources);
         return opening;
     }
-    const running = { ...resources, service: opening.service };
+    const running = { ...resources, service: opening.service, schedules };
     await recoverWorkers(running, given.promise);
     return {
         kind: "started",
@@ -173,7 +179,9 @@ async function openDaemon(settings) {
 }
 async function recoverWorkers(resources, ports) {
     try {
-        await recoverCommands(resources.commands, await ports);
+        const host = await ports;
+        await recoverCommands(resources.commands, host);
+        await recoverClaude(resources.worker, host);
     }
     catch (error) {
         await Promise.allSettled([
@@ -195,6 +203,7 @@ async function runningDaemon(settings, resources) {
     await github.scan();
     const loops = await daemonLoops({
         ...settings,
+        scheduleConnection: resources.schedules,
         submit: service.worker.submit,
         queueWorkflowId: queueWorkflowId(settings),
     }).catch(async (error) => {
@@ -212,6 +221,5 @@ async function runningDaemon(settings, resources) {
     };
 }
 function queueWorkflowId(settings) {
-    return (settings.declarations?.find((declaration) => declaration.queue === true)
-        ?.workflowId ?? issueWorkflow);
+    return settings.declarations?.find((declaration) => declaration.queue === true)?.workflowId;
 }

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

@@ -0,0 +1,2 @@
+import { type Operation } from "./github-operation.ts";
+export declare function attachAsset(operation: Operation): Promise<unknown>;

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

@@ -0,0 +1,149 @@
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+import { copiedAttachment, openedAttachment } from "./attachment-file.js";
+import { attachmentFolder } from "./attachments.js";
+import { repositoryName } from "./github-issue-methods.js";
+import { issuePrivacy, operatorPrivateTexts } from "./github-issue-privacy.js";
+import { field, repositoryPath, text, } from "./github-operation.js";
+import { githubRead } from "./github-retry.js";
+function isList(value) {
+    return Array.isArray(value);
+}
+function validName(name) {
+    return /^[\w-][\w.-]*\.(?:mp4|webm|png)$/.test(name) && !name.includes("..");
+}
+function validRelease(release) {
+    return /^[a-z][a-z0-9-]{0,63}$/.test(release) && !/^v\d/.test(release);
+}
+function attachmentOf(operation) {
+    const number = operation.payload["number"];
+    const name = text(operation, "name");
+    const release = text(operation, "release");
+    const comment = text(operation, "comment");
+    if (typeof number !== "number" || !Number.isSafeInteger(number) || number < 1)
+        throw new Error("invalid-payload");
+    if (!validName(name) || !validRelease(release) || comment.length > 4000)
+        throw new Error("invalid-payload");
+    return { number, name, release, comment };
+}
+function attachedFile(operation, name) {
+    return openedAttachment({
+        folder: attachmentFolder({
+            worktrees: operation.settings.worktrees,
+            target: operation.target,
+        }),
+        name,
+    });
+}
+async function pages(operation, path) {
+    const reply = JSON.parse(await githubRead(operation, ["api", "--paginate", "--slurp", path]));
+    if (!isList(reply))
+        throw new Error("github-call-failed");
+    return reply.flatMap((page) => {
+        if (!isList(page))
+            throw new Error("github-call-failed");
+        return page;
+    });
+}
+async function releaseOf(operation, tag) {
+    const releases = await pages(operation, `${repositoryPath}/releases?per_page=100`);
+    return releases.find((item) => field(item, "tag_name") === tag);
+}
+async function ensuredRelease(operation, release) {
+    if ((await releaseOf(operation, release)) !== undefined)
+        return;
+    try {
+        await operation.calls.gh([
+            "release",
+            "create",
+            release,
+            "--prerelease",
+            "--latest=false",
+            "--title",
+            "Pull request demos",
+            "--notes",
+            "Demo videos of pull requests. Cloving uploads them.",
+        ]);
+    }
+    catch (error) {
+        if ((await releaseOf(operation, release)) === undefined)
+            throw error;
+    }
+}
+async function uploaded(operation, attachment) {
+    const { release } = attachment;
+    await ensuredRelease(operation, release);
+    const asset = `pr-${String(attachment.number)}-${attachment.name}`;
+    const copy = join(operation.folder, asset);
+    try {
+        await copiedAttachment(attachment.file, copy);
+        await operation.calls.gh(["release", "upload", release, copy, "--clobber"]);
+    }
+    finally {
+        await rm(copy, { force: true });
+    }
+    const assets = field(await releaseOf(operation, release), "assets");
+    const found = isList(assets)
+        ? assets.find((item) => field(item, "name") === asset)
+        : undefined;
+    const url = field(found, "browser_download_url");
+    if (typeof url !== "string" || !url.startsWith("https://"))
+        throw new Error("github-call-failed");
+    return url;
+}
+async function ownLogin(operation) {
+    const user = JSON.parse(await githubRead(operation, ["api", "user"]));
+    const login = field(user, "login");
+    if (typeof login !== "string" || login === "")
+        throw new Error("github-call-failed");
+    return login;
+}
+async function commented(operation, attachment) {
+    const { number, name, url } = attachment;
+    const marker = `<!-- cloving-attachment:${String(number)}:${name} -->`;
+    const body = `${attachment.comment}\n\n[${name}](${url})\n\n${marker}`;
+    const comments = await pages(operation, `${repositoryPath}/issues/${String(number)}/comments?per_page=100`);
+    const login = await ownLogin(operation);
+    const known = comments.find((item) => {
+        const existing = field(item, "body");
+        return (typeof existing === "string" &&
+            existing.includes(marker) &&
+            field(field(item, "user"), "login") === login);
+    });
+    const id = field(known, "id");
+    if (typeof id === "number") {
+        await operation.calls.gh([
+            "api",
+            "-X",
+            "PATCH",
+            `${repositoryPath}/issues/comments/${String(id)}`,
+            "-f",
+            `body=${body}`,
+        ]);
+        return;
+    }
+    await operation.calls.gh([
+        "api",
+        `${repositoryPath}/issues/${String(number)}/comments`,
+        "-f",
+        `body=${body}`,
+    ]);
+}
+export async function attachAsset(operation) {
+    const attachment = attachmentOf(operation);
+    operatorPrivateTexts(operation.settings);
+    const repository = repositoryName(await operation.calls.gh(["repo", "view", "--json", "nameWithOwner"]));
+    issuePrivacy(attachment.comment, {
+        settings: operation.settings,
+        repository,
+    });
+    const file = await attachedFile(operation, attachment.name);
+    try {
+        const url = await uploaded(operation, { ...attachment, file });
+        await commented(operation, { ...attachment, url });
+        return { number: attachment.number, url };
+    }
+    finally {
+        await file.close();
+    }
+}

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

@@ -0,0 +1,6 @@
+export declare function triggerKind(trigger: unknown): "push" | "event";
+export declare function pullRequestTrigger(source: string): unknown;
+export declare function workflowApplies(trigger: unknown, context: {
+    readonly branch: string;
+    readonly paths: readonly string[];
+}): boolean;

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

@@ -0,0 +1,138 @@
+import { parse } from "yaml";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function triggerKind(trigger) {
+    if (!isRecord(trigger))
+        return "push";
+    const types = patterns(trigger["types"]);
+    return types === undefined || types.includes("synchronize")
+        ? "push"
+        : "event";
+}
+export function pullRequestTrigger(source) {
+    try {
+        const document = parse(source, { merge: true });
+        if (!isRecord(document) || !("on" in document))
+            return true;
+        const events = document["on"];
+        if (typeof events === "string")
+            return events === "pull_request";
+        if (Array.isArray(events))
+            return events.includes("pull_request");
+        if (isRecord(events))
+            return "pull_request" in events ? events["pull_request"] : false;
+        return true;
+    }
+    catch {
+        return true;
+    }
+}
+function patternToken(token) {
+    if (token === "**/")
+        return { kind: "directory" };
+    if (token === "*" || token === "**")
+        return {
+            kind: "character",
+            matcher: token === "*" ? /[^/]/ : /[\s\S]/,
+            optional: true,
+            repeat: true,
+        };
+    const literal = token.startsWith("\\") ? token.slice(1) : token;
+    const source = token.startsWith("[")
+        ? token
+        : literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return {
+        kind: "character",
+        matcher: new RegExp(`^${source}$`),
+        optional: false,
+        repeat: false,
+    };
+}
+function patternTokens(source) {
+    const tokens = [];
+    for (const raw of source.match(/\*\*\/|\*\*|\*|\[[a-zA-Z0-9-]+\]|\\[\s\S]|[\s\S]/g) ?? []) {
+        if (raw !== "?" && raw !== "+") {
+            tokens.push(patternToken(raw));
+            continue;
+        }
+        const previous = tokens.pop();
+        if (previous?.kind !== "character" || previous.optional || previous.repeat)
+            throw new Error("invalid-workflow-filter");
+        tokens.push({ ...previous, optional: raw === "?", repeat: raw === "+" });
+    }
+    return tokens;
+}
+function advanceDirectory({ value, previous, }) {
+    let reachable = false;
+    return Array.from({ length: value.length + 1 }, (_, index) => {
+        const matches = previous[index] === true || (reachable && value[index - 1] === "/");
+        reachable ||= previous[index] === true;
+        return matches;
+    });
+}
+function advancePattern(token, input) {
+    const { value, previous } = input;
+    const next = [];
+    for (let index = 0; index <= value.length; index += 1) {
+        const consumes = index > 0 && token.matcher.test(value[index - 1] ?? "");
+        next[index] =
+            (token.optional && previous[index] === true) ||
+                (consumes &&
+                    (previous[index - 1] === true ||
+                        (token.repeat && next[index - 1] === true)));
+    }
+    return next;
+}
+function matchesPattern(value, source) {
+    let previous = [true];
+    for (const token of patternTokens(source))
+        previous =
+            token.kind === "directory"
+                ? advanceDirectory({ value, previous })
+                : advancePattern(token, { value, previous });
+    return previous[value.length] === true;
+}
+function selected(value, patterns) {
+    let included = false;
+    for (const pattern of patterns) {
+        const negative = pattern.startsWith("!");
+        const source = negative ? pattern.slice(1) : pattern;
+        try {
+            if (matchesPattern(value, source))
+                included = !negative;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return included;
+}
+function patterns(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    return value.every((item) => typeof item === "string")
+        ? value
+        : undefined;
+}
+function allows(values, filters) {
+    const include = patterns(filters.include);
+    const ignore = patterns(filters.ignore);
+    if (include !== undefined &&
+        !values.some((value) => selected(value, include) !== false))
+        return false;
+    return (ignore === undefined ||
+        values.some((value) => selected(value, ignore) !== true));
+}
+export function workflowApplies(trigger, context) {
+    if (!isRecord(trigger))
+        return trigger !== false;
+    return (allows([context.branch], {
+        include: trigger["branches"],
+        ignore: trigger["branches-ignore"],
+    }) &&
+        allows(context.paths, {
+            include: trigger["paths"],
+            ignore: trigger["paths-ignore"],
+        }));
+}

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

@@ -0,0 +1,10 @@
+import { type Operation } from "./github-operation.ts";
+export interface ExpectedWorkflow {
+    readonly path: string;
+    readonly kind: "push" | "event";
+}
+export declare function pullRequestWorkflows(operation: Operation, commit: string): Promise<readonly ExpectedWorkflow[]>;
+export declare function pendingWorkflows(operation: Operation, input: {
+    readonly commit: string;
+    readonly workflows: readonly ExpectedWorkflow[];
+}): Promise<readonly string[]>;

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

@@ -0,0 +1,148 @@
+import { pullRequestTrigger, triggerKind, workflowApplies, } from "./github-ci-filters.js";
+import { field, repositoryPath } from "./github-operation.js";
+import { githubRead } from "./github-retry.js";
+async function pullBase(operation) {
+    const pull = JSON.parse(await githubRead(operation, [
+        "api",
+        `${repositoryPath}/pulls/${String(operation.payload["number"])}`,
+    ]));
+    if (typeof pull !== "object" || pull === null || !("base" in pull))
+        throw new Error("github-call-failed");
+    const baseData = pull.base;
+    if (typeof baseData !== "object" || baseData === null)
+        throw new Error("github-call-failed");
+    const base = field(baseData, "sha");
+    const branch = field(baseData, "ref");
+    if (typeof base !== "string" ||
+        !/^[0-9a-f]{40,64}$/.test(base) ||
+        typeof branch !== "string")
+        throw new Error("github-call-failed");
+    return { base, branch };
+}
+async function appliesToPull(operation, input) {
+    const { commit, trigger } = input;
+    if (trigger === false)
+        return false;
+    if (typeof trigger !== "object" || trigger === null)
+        return true;
+    if (!["paths", "paths-ignore", "branches", "branches-ignore"].some((key) => Object.hasOwn(trigger, key)))
+        return true;
+    const { base, branch } = await pullBase(operation);
+    await operation.calls.git(operation.settings.repository, [
+        "fetch",
+        "--quiet",
+        "--no-tags",
+        "origin",
+        base,
+    ]);
+    const paths = await operation.calls.git(operation.settings.repository, [
+        "diff",
+        "--name-only",
+        "-z",
+        `${base}...${commit}`,
+    ]);
+    return workflowApplies(trigger, {
+        branch,
+        paths: paths.split("\0").filter((path) => path !== ""),
+    });
+}
+export async function pullRequestWorkflows(operation, commit) {
+    const read = (parts) => operation.calls.git(operation.settings.repository, parts);
+    const paths = await read([
+        "ls-tree",
+        "-r",
+        "--name-only",
+        "-z",
+        commit,
+        "--",
+        ".github/workflows",
+    ]);
+    const workflows = [];
+    for (const path of paths.split("\0")) {
+        if (!/^\.github\/workflows\/[^/]+\.ya?ml$/.test(path))
+            continue;
+        const trigger = pullRequestTrigger(await read(["show", `${commit}:${path}`]));
+        if (await appliesToPull(operation, { commit, trigger }))
+            workflows.push({ path, kind: triggerKind(trigger) });
+    }
+    if (workflows.length === 0)
+        return workflows;
+    const inactive = await inactiveWorkflows(operation);
+    return workflows.filter((workflow) => !inactive.has(workflow.path));
+}
+function isList(value) {
+    return Array.isArray(value);
+}
+async function actionPages(operation, request) {
+    const pages = JSON.parse(await githubRead(operation, ["api", "--paginate", "--slurp", request.path]));
+    if (!isList(pages) || pages.length === 0)
+        throw new Error("github-call-failed");
+    return pages.flatMap((page) => {
+        if (typeof page !== "object" || page === null)
+            throw new Error("github-call-failed");
+        const items = field(page, request.key);
+        if (!isList(items))
+            throw new Error("github-call-failed");
+        return items;
+    });
+}
+async function inactiveWorkflows(operation) {
+    const workflows = await actionPages(operation, {
+        path: `${repositoryPath}/actions/workflows?per_page=100`,
+        key: "workflows",
+    });
+    const inactive = new Set();
+    for (const workflow of workflows) {
+        if (typeof workflow !== "object" || workflow === null)
+            throw new Error("github-call-failed");
+        const path = field(workflow, "path");
+        const state = field(workflow, "state");
+        if (typeof path !== "string" || typeof state !== "string")
+            throw new Error("github-call-failed");
+        if (state !== "active")
+            inactive.add(path);
+    }
+    return inactive;
+}
+function isWorkflowRun(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const conclusion = field(value, "conclusion");
+    return (typeof field(value, "id") === "number" &&
+        ["path", "head_sha", "event", "status"].every((key) => typeof field(value, key) === "string") &&
+        (conclusion === null || typeof conclusion === "string"));
+}
+async function workflowRuns(operation, commit) {
+    const runs = await actionPages(operation, {
+        path: `${repositoryPath}/actions/runs?head_sha=${commit}&event=pull_request&per_page=100`,
+        key: "workflow_runs",
+    });
+    if (!runs.every(isWorkflowRun))
+        throw new Error("github-call-failed");
+    return runs;
+}
+export async function pendingWorkflows(operation, input) {
+    if (input.workflows.length === 0)
+        return [];
+    const paths = input.workflows.map((workflow) => workflow.path);
+    const latest = new Map();
+    for (const run of await workflowRuns(operation, input.commit)) {
+        if (run.head_sha !== input.commit || run.event !== "pull_request")
+            continue;
+        const path = paths
+            .filter((expected) => run.path === expected || run.path.startsWith(`${expected}@`))
+            .sort((left, right) => right.length - left.length)[0];
+        if (path === undefined)
+            continue;
+        if (run.id > (latest.get(path)?.id ?? -1))
+            latest.set(path, run);
+    }
+    const pending = input.workflows.filter((workflow) => {
+        const run = latest.get(workflow.path);
+        if (run === undefined)
+            return workflow.kind === "push";
+        return (run.status !== "completed" ||
+            !["success", "neutral", "skipped"].includes(run.conclusion ?? ""));
+    });
+    return pending.length === 0 ? [] : ["waiting for GitHub Actions checks"];
+}

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

@@ -2,6 +2,7 @@ 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 { pendingWorkflows, pullRequestWorkflows, } from "./github-ci-workflows.js";
 import { ciWait, workflowAttempt, attemptChecks, rerunCi, attemptOutput, } from "./github-ci-rerun.js";
 import { field, githubTiming, repositoryPath, } from "./github-operation.js";
 function isCheckRun(value) {
@@ -203,16 +204,29 @@ async function ciFailureOutput(operation, input) {
             current,
         ]);
 }
-export async function waitForCi(operation, commit) {
-    const { pollMilliseconds: poll, ciGraceMilliseconds: grace, ciLimitMilliseconds: limit, } = {
+async function ciSettings(operation, commit) {
+    const timing = {
         ...githubTiming,
         ciGraceMilliseconds: 60_000,
         ciLimitMilliseconds: 5_400_000,
         ...operation.settings.timing,
     };
+    const required = requiredChecks(operation);
+    const workflows = required === undefined ? await pullRequestWorkflows(operation, commit) : [];
+    return {
+        required,
+        workflows,
+        poll: timing.pollMilliseconds,
+        limit: timing.ciLimitMilliseconds,
+        grace: workflows.some((workflow) => workflow.kind === "push")
+            ? Infinity
+            : timing.ciGraceMilliseconds,
+    };
+}
+export async function waitForCi(operation, commit) {
     const wait = await ciWait(operation, commit);
     const started = wait.startedAt;
-    const required = requiredChecks(operation);
+    const { required, workflows, grace, poll, limit } = await ciSettings(operation, commit);
     const names = new Set(required);
     for (;;) {
         const checks = latestRuns(await checkRuns(operation, commit), required);
@@ -232,7 +246,11 @@ export async function waitForCi(operation, commit) {
                     failed: retried.failures,
                 }),
             };
-        const pending = [...pendingChecks(checks, names), ...retried.pending];
+        const pending = [
+            ...pendingChecks(checks, names),
+            ...retried.pending,
+            ...(await pendingWorkflows(operation, { commit, workflows })),
+        ];
         if (pending.length === 0 &&
             (required !== undefined ||
                 names.size > 0 ||

package/dist/src/daemon/github-issue-methods.d.ts

@@ -1,3 +1,5 @@
 import { type Operation } from "./github-operation.ts";
+export declare function repositoryName(reply: string): string;
+export declare function captureDraft(operation: Operation): Promise<unknown>;
 export declare function createIssue(operation: Operation): Promise<unknown>;
 export declare function discard(operation: Operation): Promise<unknown>;

package/dist/src/daemon/github-issue-methods.js

@@ -1,4 +1,5 @@
 import { existsSync } from "node:fs";
+import { createHash } from "node:crypto";
 import { lstat, readFile } from "node:fs/promises";
 import { basename, join } from "node:path";
 import { existingTree, removeWorktree, repositoryPath, text, } from "./github-operation.js";
@@ -30,7 +31,7 @@ function issuePage(line) {
         throw new Error("github-call-failed");
     return page.map((issue) => issueOf(issue));
 }
-function repositoryName(reply) {
+export function repositoryName(reply) {
     const repository = JSON.parse(reply);
     if (typeof repository !== "object" ||
         repository === null ||
@@ -50,6 +51,28 @@ async function draftOf(operation) {
         throw new Error("draft-not-available");
     return readFile(path, "utf8");
 }
+function draftDigest(text) {
+    return "sha256:" + createHash("sha256").update(text).digest("hex");
+}
+export async function captureDraft(operation) {
+    const text = await draftOf(operation);
+    const capture = { text, digest: draftDigest(text) };
+    if (Buffer.byteLength(JSON.stringify(capture)) > 65_536)
+        throw new Error("draft-too-large");
+    return capture;
+}
+function checkDraftDigest(operation, draft) {
+    if (!Object.hasOwn(operation.payload, "expectedDigests"))
+        return;
+    const digests = operation.payload["expectedDigests"];
+    if (!Array.isArray(digests) ||
+        digests.length === 0 ||
+        !digests.every((digest) => typeof digest === "string" && /^sha256:[0-9a-f]{64}$/.test(digest)))
+        throw new Error("invalid-payload");
+    const current = draftDigest(draft);
+    if (!digests.every((digest) => digest === current))
+        throw new Error("draft-changed");
+}
 async function knownIssue(operation, marker) {
     const output = await operation.calls.gh([
         "api",
@@ -62,7 +85,10 @@ async function knownIssue(operation, marker) {
 }
 export async function createIssue(operation) {
     operatorPrivateTexts(operation.settings);
-    const draft = await draftOf(operation);
+    const draft = Object.hasOwn(operation.payload, "text")
+        ? reportText(operation)
+        : await draftOf(operation);
+    checkDraftDigest(operation, draft);
     const [heading = "", ...lines] = draft.split("\n");
     if (!heading.startsWith("# ") || heading.slice(2).trim() === "")
         throw new Error("invalid-draft");
@@ -89,6 +115,15 @@ export async function createIssue(operation) {
     const url = printed.trim().split("\n").at(-1) ?? "";
     return issueFromUrl(url);
 }
+function reportText(operation) {
+    if (Object.hasOwn(operation.payload, "draft") ||
+        Object.hasOwn(operation.payload, "expectedDigests"))
+        throw new Error("invalid-payload");
+    const report = text(operation, "text");
+    if (Buffer.byteLength(report) > 65536)
+        throw new Error("draft-too-large");
+    return report;
+}
 export async function discard(operation) {
     const place = treePlace({
         worktrees: operation.settings.worktrees,