cloving 1.2.0 → 1.4.0

package/dist/src/cli/commands.js

@@ -1,28 +1,14 @@
+import { commandJson, errorObject, readCommandReply, readCommandRequest, } from "./command-requests.js";
+import { reportCommand } from "./report.js";
+import { scheduleServiceRequest } from "./schedule-arguments.js";
+import { withCiReruns } from "./github-ci-progress.js";
 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 { errorText, eventText, pendingSummary, rendered, runOverview, } 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);
@@ -40,13 +26,14 @@ function presented(environment, outcome) {
     if (reply.kind === "error")
         return failed(environment, { error: reply.error, format });
     environment.terminal.out(format.json
-        ? `${JSON.stringify(statusJson(reply.result))}\n`
+        ? `${JSON.stringify(commandJson(reply))}\n`
         : rendered(reply.result));
     return 0;
 }
 async function requested(environment, exchange) {
+    const reply = await readCommandReply(environment.runtimeDirectory, exchange.request);
     return presented(environment, {
-        reply: await send(environment.runtimeDirectory, exchange.request),
+        reply,
         format: exchange.format,
     });
 }
@@ -138,7 +125,7 @@ async function status(environment, invocation) {
     if (!json && runId === null)
         await summarized(environment);
     if (!json && runId === null && limit === null && after === null) {
-        const reply = await listRuns(environment.runtimeDirectory);
+        const reply = await withCiReruns(environment.runtimeDirectory, await listRuns(environment.runtimeDirectory));
         return presented(environment, {
             format: { json },
             reply: reply.kind === "result"
@@ -148,10 +135,7 @@ async function status(environment, invocation) {
     }
     return requested(environment, {
         format: { json },
-        request: {
-            operation: "status",
-            parameters: present({ runId, limit, after }),
-        },
+        request: readCommandRequest(invocation),
     });
 }
 function decision(environment, invocation) {
@@ -195,15 +179,7 @@ async function events(environment, invocation) {
     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 request = readCommandRequest(invocation);
     const reply = following
         ? await follow(environment.runtimeDirectory, {
             request,
@@ -227,14 +203,21 @@ export function runtimeCommand(invocation, 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.",
+                code: "repository-unknown",
+                detail: "Change to the service repository, use --repository <directory>, or set CLOVING_RUNTIME_DIR.",
             },
             format: { json: invocation.json },
         }));
     return located(invocation, { ...environment, runtimeDirectory });
 }
 function located(invocation, environment) {
+    if (invocation.kind === "schedule")
+        return requested(environment, {
+            format: { json: invocation.json },
+            request: scheduleServiceRequest(invocation),
+        });
+    if (invocation.kind === "report")
+        return reportCommand(invocation, environment);
     if (invocation.kind === "run")
         return run(environment, invocation);
     if (invocation.kind === "status")
@@ -249,10 +232,7 @@ function located(invocation, environment) {
         return watch(environment, invocation);
     return requested(environment, {
         format: { json: invocation.json },
-        request: {
-            operation: "questions",
-            parameters: present({ runId: invocation.runId }),
-        },
+        request: readCommandRequest(invocation),
     });
 }
 function watch(environment, invocation) {

package/dist/src/cli/config-arguments.d.ts

@@ -0,0 +1,11 @@
+export interface ConfigInvocation {
+    readonly kind: "config";
+    readonly action: "list" | "get" | "set" | "unset";
+    readonly field?: string;
+    readonly value?: string;
+    readonly private: boolean;
+    readonly json: boolean;
+}
+export declare function configInvocation(argumentsList: readonly string[]): ConfigInvocation | {
+    readonly kind: "config-help";
+} | string;

package/dist/src/cli/config-arguments.js

@@ -0,0 +1,59 @@
+import { parseArgs } from "node:util";
+const argumentCounts = { list: 1, get: 2, set: 3, unset: 2 };
+function escapedValue(argumentsList) {
+    const flags = new Set(["--json", "--private", "--help", "-h"]);
+    const positionals = argumentsList
+        .map((value, index) => ({ value, index }))
+        .filter(({ value }) => !flags.has(value));
+    const [command, , value] = positionals;
+    if (command?.value !== "set" ||
+        value === undefined ||
+        !value.value.startsWith("-") ||
+        argumentsList.includes("--"))
+        return { argumentsList };
+    return {
+        argumentsList: argumentsList.map((item, index) => index === value.index ? "config-value" : item),
+        value: value.value,
+    };
+}
+function knownAction(value) {
+    return value !== undefined && Object.hasOwn(argumentCounts, value);
+}
+function mutation(action) {
+    return action === "set" || action === "unset";
+}
+export function configInvocation(argumentsList) {
+    try {
+        const escaped = escapedValue(argumentsList);
+        const { values, positionals } = parseArgs({
+            args: [...escaped.argumentsList],
+            options: {
+                private: { type: "boolean" },
+                json: { type: "boolean" },
+                help: { type: "boolean", short: "h" },
+            },
+            allowPositionals: true,
+        });
+        const [action, field, parsedValue] = positionals;
+        const value = escaped.value ?? parsedValue;
+        if (values.help)
+            return { kind: "config-help" };
+        if (!knownAction(action))
+            return "unknown-command";
+        if (positionals.length !== argumentCounts[action])
+            return "invalid-invocation";
+        if (values.private && !mutation(action))
+            return "unexpected-option";
+        return {
+            kind: "config",
+            action,
+            ...(field === undefined ? {} : { field }),
+            ...(value === undefined ? {} : { value }),
+            private: values.private === true,
+            json: values.json === true,
+        };
+    }
+    catch {
+        return "invalid-invocation";
+    }
+}

package/dist/src/cli/config-command.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigInvocation } from "./config-arguments.ts";
+export declare function configCommand(invocation: ConfigInvocation, repository: string | undefined): Promise<number>;

package/dist/src/cli/config-command.js

@@ -0,0 +1,105 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { settingScope, validateSetting } from "../configuration-schema.js";
+import { settingValue } from "../configuration-change.js";
+import { configurationEntries, } from "../configuration-display.js";
+import { isProfilesFile } from "../turn-profile.js";
+import { changeConfigFile, readConfigFile } from "./config-file.js";
+import { privateSettingsPath } from "./project-settings.js";
+import { configNotice } from "./config-notice.js";
+async function environmentProfiles() {
+    const path = process.env["CLOVING_PROFILES"];
+    if (path === undefined)
+        return undefined;
+    const value = JSON.parse(await readFile(path, "utf8"));
+    if (!isProfilesFile(value))
+        throw new Error("invalid-setting: profiles");
+    return value.profiles;
+}
+async function entries(repository, field) {
+    const [project, privateFile, profiles] = await Promise.all([
+        readConfigFile(join(repository, ".cloving/config.json")),
+        readConfigFile(privateSettingsPath(process.env, repository)),
+        environmentProfiles(),
+    ]);
+    return configurationEntries({
+        project,
+        private: privateFile,
+        environment: process.env,
+        ...(profiles === undefined ? {} : { profiles }),
+        ...(field === undefined ? {} : { field }),
+    });
+}
+function entryLine(entry) {
+    const hidden = entry.hidden
+        .map((item) => `; hidden ${item.source}: ${JSON.stringify(item.value)}`)
+        .join("");
+    return `${entry.field} = ${JSON.stringify(entry.value)} (${entry.source})${hidden}\n`;
+}
+function present(invocation, result) {
+    if (invocation.json) {
+        process.stdout.write(JSON.stringify({ schemaVersion: 1, ...result }) + "\n");
+        return;
+    }
+    if ("settings" in result) {
+        for (const entry of result.settings)
+            process.stdout.write(entryLine(entry));
+        return;
+    }
+    if ("source" in result) {
+        process.stdout.write(entryLine(result));
+        return;
+    }
+    process.stdout.write(`${result.action}: ${result.field}\n`);
+    if (result.notice !== null)
+        process.stdout.write(result.notice + "\n");
+}
+async function execute(invocation, repository) {
+    if (invocation.action === "list")
+        return { settings: await entries(repository) };
+    const field = invocation.field ?? "";
+    const defaultScope = settingScope(field);
+    const scope = invocation.private ? "private" : defaultScope;
+    if (invocation.action === "set")
+        validateSetting(field, settingValue(invocation.value ?? ""));
+    const [current] = await entries(repository, field);
+    if (current === undefined)
+        throw new Error(`unknown-setting: ${field}`);
+    if (invocation.action === "get")
+        return current;
+    const path = scope === "private"
+        ? privateSettingsPath(process.env, repository)
+        : join(repository, ".cloving/config.json");
+    await changeConfigFile(path, {
+        field,
+        scope,
+        action: invocation.action,
+        ...(invocation.value === undefined ? {} : { value: invocation.value }),
+    });
+    const notice = await configNotice(repository, {
+        scope,
+        entry: (await entries(repository, field))[0],
+    });
+    return { field, scope, action: invocation.action, notice };
+}
+export async function configCommand(invocation, repository) {
+    try {
+        if (repository === undefined)
+            throw new Error("repository-unknown");
+        present(invocation, await execute(invocation, repository));
+        return 0;
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : "configuration-error";
+        if (invocation.json)
+            process.stdout.write(JSON.stringify({
+                schemaVersion: 1,
+                kind: "error",
+                code: detail.split(":")[0],
+                detail,
+            }) + "\n");
+        else
+            process.stderr.write(detail + "\n");
+        return 2;
+    }
+}

package/dist/src/cli/config-file.d.ts

@@ -0,0 +1,3 @@
+import { type SettingChange, type HarnessChange } from "../configuration-change.ts";
+export declare function readConfigFile(path: string): Promise<string | undefined>;
+export declare function changeConfigFile(path: string, change: SettingChange | HarnessChange): Promise<void>;

package/dist/src/cli/config-file.js

@@ -0,0 +1,52 @@
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, rename, rm, stat, writeFile, } from "node:fs/promises";
+import { dirname } from "node:path";
+import { acquireSettingsLock, releaseSettingsLock } from "./config-lock.js";
+import { changedConfiguration, selectedHarnessConfiguration, } from "../configuration-change.js";
+export async function readConfigFile(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+async function atomicWrite(path, contents) {
+    const { text, mode = 0o600 } = contents;
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, text, { mode: 0o600, flag: "wx" });
+        if (mode !== 0o600)
+            await chmod(temporary, mode);
+        await rename(temporary, path);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+export async function changeConfigFile(path, change) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const lock = await acquireSettingsLock(`${path}.lock`);
+    try {
+        await writeChange(path, change);
+    }
+    finally {
+        await releaseSettingsLock(lock);
+    }
+}
+async function writeChange(path, change) {
+    const previous = await readConfigFile(path);
+    const next = "harness" in change
+        ? selectedHarnessConfiguration(previous, change.harness)
+        : changedConfiguration(previous, change);
+    const mode = previous !== undefined && change.scope === "project"
+        ? (await stat(path)).mode & 0o777
+        : 0o600;
+    if (previous !== undefined && change.scope === "private")
+        await chmod(path, 0o600);
+    if (previous !== undefined)
+        await atomicWrite(`${path}.bak`, { text: previous });
+    await atomicWrite(path, { text: next, mode });
+}

package/dist/src/cli/config-lock.d.ts

@@ -0,0 +1,7 @@
+interface Lock {
+    readonly path: string;
+    readonly owner: string;
+}
+export declare function releaseSettingsLock(lock: Lock): Promise<void>;
+export declare function acquireSettingsLock(path: string, deadline?: number): Promise<Lock>;
+export {};

package/dist/src/cli/config-lock.js

@@ -0,0 +1,61 @@
+import { randomUUID } from "node:crypto";
+import { readlink, symlink, unlink } from "node:fs/promises";
+import { setTimeout } from "node:timers/promises";
+function hasCode(error, code) {
+    return error instanceof Error && "code" in error && error.code === code;
+}
+async function owner(path) {
+    try {
+        return await readlink(path);
+    }
+    catch (error) {
+        if (hasCode(error, "ENOENT"))
+            return undefined;
+        throw error;
+    }
+}
+function stopped(value) {
+    const [pid] = value.split("-");
+    if (pid === undefined || !/^[1-9][0-9]*$/.test(pid))
+        return false;
+    try {
+        process.kill(Number(pid), 0);
+        return false;
+    }
+    catch (error) {
+        return hasCode(error, "ESRCH");
+    }
+}
+export async function releaseSettingsLock(lock) {
+    if ((await owner(lock.path)) === lock.owner)
+        await unlink(lock.path);
+}
+async function reclaim(path, input) {
+    const guard = await acquireSettingsLock(`${path}.reap`, input.deadline);
+    try {
+        if ((await owner(path)) === input.previous)
+            await unlink(path);
+    }
+    finally {
+        await releaseSettingsLock(guard);
+    }
+}
+export async function acquireSettingsLock(path, deadline = Date.now() + 10000) {
+    const lock = { path, owner: `${String(process.pid)}-${randomUUID()}` };
+    while (Date.now() < deadline) {
+        try {
+            await symlink(lock.owner, path);
+            return lock;
+        }
+        catch (error) {
+            if (!hasCode(error, "EEXIST"))
+                throw error;
+        }
+        const previous = await owner(path);
+        if (previous !== undefined && stopped(previous))
+            await reclaim(path, { previous, deadline });
+        else
+            await setTimeout(Math.min(25, Math.max(1, deadline - Date.now())));
+    }
+    throw new Error("settings-locked");
+}

package/dist/src/cli/config-notice.d.ts

@@ -0,0 +1,5 @@
+import type { SettingEntry } from "../configuration-display.ts";
+export declare function configNotice(repository: string, input: {
+    readonly scope: "project" | "private";
+    readonly entry: SettingEntry | undefined;
+}): Promise<string | null>;

package/dist/src/cli/config-notice.js

@@ -0,0 +1,46 @@
+import net from "node:net";
+import { join } from "node:path";
+import { socketAddress } from "../broker/socket-address.js";
+import { runtimeDirectory } from "./runtime-directory.js";
+function serviceDirectory(repository) {
+    try {
+        return runtimeDirectory(process.env, repository);
+    }
+    catch {
+        return undefined;
+    }
+}
+function running(repository) {
+    const directory = serviceDirectory(repository);
+    if (directory === undefined)
+        return Promise.resolve(false);
+    const address = socketAddress(join(directory, "control.sock"));
+    if (address.kind !== "address")
+        return Promise.resolve(false);
+    return new Promise((resolve) => {
+        const socket = net.connect(address.path);
+        const finish = (result) => {
+            socket.destroy();
+            resolve(result.connected);
+        };
+        socket.setTimeout(250);
+        socket.once("connect", () => {
+            finish({ connected: true });
+        });
+        const unavailable = () => {
+            finish({ connected: false });
+        };
+        socket.once("error", unavailable);
+        socket.once("timeout", unavailable);
+    });
+}
+export async function configNotice(repository, input) {
+    if (!(await running(repository)))
+        return null;
+    const source = input.entry?.source;
+    const hidden = source === "environment" ||
+        (input.scope === "project" && source === "private");
+    return hidden
+        ? `The ${source} source hides this file value. A restart keeps the value of that source.`
+        : "Restart the service to use the new value.";
+}

package/dist/src/cli/doctor-github.d.ts

@@ -0,0 +1,9 @@
+import type { DoctorCode, DoctorObservation } from "../doctor-report.ts";
+import type { ProbeRunner } from "./probe-command.ts";
+export declare function githubObservations(repository: string, options: {
+    readonly environment: Readonly<NodeJS.ProcessEnv>;
+    readonly probe: ProbeRunner;
+}): Promise<{
+    readonly observations: Partial<Record<DoctorCode, DoctorObservation>>;
+    readonly loginFix: string;
+}>;

package/dist/src/cli/doctor-github.js

@@ -0,0 +1,138 @@
+import { shellArgument } from "./runtime-directory.js";
+import { record } from "../protocol.js";
+import { listedSetting } from "./doctor-local.js";
+import { prRepository } from "./watch-pr-identity.js";
+async function read(context, argumentsList) {
+    const output = await context.probe(context.command[0] ?? "", {
+        arguments: [...context.command.slice(1), ...argumentsList],
+        env: context.environment,
+        directory: context.repository,
+        bytes: 8 * 1024 * 1024,
+    });
+    if (output.reason !== null)
+        throw new Error(output.reason === "probe-timeout"
+            ? "GitHub read timed out after 10 seconds"
+            : "GitHub command failed: " + output.reason);
+    return output.stdout;
+}
+async function origin(context) {
+    const output = await context.probe("git", {
+        arguments: ["remote", "get-url", "origin"],
+        env: context.environment,
+        directory: context.repository,
+    });
+    const identity = output.reason === null ? prRepository(output.stdout.trim()) : null;
+    const valid = identity !== null;
+    return {
+        observation: {
+            result: valid ? "ok" : "fail",
+            detail: valid
+                ? `GitHub origin ${identity.host}/${identity.owner}/${identity.repository}`
+                : "origin is absent or is not on GitHub",
+        },
+        identity: valid ? identity : null,
+    };
+}
+function list(text) {
+    const value = JSON.parse(text);
+    if (!Array.isArray(value))
+        throw new Error("Invalid GitHub response");
+    return Array.from(value).flatMap((item) => Array.isArray(item) ? Array.from(item) : [item]);
+}
+async function botActivity(context, pull) {
+    const { identity, number } = pull;
+    for (const endpoint of [
+        `pulls/${String(number)}/reviews`,
+        `issues/${String(number)}/comments`,
+        `pulls/${String(number)}/comments`,
+    ]) {
+        const entries = list(await read(context, [
+            "api",
+            "--method",
+            "GET",
+            "--hostname",
+            identity.host,
+            "--paginate",
+            "--slurp",
+            `repos/${identity.owner}/${identity.repository}/${endpoint}?per_page=100`,
+        ]));
+        if (entries.some((entry) => record(record(entry)?.["user"])?.["login"] === "greptile-apps[bot]"))
+            return true;
+    }
+    return false;
+}
+async function greptile(context, identity) {
+    const pulls = list(await read(context, [
+        "pr",
+        "list",
+        "--repo",
+        `${identity.host}/${identity.owner}/${identity.repository}`,
+        "--state",
+        "all",
+        "--limit",
+        "20",
+        "--json",
+        "number",
+    ]));
+    if (pulls.length === 0)
+        return { result: "skip", detail: "No pull requests in this repository" };
+    for (const pull of pulls.slice(0, 20)) {
+        const number = record(pull)?.["number"];
+        if (typeof number !== "number" ||
+            !Number.isSafeInteger(number) ||
+            number < 1)
+            throw new Error("Invalid GitHub pull request");
+        if (await botActivity(context, { identity, number }))
+            return {
+                result: "ok",
+                detail: "Recent activity of greptile-apps[bot]; this does not establish a usable review",
+            };
+    }
+    return {
+        result: "fail",
+        detail: "No Greptile review or comment found on the last 20 pull requests. This does not prove Greptile is not installed",
+    };
+}
+export async function githubObservations(repository, options) {
+    const { environment, probe } = options;
+    const command = environment["CLOVING_GH_COMMAND"] === undefined
+        ? ["gh"]
+        : (listedSetting(environment["CLOVING_GH_COMMAND"]) ?? []);
+    const context = { repository, environment, command, probe };
+    const found = await origin(context);
+    const host = found.identity?.host ?? "github.com";
+    const observations = {
+        "github-origin": found.observation,
+        "greptile-review": {
+            result: "skip",
+            detail: "GitHub login or origin prerequisite unavailable",
+        },
+    };
+    const loginFix = `Log in with the configured command: ${command.map(shellArgument).join(" ")} auth login --hostname ${shellArgument(host)}`;
+    try {
+        await read(context, ["auth", "status", "--hostname", host]);
+        observations["gh-login"] = {
+            result: "ok",
+            detail: `Configured GitHub command is authenticated on ${host}`,
+        };
+    }
+    catch (error) {
+        observations["gh-login"] = {
+            result: "fail",
+            detail: error instanceof Error ? error.message : "GitHub login unavailable",
+        };
+        return { observations, loginFix };
+    }
+    if (found.identity !== null) {
+        try {
+            observations["greptile-review"] = await greptile(context, found.identity);
+        }
+        catch (error) {
+            observations["greptile-review"] = {
+                result: "fail",
+                detail: error instanceof Error ? error.message : "GitHub read failed",
+            };
+        }
+    }
+    return { observations, loginFix };
+}

package/dist/src/cli/doctor-harness.d.ts

@@ -0,0 +1,13 @@
+import type { DoctorObservation } from "../doctor-report.ts";
+import { type HarnessSettings } from "../harness-defaults.ts";
+import type { ProbeRunner } from "./probe-command.ts";
+export declare function harnessObservations(environment: Readonly<NodeJS.ProcessEnv>, location: {
+    readonly directory: string;
+    readonly settingsValid: boolean;
+    readonly probe: ProbeRunner;
+    readonly commandEnvironment: Readonly<NodeJS.ProcessEnv>;
+    readonly harness?: HarnessSettings["harness"];
+}): Promise<{
+    readonly harnesses: DoctorObservation;
+    readonly selected: DoctorObservation;
+}>;