cloving 0.3.20 → 1.1.0

package/dist/src/cli/client.js

@@ -0,0 +1,159 @@
+import net from "node:net";
+import { join } from "node:path";
+import { socketAddress } from "../broker/socket-address.js";
+import { parseReplyLine, record, requestLine, } from "../protocol.js";
+const mutations = ["run", "decision", "run-command"];
+function unavailable(runtimeDirectory) {
+    return {
+        kind: "error",
+        error: {
+            code: "service-unavailable",
+            detail: `No Cloving service answers in ${runtimeDirectory}. Start the service, or set CLOVING_RUNTIME_DIR to its runtime directory.`,
+        },
+    };
+}
+function refused(runtimeDirectory) {
+    return {
+        kind: "error",
+        error: {
+            code: "permission-denied",
+            detail: `The service socket in ${runtimeDirectory} refused this account.`,
+        },
+    };
+}
+function lost(request, runtimeDirectory) {
+    if (!mutations.includes(request.operation))
+        return unavailable(runtimeDirectory);
+    return {
+        kind: "error",
+        error: {
+            code: "outcome-unknown",
+            detail: "The connection ended before the reply. Send the command again with the same command ID.",
+        },
+    };
+}
+function exchange(context) {
+    const { runtimeDirectory, request, onEvent, interruption } = context;
+    const address = socketAddress(join(runtimeDirectory, "control.sock"));
+    if (address.kind === "refused")
+        return Promise.resolve({
+            kind: "error",
+            error: { code: address.reason, detail: address.detail },
+        });
+    return new Promise((settle) => {
+        const socket = net.connect(address.path);
+        let buffered = "";
+        let written = false;
+        socket.setEncoding("utf8");
+        socket.on("connect", () => {
+            socket.write(requestLine(request), () => {
+                written = true;
+            });
+        });
+        socket.on("data", (data) => {
+            buffered += data;
+            const lines = buffered.split("\n");
+            buffered = lines.pop() ?? "";
+            for (const line of lines) {
+                const parsed = parseReplyLine(line);
+                if (parsed?.kind === "event")
+                    onEvent(parsed.event);
+                if (parsed?.kind === "result" || parsed?.kind === "error") {
+                    settle(parsed);
+                    socket.destroy();
+                }
+            }
+        });
+        const stopped = (reply) => () => {
+            settle(reply);
+            socket.destroy();
+        };
+        if (interruption !== undefined)
+            interruption.signal.then(stopped(interruption.reply), stopped(interruption.reply));
+        const ended = (code) => {
+            if (code === "EACCES")
+                return refused(runtimeDirectory);
+            return written
+                ? lost(request, runtimeDirectory)
+                : unavailable(runtimeDirectory);
+        };
+        socket.on("error", (error) => {
+            settle(ended(Reflect.get(error, "code")));
+        });
+        socket.on("close", () => {
+            settle(ended(undefined));
+        });
+    });
+}
+const unobserved = () => undefined;
+export function send(runtimeDirectory, request) {
+    return exchange({ runtimeDirectory, request, onEvent: unobserved });
+}
+function listedRuns(result) {
+    const runs = result["runs"];
+    return Array.isArray(runs)
+        ? runs.map(record).filter((run) => run !== undefined)
+        : [];
+}
+export async function listRuns(runtimeDirectory) {
+    const first = await send(runtimeDirectory, {
+        operation: "status",
+        parameters: { limit: 500 },
+    });
+    if (first.kind === "error")
+        return first;
+    const runs = listedRuns(first.result);
+    let next = first.result["next"];
+    let after = "";
+    while (typeof next === "string") {
+        if (next <= after)
+            return {
+                kind: "error",
+                error: {
+                    code: "invalid-run-page",
+                    detail: "The run-list cursor did not advance.",
+                },
+            };
+        after = next;
+        const page = await send(runtimeDirectory, {
+            operation: "status",
+            parameters: { limit: 500, after },
+        });
+        if (page.kind === "error")
+            return page;
+        runs.push(...listedRuns(page.result));
+        next = page.result["next"];
+    }
+    return { kind: "result", result: { ...first.result, runs, next: null } };
+}
+export function mutate(runtimeDirectory, mutation) {
+    return exchange({
+        runtimeDirectory,
+        request: mutation.request,
+        onEvent: unobserved,
+        interruption: {
+            signal: mutation.signal,
+            reply: {
+                kind: "error",
+                error: {
+                    code: "outcome-unknown",
+                    detail: "A signal ended the command before the reply. Send the command again with the same command ID.",
+                },
+            },
+        },
+    });
+}
+export function follow(runtimeDirectory, stream) {
+    return exchange({
+        runtimeDirectory,
+        request: stream.request,
+        onEvent: stream.onEvent,
+        interruption: {
+            signal: stream.signal,
+            reply: {
+                kind: "result",
+                result: { schemaVersion: 1, kind: "event-page", events: [] },
+            },
+        },
+    });
+}

package/dist/src/cli/commands.d.ts

@@ -0,0 +1,17 @@
+import type { WatchPrSettings } from "./watch-pr-settings.ts";
+import type { RuntimeInvocation } from "./runtime-arguments.ts";
+export interface Terminal {
+    readonly out: (text: string) => void;
+    readonly error: (text: string) => void;
+}
+export interface CommandEnvironment {
+    readonly runtimeDirectory: string | undefined;
+    readonly watchActions?: string;
+    readonly watchPr?: WatchPrSettings;
+    readonly client?: string;
+    readonly workingDirectory: string;
+    readonly terminal: Terminal;
+    readonly identifier: () => string;
+    readonly interrupted: () => Promise<void>;
+}
+export declare function runtimeCommand(invocation: RuntimeInvocation, environment: CommandEnvironment): Promise<number>;

package/dist/src/cli/commands.js

@@ -0,0 +1,271 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { record, } from "../protocol.js";
+import { follow, listRuns, mutate, send } from "./client.js";
+import { errorText, eventText, pendingSummary, rendered, runOverview, statusJson, } from "./render.js";
+import { commandUsage } from "./usage.js";
+import { defaultWatchPort, watchServer } from "./watch-server.js";
+function errorObject(error, format) {
+    if (error.code === "event-gap")
+        return {
+            schemaVersion: 1,
+            kind: "event-gap",
+            after: error["after"],
+            earliestAvailable: error["earliestAvailable"],
+            latestSequence: error["latestSequence"],
+        };
+    return {
+        schemaVersion: 1,
+        kind: "error",
+        ...error,
+        commandId: error["commandId"] ?? format.commandId ?? null,
+        runId: error["runId"] ?? null,
+        currentRevision: error["currentRevision"] ?? null,
+    };
+}
+function failed(environment, failure) {
+    const { terminal } = environment;
+    const shown = errorObject(failure.error, failure.format);
+    if (failure.format.json) {
+        terminal.out(`${JSON.stringify(shown)}\n`);
+        return 1;
+    }
+    terminal.error(errorText(failure.error));
+    if (typeof shown["commandId"] === "string" && !failure.format.announced)
+        terminal.error(`Command ID: ${shown["commandId"]}\n`);
+    return 1;
+}
+function presented(environment, outcome) {
+    const { reply, format } = outcome;
+    if (reply.kind === "error")
+        return failed(environment, { error: reply.error, format });
+    environment.terminal.out(format.json
+        ? `${JSON.stringify(statusJson(reply.result))}\n`
+        : rendered(reply.result));
+    return 0;
+}
+async function requested(environment, exchange) {
+    return presented(environment, {
+        reply: await send(environment.runtimeDirectory, exchange.request),
+        format: exchange.format,
+    });
+}
+async function mutated(environment, exchange) {
+    return presented(environment, {
+        reply: await mutate(environment.runtimeDirectory, {
+            request: exchange.request,
+            signal: environment.interrupted(),
+        }),
+        format: exchange.format,
+    });
+}
+function identified(environment, invocation) {
+    const { json } = invocation;
+    if (invocation.commandId !== null)
+        return { json, commandId: invocation.commandId, announced: false };
+    const commandId = environment.identifier();
+    if (!json)
+        environment.terminal.error(`Command ID: ${commandId}\n`);
+    return { json, commandId, announced: !json };
+}
+async function inputFile(environment, file) {
+    let text;
+    try {
+        text = await readFile(resolve(environment.workingDirectory, file), "utf8");
+    }
+    catch {
+        return {
+            kind: "error",
+            error: {
+                code: "unreadable-input",
+                detail: `The input file ${file} is not readable.`,
+            },
+        };
+    }
+    try {
+        return { kind: "read", submission: JSON.parse(text) };
+    }
+    catch {
+        return {
+            kind: "error",
+            error: {
+                code: "malformed-input",
+                detail: `The input file ${file} is not JSON.`,
+            },
+        };
+    }
+}
+function typed(source) {
+    return source.kind === "prompt"
+        ? { prompt: source.text }
+        : { ticket: source.id };
+}
+async function run(environment, invocation) {
+    const format = identified(environment, invocation);
+    const { commandId } = format;
+    const { source } = invocation;
+    const read = source.kind === "input"
+        ? await inputFile(environment, source.file)
+        : { kind: "read", submission: typed(source) };
+    if (read.kind === "error")
+        return failed(environment, { error: read.error, format });
+    return mutated(environment, {
+        format,
+        request: {
+            operation: "run",
+            parameters: {
+                workflowId: invocation.workflowId,
+                source: source.kind,
+                submission: read.submission,
+                commandId,
+            },
+        },
+    });
+}
+function present(values) {
+    return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== null));
+}
+async function summarized(environment) {
+    const pending = await send(environment.runtimeDirectory, {
+        operation: "questions",
+        parameters: {},
+    });
+    if (pending.kind === "result")
+        environment.terminal.out(pendingSummary(pending.result));
+}
+async function status(environment, invocation) {
+    const { runId, limit, after, json } = invocation;
+    if (!json && runId === null)
+        await summarized(environment);
+    if (!json && runId === null && limit === null && after === null) {
+        const reply = await listRuns(environment.runtimeDirectory);
+        return presented(environment, {
+            format: { json },
+            reply: reply.kind === "result"
+                ? { kind: "result", result: runOverview(reply.result) }
+                : reply,
+        });
+    }
+    return requested(environment, {
+        format: { json },
+        request: {
+            operation: "status",
+            parameters: present({ runId, limit, after }),
+        },
+    });
+}
+function decision(environment, invocation) {
+    const format = identified(environment, invocation);
+    const { commandId } = format;
+    return mutated(environment, {
+        format,
+        request: {
+            operation: "decision",
+            parameters: present({
+                command: invocation.command,
+                reference: invocation.reference,
+                text: invocation.text,
+                expectedRevision: invocation.expectedRevision,
+                generation: invocation.generation,
+                subjectDigest: invocation.subjectDigest,
+                commandId,
+            }),
+        },
+    });
+}
+function runCommand(environment, invocation) {
+    const format = identified(environment, invocation);
+    const { commandId } = format;
+    return mutated(environment, {
+        format,
+        request: {
+            operation: "run-command",
+            parameters: {
+                command: invocation.command,
+                runId: invocation.runId,
+                expectedRevision: invocation.expectedRevision,
+                commandId,
+            },
+        },
+    });
+}
+async function events(environment, invocation) {
+    const { json, follow: following } = invocation;
+    const { terminal } = environment;
+    const print = (event) => {
+        terminal.out(json ? `${JSON.stringify(event)}\n` : `${eventText(event)}\n`);
+    };
+    const request = {
+        operation: "events",
+        parameters: present({
+            runId: invocation.runId,
+            after: invocation.after,
+            limit: invocation.limit,
+            follow: following,
+        }),
+    };
+    const reply = following
+        ? await follow(environment.runtimeDirectory, {
+            request,
+            onEvent: print,
+            signal: environment.interrupted(),
+        })
+        : await send(environment.runtimeDirectory, request);
+    if (reply.kind === "error")
+        return failed(environment, { error: reply.error, format: { json } });
+    const page = reply.result["events"];
+    for (const event of Array.isArray(page) ? page : [])
+        print(record(event) ?? {});
+    return 0;
+}
+export function runtimeCommand(invocation, environment) {
+    if (invocation.kind === "command-help") {
+        environment.terminal.out(commandUsage[invocation.command] ?? "");
+        return Promise.resolve(0);
+    }
+    const { runtimeDirectory } = environment;
+    if (runtimeDirectory === undefined)
+        return Promise.resolve(failed(environment, {
+            error: {
+                code: "runtime-directory-unknown",
+                detail: "No runtime directory is known. Set CLOVING_RUNTIME_DIR to the runtime directory of the service.",
+            },
+            format: { json: invocation.json },
+        }));
+    return located(invocation, { ...environment, runtimeDirectory });
+}
+function located(invocation, environment) {
+    if (invocation.kind === "run")
+        return run(environment, invocation);
+    if (invocation.kind === "status")
+        return status(environment, invocation);
+    if (invocation.kind === "decision")
+        return decision(environment, invocation);
+    if (invocation.kind === "run-command")
+        return runCommand(environment, invocation);
+    if (invocation.kind === "events")
+        return events(environment, invocation);
+    if (invocation.kind === "watch")
+        return watch(environment, invocation);
+    return requested(environment, {
+        format: { json: invocation.json },
+        request: {
+            operation: "questions",
+            parameters: present({ runId: invocation.runId }),
+        },
+    });
+}
+function watch(environment, invocation) {
+    return watchServer({
+        actions: environment.watchActions ?? "on",
+        ...(environment.watchPr === undefined
+            ? {}
+            : { pullRequests: environment.watchPr }),
+        runtimeDirectory: environment.runtimeDirectory,
+        port: invocation.port ?? defaultWatchPort,
+        client: environment.client ?? "cloving",
+        announce: environment.terminal.out,
+        complain: environment.terminal.error,
+        stopped: environment.interrupted(),
+    });
+}

package/dist/src/cli/main.d.ts

@@ -0,0 +1,2 @@
+import type { WatchPrSettings } from "./watch-pr-settings.ts";
+export declare function main(argumentsList: readonly string[], watchPr?: WatchPrSettings): Promise<void>;

package/dist/src/cli/main.js

@@ -0,0 +1,127 @@
+import { randomUUID } from "node:crypto";
+import packageMetadata from "#package" with { type: "json" };
+import { redactImport } from "../chats/redact-import.js";
+import { emptyCounts } from "../chats/redaction.js";
+import { importChats } from "../chats/import.js";
+import { parseInvocation } from "./arguments.js";
+import { runtimeCommand } from "./commands.js";
+import { clientCommand, runtimeDirectory } from "./runtime-directory.js";
+import { chatsRedactUsage, chatsImportUsage, usage, validateUsage, } from "./usage.js";
+import { validateWorkflow } from "./validate.js";
+const helpTexts = {
+    help: usage,
+    version: `${packageMetadata.version}\n`,
+    "validate-help": validateUsage,
+    "chats-import-help": chatsImportUsage,
+    "chats-redact-help": chatsRedactUsage,
+};
+function helpInvocation(invocation) {
+    return Object.hasOwn(helpTexts, invocation.kind);
+}
+export async function main(argumentsList, watchPr) {
+    const invocation = parseInvocation(argumentsList);
+    if (refuseChatPlatform(invocation))
+        return;
+    if (helpInvocation(invocation)) {
+        process.stdout.write(helpTexts[invocation.kind]);
+        return;
+    }
+    if (invocation.kind === "usage-error") {
+        presentUsageError(invocation);
+    }
+    else if (invocation.kind === "validate") {
+        await validationCommand(invocation);
+    }
+    else if (invocation.kind === "chats-redact") {
+        await redactionCommand(invocation.importId);
+    }
+    else if (invocation.kind === "chats-import") {
+        const result = await importChats({
+            ...invocation,
+            workingDirectory: process.cwd(),
+            runtimeDirectory: runtimeDirectory(process.env),
+        });
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+        process.exitCode = result.code === "import-complete" ? 0 : 1;
+    }
+    else {
+        process.exitCode = await runtimeCommand(invocation, {
+            runtimeDirectory: runtimeDirectory(process.env),
+            ...(process.env["CLOVING_WATCH_ACTIONS"] === undefined
+                ? {}
+                : { watchActions: process.env["CLOVING_WATCH_ACTIONS"] }),
+            ...(watchPr === undefined ? {} : { watchPr }),
+            client: clientCommand(process.env),
+            workingDirectory: process.cwd(),
+            terminal: {
+                out: (text) => process.stdout.write(text),
+                error: (text) => process.stderr.write(text),
+            },
+            identifier: randomUUID,
+            interrupted: () => new Promise((settle) => {
+                for (const signal of ["SIGINT", "SIGTERM"])
+                    process.once(signal, () => {
+                        settle();
+                    });
+            }),
+        });
+    }
+}
+function refuseChatPlatform(invocation) {
+    if (process.platform === "darwin")
+        return false;
+    if (invocation.kind !== "chats-import" && invocation.kind !== "chats-redact")
+        return false;
+    process.stdout.write(`${JSON.stringify({ code: "platform-unsupported" })}\n`);
+    process.stderr.write("platform-unsupported: Chat commands require macOS.\n");
+    process.exitCode = 1;
+    return true;
+}
+function presentUsageError(invocation) {
+    if (invocation.json)
+        process.stdout.write(`${JSON.stringify({ schemaVersion: 1, kind: "usage-error", code: invocation.code })}\n`);
+    else
+        process.stderr.write(`${invocation.code}: run cloving --help for usage.\n`);
+    process.exitCode = 2;
+}
+async function validationCommand(invocation) {
+    const report = await validateWorkflow(process.cwd(), invocation);
+    present(report, invocation.json ? "json" : "human");
+    process.exitCode = report.status === "valid" ? 0 : 1;
+}
+function present(report, format) {
+    if (format === "json") {
+        process.stdout.write(`${JSON.stringify(report)}\n`);
+        return;
+    }
+    if (report.status === "valid") {
+        process.stdout.write(`Workflow ${report.workflow.name} is valid.\nWorkflow ID: ${report.workflow.workflowId}\nPinned identity: ${report.pinnedIdentity}\n`);
+        return;
+    }
+    for (const error of report.errors)
+        process.stderr.write(`${error.code}: ${error.file}: ${error.detail}\n`);
+}
+async function redactionCommand(importId) {
+    let privateTexts = [];
+    try {
+        const setting = process.env["CLOVING_PRIVATE_TEXTS"];
+        if (setting !== undefined)
+            privateTexts = JSON.parse(setting);
+        if (!Array.isArray(privateTexts) ||
+            !privateTexts.every((item) => typeof item === "string" && item.trim() !== ""))
+            throw new Error("invalid-settings");
+    }
+    catch {
+        process.stdout.write(`${JSON.stringify({ code: "invalid-settings", importId, recordCount: 0, counts: emptyCounts(), totalCount: 0 })}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const result = await redactImport({
+        importId,
+        workingDirectory: process.cwd(),
+        runtimeDirectory: runtimeDirectory(process.env),
+        settings: { home: process.env["HOME"] || null, privateTexts },
+    });
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    process.exitCode = result.code === "redaction-complete" ? 0 : 1;
+}

package/dist/src/cli/render.d.ts

@@ -0,0 +1,10 @@
+import { type Fields } from "../protocol.ts";
+export declare function errorText(error: Fields): string;
+export declare function runOverview(result: Fields): Fields;
+export declare function statusJson(result: Fields): Fields;
+export declare function runStatus(result: Fields): readonly string[];
+export declare function decisionLines(decision: unknown): readonly string[];
+export declare function decisionList(result: Fields): readonly string[];
+export declare function eventText(event: Fields): string;
+export declare function rendered(result: Fields): string;
+export declare function pendingSummary(result: Fields): string;