cloving 1.2.0 → 1.4.0

package/dist/src/configuration-change.js

@@ -0,0 +1,76 @@
+import { configuration, settingScope, validateSetting, } from "./configuration-schema.js";
+import { configurationValues, parseConfiguration } from "./project-settings.js";
+import { record } from "./protocol.js";
+export function selectedHarnessConfiguration(contents, selection) {
+    const previous = parseConfiguration(contents, "private");
+    const harness = previous.harness;
+    const same = harness?.name === selection.name &&
+        harness.kind === selection.kind &&
+        harness.path === selection.path;
+    const next = {
+        version: 1,
+        ...previous,
+        harness: { ...(same ? harness : {}), ...selection },
+    };
+    configuration(next, "private");
+    return JSON.stringify(next, null, 2) + "\n";
+}
+function isJsonValue(value) {
+    if (value === null || typeof value === "boolean" || typeof value === "string")
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.every(isJsonValue);
+    const object = record(value);
+    return object !== undefined && Object.values(object).every(isJsonValue);
+}
+export function settingValue(text) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+    if (!isJsonValue(value))
+        throw new Error("invalid-setting-value");
+    return value;
+}
+function trimHarness(root, field) {
+    const order = ["harness.name", "harness.kind", "harness.path"];
+    const index = order.indexOf(field);
+    const harness = record(root["harness"]);
+    if (index < 0 || harness === undefined)
+        return;
+    const names = ["name", "kind", "path"].slice(0, index + 1);
+    root["harness"] = Object.fromEntries(Object.entries(harness).filter(([name]) => names.includes(name)));
+}
+function assign(root, change) {
+    const [name = "", ...tail] = change.field.split(".");
+    if (tail.length === 0 && change.action === "unset")
+        return Object.fromEntries(Object.entries(root).filter(([key]) => key !== name));
+    if (tail.length === 0)
+        return { ...root, [name]: settingValue(change.value ?? "") };
+    const child = assign({ ...record(root[name]) }, { ...change, field: tail.join(".") });
+    if (Object.keys(child).length === 0)
+        return Object.fromEntries(Object.entries(root).filter(([key]) => key !== name));
+    return { ...root, [name]: child };
+}
+export function changedConfiguration(contents, change) {
+    settingScope(change.field);
+    if (change.action === "set")
+        validateSetting(change.field, settingValue(change.value ?? ""));
+    const previous = parseConfiguration(contents, change.scope);
+    const root = {
+        version: 1,
+        ...previous,
+    };
+    if (change.action === "unset" ||
+        configurationValues(previous)[change.field] !==
+            settingValue(change.value ?? ""))
+        trimHarness(root, change.field);
+    const next = assign(root, change);
+    configuration(next, change.scope);
+    return JSON.stringify(next, null, 2) + "\n";
+}

package/dist/src/configuration-display.d.ts

@@ -0,0 +1,21 @@
+import { type SettingValue } from "./project-settings.ts";
+import { type JsonValue } from "./configuration-change.ts";
+import type { TurnProfiles } from "./turn-profile.ts";
+type Source = "environment" | "private" | "project" | "default";
+type DisplayValue = SettingValue | JsonValue;
+interface ValueSource {
+    readonly value: DisplayValue;
+    readonly source: Source;
+}
+export interface SettingEntry extends ValueSource {
+    readonly field: string;
+    readonly hidden: readonly ValueSource[];
+}
+export declare function configurationEntries(input: {
+    readonly project: string | undefined;
+    readonly private: string | undefined;
+    readonly environment: Readonly<NodeJS.ProcessEnv>;
+    readonly field?: string;
+    readonly profiles?: TurnProfiles;
+}): readonly SettingEntry[];
+export {};

package/dist/src/configuration-display.js

@@ -0,0 +1,69 @@
+import { settingFields, settingScope } from "./configuration-schema.js";
+import { configurationValues, parseConfiguration, settingVariables, } from "./project-settings.js";
+import { settingValue } from "./configuration-change.js";
+import { harnessDefaults, nativeHarness } from "./harness-defaults.js";
+import { builtInPriceTable, parseTokenPrices } from "./token-prices.js";
+const defaults = {
+    "queue.lanes": 1,
+    "harness.name": "claude",
+    "harness.output": "text",
+    tokenPrices: builtInPriceTable.prices,
+    fallbackModels: [],
+    profiles: {},
+    "watch.port": 3663,
+    "watch.actions": "on",
+    "github.command": ["gh"],
+};
+function effectiveValue(setting) {
+    const { field, value } = setting;
+    if (field === "tokenPrices")
+        return parseTokenPrices(JSON.stringify(value));
+    return value;
+}
+export function configurationEntries(input) {
+    const project = configurationValues(parseConfiguration(input.project, "project"));
+    const privateFile = configurationValues(parseConfiguration(input.private, "private"));
+    const name = input.environment["CLOVING_WORKER"] ?? privateFile["harness.name"];
+    const harness = typeof name === "string" && !nativeHarness(name)
+        ? undefined
+        : harnessDefaults(name);
+    const environment = Object.fromEntries(Object.entries({
+        ...settingVariables,
+        profiles: "CLOVING_PROFILES",
+        ...(harness?.variable === undefined
+            ? {}
+            : { "harness.command": harness.variable }),
+    }).flatMap(([field, variable]) => {
+        const value = input.environment[variable];
+        return value === undefined ? [] : [[field, settingValue(value)]];
+    }));
+    if (input.profiles !== undefined)
+        environment["profiles"] = input.profiles;
+    const effectiveDefaults = {
+        ...defaults,
+        ...(harness === undefined ? {} : { "harness.command": harness.command }),
+    };
+    const fields = input.field === undefined ? settingFields() : [input.field];
+    const layers = [
+        ["environment", environment],
+        ["private", privateFile],
+        ["project", project],
+    ];
+    return fields.map((field) => {
+        settingScope(field);
+        const [effective, ...hidden] = layers.flatMap(([source, values]) => {
+            const value = values[field];
+            return value === undefined ? [] : [{ source, value }];
+        });
+        const selected = effective ?? {
+            source: "default",
+            value: effectiveDefaults[field] ?? null,
+        };
+        return {
+            field,
+            ...selected,
+            value: effectiveValue({ field, value: selected.value }),
+            hidden,
+        };
+    });
+}

package/dist/src/configuration-schema.d.ts

@@ -0,0 +1,58 @@
+import type { TurnProfiles } from "./turn-profile.ts";
+import type { TokenPrices } from "./token-prices.ts";
+export interface RedGreenSettings {
+    readonly test: readonly string[];
+    readonly testFiles: readonly string[];
+    readonly prepare?: readonly string[];
+    readonly assertionPattern?: string;
+    readonly skipPattern?: string;
+}
+export interface Configuration {
+    readonly version: 1;
+    readonly checks?: {
+        readonly beforeMerge?: readonly string[];
+        readonly required?: readonly string[];
+        readonly redGreen?: RedGreenSettings;
+    };
+    readonly tickets?: {
+        readonly command?: readonly string[];
+        readonly nextCommand?: readonly string[];
+    };
+    readonly queue?: {
+        readonly everySeconds?: number;
+        readonly lanes?: number;
+        readonly dailySpendLimitUsd?: number;
+    };
+    readonly harness?: {
+        readonly name?: string;
+        readonly turn?: readonly string[];
+        readonly output?: "text";
+        readonly kind?: "file" | "shell";
+        readonly path?: string;
+        readonly command?: readonly string[];
+    };
+    readonly profiles?: TurnProfiles;
+    readonly fallbackModels?: readonly string[];
+    readonly tokenPrices?: TokenPrices;
+    readonly privateTexts?: readonly string[];
+    readonly notify?: {
+        readonly command?: readonly string[];
+    };
+    readonly watch?: {
+        readonly port?: number | "off";
+        readonly actions?: "on" | "off";
+    };
+    readonly selfUpdate?: {
+        readonly everySeconds?: number;
+    };
+    readonly github?: {
+        readonly command?: readonly string[];
+    };
+    readonly workflows?: {
+        readonly folder?: string;
+    };
+}
+export declare function configuration(value: unknown, scope: "project" | "private"): Configuration;
+export declare function settingScope(field: string): "project" | "private";
+export declare function validateSetting(field: string, value: unknown): void;
+export declare function settingFields(): readonly string[];

package/dist/src/configuration-schema.js

@@ -0,0 +1,163 @@
+import project from "./project-config.schema.json" with { type: "json" };
+import privateConfig from "./private-config.schema.json" with { type: "json" };
+import { record } from "./protocol.js";
+import { isTurnCommand } from "./harness-defaults.js";
+const schemas = {
+    project,
+    private: privateConfig,
+};
+function invalid(field) {
+    throw new Error(`invalid-setting: ${field}`);
+}
+function text(value, { schema, field }) {
+    if (typeof value !== "string")
+        invalid(field);
+    if (schema.pattern !== undefined && !new RegExp(schema.pattern).test(value))
+        invalid(field);
+}
+function number(value, { schema, field }) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        invalid(field);
+    if (schema.type === "integer" && !Number.isInteger(value))
+        invalid(field);
+    bounds(value, { schema, field });
+}
+function bounds(value, { schema, field }) {
+    if (schema.minimum !== undefined && value < schema.minimum)
+        invalid(field);
+    if (schema.maximum !== undefined && value > schema.maximum)
+        invalid(field);
+    if (schema.exclusiveMinimum !== undefined && value <= schema.exclusiveMinimum)
+        invalid(field);
+}
+function scalar(value, checked) {
+    const { schema, field } = checked;
+    if (field === "harness.turn" && !isTurnCommand(value))
+        invalid(field);
+    if ("const" in schema && value !== schema.const)
+        invalid(field);
+    if (schema.enum !== undefined && !schema.enum.includes(value))
+        invalid(field);
+    if (schema.type === "string")
+        text(value, checked);
+    if (schema.type === "number" || schema.type === "integer")
+        number(value, checked);
+}
+function childSchema(name, { schema, field }) {
+    const properties = schema.properties ?? {};
+    const child = Object.hasOwn(properties, name)
+        ? properties[name]
+        : schema.additionalProperties;
+    if (child === false || child === undefined)
+        throw new Error(`unknown-setting: ${field}`);
+    if (schema.propertyNames !== undefined &&
+        !new RegExp(schema.propertyNames.pattern).test(name))
+        invalid(field);
+    return child;
+}
+function validateObject(value, { schema, field }) {
+    const object = record(value);
+    if (object === undefined)
+        invalid(field);
+    for (const required of schema.required ?? [])
+        if (!Object.hasOwn(object, required))
+            invalid(`${field}.${required}`);
+    for (const [name, item] of Object.entries(object)) {
+        const path = field === "" ? name : `${field}.${name}`;
+        const child = childSchema(name, { schema, field: path });
+        if (typeof child === "object")
+            validate(item, { schema: child, field: path });
+    }
+}
+function matches(value, schema) {
+    try {
+        validate(value, { schema, field: "" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function validate(value, checked) {
+    const { schema, field } = checked;
+    if (schema.anyOf !== undefined) {
+        if (!schema.anyOf.some((option) => matches(value, option)))
+            invalid(field);
+        return;
+    }
+    scalar(value, checked);
+    if (schema.type === "object")
+        validateObject(value, checked);
+    if (schema.type === "array")
+        validateArray(value, checked);
+}
+function validateArray(value, { schema, field }) {
+    if (!Array.isArray(value))
+        invalid(field);
+    if (schema.maxItems !== undefined && value.length > schema.maxItems)
+        invalid(field);
+    if (schema.minItems !== undefined && value.length < schema.minItems)
+        invalid(field);
+    if (schema.items === undefined)
+        return;
+    for (const [index, item] of value.entries())
+        validate(item, {
+            schema: schema.items,
+            field: `${field}.${String(index)}`,
+        });
+}
+function validateConfiguration(value, scope) {
+    const object = record(value);
+    if (object === undefined)
+        invalid("$");
+    if (object["version"] !== 1)
+        throw new Error("unsupported-config-version: version");
+    if (scope === "project") {
+        for (const field of Object.keys(object))
+            if (Object.hasOwn(privateConfig.properties, field) &&
+                !Object.hasOwn(project.properties, field))
+                throw new Error(`private-setting-in-project-file: ${field}`);
+    }
+    validate(object, { schema: schemas[scope] ?? {}, field: "" });
+}
+export function configuration(value, scope) {
+    validateConfiguration(value, scope);
+    return value;
+}
+export function settingScope(field) {
+    fieldSchema(field);
+    const root = field.split(".")[0] ?? "";
+    return Object.hasOwn(project.properties, root) ? "project" : "private";
+}
+function fieldSchema(field) {
+    if (!settingFields().includes(field))
+        throw new Error(`unknown-setting: ${field}`);
+    let schema = privateConfig;
+    for (const name of field.split(".")) {
+        if (schema.type !== "object")
+            throw new Error(`unknown-setting: ${field}`);
+        const child = childSchema(name, { schema, field });
+        if (typeof child !== "object")
+            throw new Error(`unknown-setting: ${field}`);
+        schema = child;
+    }
+    return schema;
+}
+export function validateSetting(field, value) {
+    const schema = fieldSchema(field);
+    if (schema.minimum !== undefined &&
+        schema.maximum !== undefined &&
+        typeof value === "number" &&
+        (value < schema.minimum || value > schema.maximum))
+        throw new Error(`invalid-setting: ${field} must be from ${String(schema.minimum)} to ${String(schema.maximum)}`);
+    validate(value, { schema, field });
+}
+export function settingFields() {
+    return Object.entries(privateConfig.properties).flatMap(([name, schema]) => {
+        if (name === "version")
+            return [];
+        return "properties" in schema
+            ? Object.keys(schema.properties).map((child) => `${name}.${child}`)
+            : [name];
+    });
+}

package/dist/src/daemon/attachment-file.d.ts

@@ -0,0 +1,6 @@
+import { type FileHandle } from "node:fs/promises";
+export declare function openedAttachment(place: {
+    readonly folder: string;
+    readonly name: string;
+}): Promise<FileHandle>;
+export declare function copiedAttachment(handle: FileHandle, copy: string): Promise<void>;

package/dist/src/daemon/attachment-file.js

@@ -0,0 +1,86 @@
+import { constants } from "node:fs";
+import { lstat, open, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+const maximumBytes = 104_857_600;
+const chunkBytes = 1_048_576;
+const pngSignature = Buffer.from([
+    0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+]);
+const webmSignature = Buffer.from([0x1a, 0x45, 0xdf, 0xa3]);
+const signatures = new Map([
+    ["mp4", (head) => head.subarray(4, 8).toString("latin1") === "ftyp"],
+    ["webm", (head) => head.subarray(0, 4).equals(webmSignature)],
+    ["png", (head) => head.subarray(0, 8).equals(pngSignature)],
+]);
+function listedStatus(path) {
+    return lstat(path).catch(() => undefined);
+}
+async function realFolder(path) {
+    const status = await listedStatus(path);
+    return (status !== undefined && status.isDirectory() && !status.isSymbolicLink());
+}
+async function realFolders(folder) {
+    return (await realFolder(dirname(folder))) && (await realFolder(folder));
+}
+function sameFile(opened, listed) {
+    return (listed !== undefined &&
+        listed.isFile() &&
+        listed.ino === opened.ino &&
+        listed.dev === opened.dev);
+}
+async function signed(handle, name) {
+    const head = Buffer.alloc(8);
+    const { bytesRead } = await handle.read(head, 0, 8, 0);
+    const check = signatures.get(name.slice(name.lastIndexOf(".") + 1));
+    return bytesRead === 8 && check !== undefined && check(head);
+}
+async function checkedHandle(handle, place) {
+    const opened = await handle.stat();
+    const listed = await listedStatus(join(place.folder, place.name));
+    if (!opened.isFile() || opened.nlink !== 1 || !sameFile(opened, listed))
+        throw new Error("attachment-not-available");
+    if (!(await realFolders(place.folder)))
+        throw new Error("attachment-not-available");
+    if (opened.size > maximumBytes)
+        throw new Error("attachment-too-large");
+    if (!(await signed(handle, place.name)))
+        throw new Error("attachment-not-available");
+}
+export async function openedAttachment(place) {
+    if (!(await realFolders(place.folder)))
+        throw new Error("attachment-not-available");
+    const handle = await open(join(place.folder, place.name), constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK).catch(() => undefined);
+    if (handle === undefined)
+        throw new Error("attachment-not-available");
+    try {
+        await checkedHandle(handle, place);
+        return handle;
+    }
+    catch (error) {
+        await handle.close();
+        throw error;
+    }
+}
+async function copiedChunks(source, target) {
+    const chunk = Buffer.alloc(chunkBytes);
+    let position = 0;
+    for (;;) {
+        const { bytesRead } = await source.read(chunk, 0, chunkBytes, position);
+        if (bytesRead === 0)
+            return;
+        position += bytesRead;
+        if (position > maximumBytes)
+            throw new Error("attachment-too-large");
+        await target.write(chunk, 0, bytesRead);
+    }
+}
+export async function copiedAttachment(handle, copy) {
+    await rm(copy, { force: true });
+    const target = await open(copy, "wx");
+    try {
+        await copiedChunks(handle, target);
+    }
+    finally {
+        await target.close();
+    }
+}

package/dist/src/daemon/attachments.d.ts

@@ -0,0 +1,14 @@
+export declare function attachmentFolder(place: {
+    readonly worktrees: string;
+    readonly target: string;
+}): string;
+export declare function attachmentEnvironment(settings: {
+    readonly worktrees: string;
+}, start: {
+    readonly intent: {
+        readonly target: string;
+    };
+    readonly profile: {
+        readonly env?: Readonly<Record<string, string>>;
+    };
+}): Promise<Readonly<Record<string, string>>>;

package/dist/src/daemon/attachments.js

@@ -0,0 +1,17 @@
+import { mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { treeName } from "./work-tree.js";
+export function attachmentFolder(place) {
+    return join(dirname(place.worktrees), "attachments", treeName(place.target));
+}
+export async function attachmentEnvironment(settings, start) {
+    const attachments = attachmentFolder({
+        worktrees: settings.worktrees,
+        target: start.intent.target,
+    });
+    await mkdir(attachments, { recursive: true });
+    return {
+        ...(start.profile.env ?? {}),
+        CLOVING_ATTACHMENTS_DIRECTORY: attachments,
+    };
+}

package/dist/src/daemon/claude-recovery.d.ts

@@ -0,0 +1,50 @@
+import type { TurnEnd } from "./claude-turn.ts";
+import { type Located, type WorkerReport } from "./operation-journal.ts";
+import type { WorkTree } from "./work-tree.ts";
+import { type WorkerProfiles } from "./worker-profile.ts";
+import type { AdapterOutcome, DeliveryIntent, ProtectedIntent } from "../broker/actor/delivery-intents.ts";
+export interface TurnResume {
+    readonly startedAt: string;
+    readonly turnStartCommit: string | null;
+    readonly sessionId: string;
+    readonly ends: readonly TurnEnd[];
+}
+export declare const resumePrompt = "This turn stopped because the Cloving daemon restarted. Continue the task from the point where it stopped. Run again each command or subagent that did not end. End with the result line that the task asks for.";
+export declare function turnIntent(intent: DeliveryIntent): intent is ProtectedIntent;
+export declare function resumableHarness(harness: unknown): boolean;
+export declare function resumedCommand(request: {
+    readonly worker: string | undefined;
+    readonly command: readonly string[];
+    readonly sessionId: string;
+}): readonly string[] | undefined;
+export declare function recordedField(value: unknown, name: string): unknown;
+export declare function processAlive(processId: unknown): boolean;
+export declare function uncertainProcess(started: unknown): Promise<boolean>;
+export declare function recordedTree(started: unknown): WorkTree | undefined;
+export declare function resumePlan(settings: WorkerProfiles & {
+    readonly stopMilliseconds?: number;
+}, request: {
+    readonly folder: string;
+    readonly started: unknown;
+    readonly intent: ProtectedIntent;
+    readonly signal: AbortSignal;
+}): Promise<"worktree-index-unknown" | "worktree-index-locked" | "claude-turn-interrupted" | {
+    resume: TurnResume;
+    tree: WorkTree;
+    profile: import("../turn-profile.ts").TurnProfile;
+    harness: {
+        readonly worker: string;
+        readonly command: readonly string[];
+        readonly shell?: string;
+        readonly output?: "text";
+    };
+}>;
+export declare function readResume(folder: string, started: unknown): Promise<TurnResume | undefined>;
+export declare function recordedHarness(journal: string, operationId: string): Promise<string | undefined>;
+export declare function interruptedReply(place: Located, reason: string): Promise<AdapterOutcome>;
+export declare function recoverTurn(operation: {
+    readonly intent: ProtectedIntent;
+    readonly journal: string;
+    readonly report: (report: WorkerReport) => Promise<unknown>;
+    readonly signal: AbortSignal;
+}, reconcile: () => Promise<AdapterOutcome>): Promise<void>;