cloving 1.2.0 → 1.4.0

package/dist/src/daemon/daemon.js

@@ -1,20 +1,19 @@
+import { adapters, recoverCommands, recoverClaude, } from "./daemon-adapters.js";
 import { mkdir, realpath } from "node:fs/promises";
 import { join } from "node:path";
-import { startDelivery, } from "../host/start-delivery.js";
 import { registerStepBridge, sdkStepCall, stepBridge, } from "../host/step-bridge-host.js";
 import { startHost } from "../host/world-host.js";
 import { worldLoop } from "../host/world-reconciliation.js";
-import { cancelled, workflowOutcome, taggedRun, taggedRuns, } from "../host/world-runs.js";
-import { startService, } from "../service/service.js";
-import { workflowPin } from "../broker/workflow-pin.js";
-import { claudeWorker } from "./claude-worker.js";
+import { workflowOutcome, taggedRun, taggedRuns } from "../host/world-runs.js";
+import { startService, serviceLimits, } from "../service/service.js";
+import { workflowGenerations, prepareWorkflowGenerations, } from "./workflow-generations.js";
 import { deliveryRouter } from "./delivery-router.js";
-import { handoffWorker } from "./handoff-worker.js";
-import { githubWorker } from "./github-worker.js";
-import { chatsWorker } from "./chats-worker.js";
+import { commandEffects } from "./command-journal.js";
 import { worldDirectory } from "./host-environment.js";
-import { issueQueue } from "./issue-queue.js";
-import { notifyRuns } from "./notify.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, } from "./ticket-registration.js";
 export const turnLeaseMilliseconds = 4 * 3_600_000;
 export const loopMilliseconds = 250;
@@ -23,11 +22,23 @@ export const bridgeTiming = {
     pollMilliseconds: 250,
     retryMilliseconds: 1_000,
 };
-async function hosted(settings, ports) {
+async function hosted(settings, hosting) {
+    const { ports, generations } = hosting;
+    await prepareWorkflowGenerations(ports, generations);
     const opening = await startHost({
         dataDirectory: worldDirectory(settings.directory),
         concurrency: settings.concurrency,
-        handler: settings.handler,
+        handler: pinnedWorkflowHandler(async (request, runId) => {
+            const generation = await generations.resolve(await ports.workflow.manifest(runId));
+            return generation === undefined
+                ? new Response("pinned-workflow-unavailable", { status: 503 })
+                : generation.handler(request);
+        }, {
+            state: ports.state,
+            run: taggedRun,
+            available: ports.workflow.available,
+            submit: ports.submit,
+        }),
     });
     if (opening.kind === "refused")
         throw new Error(`${opening.reason}: ${opening.detail}`);
@@ -55,169 +66,160 @@ async function hosted(settings, ports) {
         },
     };
 }
-function githubOf(settings, given) {
-    const { directory, repository, checkCommand } = settings;
-    return githubWorker({
-        document: async (digest) => (await given).document(digest),
-        report: async (effect) => (await given).reportEffect(effect),
-        operationStatus: async (operationId) => (await (await given).operation(operationId))?.status,
-        runStatus: async (runId) => (await (await given).state()).runs[runId]?.status,
-        repository,
-        gh: settings.githubCommand ?? ["gh"],
-        worktrees: join(directory, "worktrees"),
-        journal: join(directory, "github"),
-        ...(settings.privateTexts === undefined
-            ? {}
-            : { privateTexts: settings.privateTexts }),
-        ...(checkCommand === undefined ? {} : { check: checkCommand }),
-    });
-}
-function adapters(settings, options) {
-    const { directory, repository, command } = settings;
-    const { given, table, registrations } = options;
-    const functions = Object.fromEntries(table.map((row) => [row.workflowId, settings.workflows[row.functionName]]));
-    const workflows = Object.fromEntries(registrations.map((registration) => [
-        workflowPin(registration.manifest),
-        functions[registration.workflowId],
-    ]));
-    const document = async (digest) => (await given).document(digest);
-    const report = async (effect) => (await given).reportEffect(effect);
-    const worker = claudeWorker({
-        fallbackModels: settings.fallbackModels ?? [],
-        tokenPrices: settings.tokenPrices ?? {},
-        worker: settings.worker ?? "claude",
-        profiles: settings.profiles ?? {},
-        workflowId: async (runId) => (await given).workflowId(runId),
-        repository,
-        command,
-        document,
-        report,
-        worktrees: join(directory, "worktrees"),
-        journal: join(directory, "journal"),
-    });
-    const github = githubOf(settings, given);
-    const chats = chatsWorker({
-        runtimeDirectory: settings.runtimeDirectory,
-        document,
-        workflowId: async (runId) => (await given).workflowId(runId),
-    });
-    const runs = startDelivery({
-        document,
-        runs: taggedRuns,
-        cancel: cancelled,
-        input: async (runId) => (await given).input(runId),
-        workflow: ({ workflow }) => Promise.resolve(workflows[workflow]),
-    });
-    const handoff = handoffOf(settings, given);
-    return { worker, github, runs, chats, handoff };
-}
-function handoffOf(settings, given) {
-    return handoffWorker({
-        runtimeDirectory: settings.runtimeDirectory,
-        journal: join(settings.directory, "handoffs"),
-        document: async (digest) => (await given).document(digest),
-        runStatus: async (runId) => (await (await given).state()).runs[runId]?.status,
-    });
-}
 async function daemonRegistrations(settings) {
+    const conflict = settings.workflowRefusals?.find((refusal) => refusal.codes.includes("queue-workflow-conflict"));
+    if (conflict !== undefined)
+        return {
+            table: [],
+            admitted: {
+                kind: "rejected",
+                detail: `queue-workflow-conflict: ${conflict.scope} ${conflict.label}`,
+            },
+        };
     const table = ticketRegistrationTable({
         repository: settings.repository,
         command: settings.ticketCommand,
         nextCommand: settings.nextCommand,
         githubCommand: settings.githubCommand,
     }, settings.declarations);
-    const admitted = await ticketRegistrations(settings.manifests, { table });
-    return { table, admitted };
+    const admitted = await ticketRegistrations(settings.manifests, {
+        table,
+        commands: settings.commands ?? {},
+        ...(settings.bundleDigest === undefined
+            ? {}
+            : { bundleDigest: settings.bundleDigest }),
+    });
+    return {
+        table,
+        admitted: admitted.kind === "rejected"
+            ? admitted
+            : {
+                ...admitted,
+                registrations: admitted.registrations.map((registration) => ({
+                    ...registration,
+                    ...(settings.queueMilliseconds !== undefined &&
+                        registration.workflowId === queueWorkflowId(settings)
+                        ? { admission: settings.queueLanes ?? 1, queue: true }
+                        : {}),
+                })),
+            },
+    };
 }
 export async function startDaemon(givenSettings) {
-    const settings = {
+    const repository = await realpath(givenSettings.repository);
+    const scheduled = scheduledDeclarations(givenSettings, {
+        repository,
+        documentBytes: serviceLimits.documentBytes,
+    });
+    if (scheduled.kind === "refused")
+        return scheduled;
+    return openDaemon({
         ...givenSettings,
-        repository: await realpath(givenSettings.repository),
-    };
-    const { directory } = settings;
+        declarations: scheduled.declarations,
+        repository,
+    });
+}
+async function openDaemon(settings) {
     const { table, admitted } = await daemonRegistrations(settings);
     if (admitted.kind === "rejected")
         return {
             kind: "refused",
-            reason: "workflow-rejected",
+            reason: admitted.detail.startsWith("queue-workflow-conflict")
+                ? "queue-workflow-conflict"
+                : "workflow-rejected",
             detail: admitted.detail,
         };
     const given = Promise.withResolvers();
-    const { worker, github, runs, chats, handoff } = adapters(settings, {
-        given: given.promise,
-        table,
+    const generations = workflowGenerations({
+        ...settings,
         registrations: admitted.registrations,
+        table,
     });
-    await mkdir(join(directory, "state"), { recursive: true });
+    const resources = adapters(settings, { given: given.promise, generations });
+    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({
-        stateDirectory: join(directory, "state"),
+        schedule: schedules.request,
+        ...(settings.queueDailySpendLimitUsd === undefined
+            ? {}
+            : { queueDailySpendLimitUsd: settings.queueDailySpendLimitUsd }),
+        workerHarness: worker.harness,
+        commandEffects: commandEffects(join(settings.directory, "commands")),
+        stateDirectory: join(settings.directory, "state"),
         runtimeDirectory: settings.runtimeDirectory,
+        workflowBundles: {
+            directory: join(settings.directory, "workflow-bundles"),
+            repository: settings.repository,
+        },
         workflowRefusals: settings.workflowRefusals ?? [],
-        workflows: admitted.registrations.map((registration) => ({
-            ...registration,
-            ...(settings.queueMilliseconds !== undefined &&
-                registration.workflowId === "develop-issue"
-                ? { admission: settings.queueLanes ?? 1 }
-                : {}),
-        })),
+        workflows: admitted.registrations,
+        retainedWorkflow: generations.available,
         delivery: deliveryRouter({
             runs,
-            effects: { claude: worker, github, chats, handoff },
+            effects: { claude: worker, github, handoff, command: commands },
         }),
         effects: { leaseMilliseconds: turnLeaseMilliseconds },
         host: (ports) => {
             given.resolve(ports);
-            return hosted(settings, ports);
+            return hosted(settings, { ports, generations });
         },
     });
     if (opening.kind === "refused") {
-        await Promise.all([worker.close(), github.close(), chats.close()]);
+        await closeWorkers(resources);
         return opening;
     }
+    const running = { ...resources, service: opening.service, schedules };
+    await recoverWorkers(running, given.promise);
     return {
         kind: "started",
-        daemon: await runningDaemon(settings, {
-            service: opening.service,
-            worker,
-            github,
-            chats,
-        }),
+        daemon: await runningDaemon(settings, running),
     };
 }
+async function recoverWorkers(resources, ports) {
+    try {
+        const host = await ports;
+        await recoverCommands(resources.commands, host);
+        await recoverClaude(resources.worker, host);
+    }
+    catch (error) {
+        await Promise.allSettled([
+            closeWorkers(resources),
+            resources.service.close(),
+        ]);
+        throw error;
+    }
+}
+async function closeWorkers(resources) {
+    await Promise.all([
+        resources.worker.close(),
+        resources.github.close(),
+        resources.commands.close(),
+    ]);
+}
 async function runningDaemon(settings, resources) {
-    const { service, worker, github, chats } = resources;
+    const { service, github } = resources;
     await github.scan();
-    const notifier = settings.notifyCommand === undefined
-        ? undefined
-        : await notifyRuns({
-            directory: settings.directory,
-            runtimeDirectory: settings.runtimeDirectory,
-            command: settings.notifyCommand,
-            ...(settings.notifyMilliseconds === undefined
-                ? {}
-                : { intervalMilliseconds: settings.notifyMilliseconds }),
-        }).catch(async (error) => {
-            await Promise.all([worker.close(), github.close(), chats.close()]);
-            await service.close();
-            throw error;
-        });
-    const queue = settings.queueMilliseconds === undefined
-        ? undefined
-        : issueQueue({
-            directory: settings.directory,
-            runtimeDirectory: settings.runtimeDirectory,
-            intervalMilliseconds: settings.queueMilliseconds,
-            lanes: settings.queueLanes ?? 1,
-            resetQueue: settings.resetQueue ?? false,
-        });
+    const loops = await daemonLoops({
+        ...settings,
+        scheduleConnection: resources.schedules,
+        submit: service.worker.submit,
+        queueWorkflowId: queueWorkflowId(settings),
+    }).catch(async (error) => {
+        await closeWorkers(resources);
+        await service.close();
+        throw error;
+    });
     return {
         socket: service.socket,
         close: async () => {
-            await notifier?.stop();
-            await queue?.stop();
-            await Promise.all([worker.close(), github.close(), chats.close()]);
+            await loops.stop();
+            await closeWorkers(resources);
             await service.close();
         },
     };
 }
+function queueWorkflowId(settings) {
+    return settings.declarations?.find((declaration) => declaration.queue === true)?.workflowId;
+}

package/dist/src/daemon/declared-input.d.ts

@@ -0,0 +1,3 @@
+import type { Fields } from "../protocol.ts";
+import type { ResolutionRequest } from "../service/registry.ts";
+export declare function declaredInput(repository: string, request: Pick<ResolutionRequest, "commandId" | "submission">): Fields;

package/dist/src/daemon/declared-input.js

@@ -0,0 +1,9 @@
+import { createHash } from "node:crypto";
+export function declaredInput(repository, request) {
+    const digest = createHash("sha256").update(request.commandId).digest("hex");
+    return {
+        cycleId: `task-${digest.slice(0, 12)}`,
+        repository,
+        input: request.submission,
+    };
+}

package/dist/src/daemon/delivery-router.js

@@ -17,7 +17,7 @@ export function deliveryRouter(routes) {
     return {
         deliver: (intent, signal) => {
             if (!protectedEffect(intent))
-                return runs.deliver(intent);
+                return runs.deliver(intent, signal);
             return workerOf(routes, intent)?.deliver(intent, signal) ?? refusal();
         },
         reconcile: (intent, signal) => {

package/dist/src/daemon/gemini-stream.d.ts

@@ -0,0 +1,4 @@
+export declare function geminiStream(): {
+    readonly line: (line: string) => readonly string[];
+    readonly result: (exitCode: number | null) => string;
+};

package/dist/src/daemon/gemini-stream.js

@@ -0,0 +1,129 @@
+import { record } from "../protocol.js";
+import { sumUsage, usageOf, } from "../worker-usage.js";
+function parsed(line) {
+    try {
+        return record(JSON.parse(line)) ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+function text(value) {
+    return typeof value === "string" ? value : "";
+}
+function usage(value) {
+    const fields = record(value) ?? {};
+    return usageOf({
+        input_tokens: fields["input_tokens"],
+        output_tokens: fields["output_tokens"],
+        cache_read_input_tokens: fields["cached"],
+    });
+}
+function statistics(event, state) {
+    const stats = record(event["stats"]);
+    const models = record(stats?.["models"]);
+    state.models =
+        models === undefined
+            ? undefined
+            : Object.entries(models).map(([model, counts]) => ({
+                model,
+                usage: usage(counts),
+            }));
+    state.usage =
+        state.models === undefined
+            ? usage(stats)
+            : sumUsage(state.models.map((entry) => entry.usage));
+}
+function completed(event, state) {
+    statistics(event, state);
+    state.success = event["status"] === "success";
+    if (!state.success)
+        state.failure =
+            text(record(event["error"])?.["message"]) ||
+                "Gemini result was not successful";
+}
+function message(event, state) {
+    if (event["role"] === "user")
+        state.continuing = false;
+    if (event["role"] !== "assistant")
+        return [];
+    const content = text(event["content"]);
+    state.message =
+        state.continuing && event["delta"] === true
+            ? state.message + content
+            : content;
+    state.continuing = true;
+    return [
+        JSON.stringify({
+            type: "assistant",
+            message: { content: [{ type: "text", text: content }] },
+        }),
+    ];
+}
+function toolUse(event) {
+    return [
+        JSON.stringify({
+            type: "assistant",
+            message: {
+                content: [
+                    {
+                        type: "tool_use",
+                        name: text(event["tool_name"]),
+                        input: record(event["parameters"]) ?? {},
+                    },
+                ],
+            },
+        }),
+    ];
+}
+function received(event, state) {
+    if (event["severity"] === "error")
+        state.failure = text(event["message"]) || "Gemini error";
+    switch (event["type"]) {
+        case "init":
+            state.model = text(event["model"]) || null;
+            state.sessionId = text(event["session_id"]) || null;
+            break;
+        case "result":
+            completed(event, state);
+            break;
+        case "message":
+            return message(event, state);
+        case "tool_use":
+            state.continuing = false;
+            return toolUse(event);
+        case "tool_result":
+            state.continuing = false;
+    }
+    return [];
+}
+export function geminiStream() {
+    const state = {
+        model: null,
+        sessionId: null,
+        message: "",
+        continuing: false,
+        success: false,
+        failure: null,
+        models: undefined,
+        usage: usageOf(null),
+    };
+    return {
+        line: (line) => received(parsed(line), state),
+        result: (exitCode) => {
+            const success = exitCode === 0 && state.success && state.failure === null;
+            return JSON.stringify({
+                type: "result",
+                is_error: !success,
+                result: success
+                    ? state.message
+                    : (state.failure ??
+                        `gemini ended with code ${String(exitCode)} without a successful result`),
+                model: state.model,
+                session_id: state.sessionId,
+                usage: state.usage,
+                models: state.models,
+            });
+        },
+    };
+}

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;