cloving 1.3.0 → 1.4.0

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

@@ -3,7 +3,10 @@ export interface Interruption {
     readonly signal: Promise<void>;
     readonly reply: Reply;
 }
-export declare function send(runtimeDirectory: string, request: ServiceRequest): Promise<Reply>;
+export interface ClientRequest extends ServiceRequest {
+    readonly signal?: AbortSignal;
+}
+export declare function send(runtimeDirectory: string, input: ClientRequest): Promise<Reply>;
 export declare function listRuns(runtimeDirectory: string): Promise<Reply>;
 export declare function mutate(runtimeDirectory: string, mutation: {
     readonly request: ServiceRequest;

package/dist/src/cli/client.js

@@ -41,7 +41,7 @@ function exchange(context) {
             error: { code: address.reason, detail: address.detail },
         });
     return new Promise((settle) => {
-        const socket = net.connect(address.path);
+        const socket = net.connect({ path: address.path, signal: context.signal });
         let buffered = "";
         let written = false;
         socket.setEncoding("utf8");
@@ -86,8 +86,14 @@ function exchange(context) {
     });
 }
 const unobserved = () => undefined;
-export function send(runtimeDirectory, request) {
-    return exchange({ runtimeDirectory, request, onEvent: unobserved });
+export function send(runtimeDirectory, input) {
+    const { signal, ...request } = input;
+    return exchange({
+        runtimeDirectory,
+        request,
+        onEvent: unobserved,
+        ...(signal === undefined ? {} : { signal }),
+    });
 }
 function listedRuns(result) {
     const runs = result["runs"];

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

@@ -0,0 +1,17 @@
+import { type Fields, type Reply, type ServiceError, type ServiceRequest } from "../protocol.ts";
+import { type ClientRequest } from "./client.ts";
+export interface ReadCommand {
+    readonly kind: "status" | "questions" | "events";
+    readonly runId?: string | null;
+    readonly limit?: number | null;
+    readonly after?: string | number | null;
+    readonly follow?: boolean;
+}
+export declare function readCommandRequest(command: ReadCommand): ServiceRequest;
+export declare function readCommandReply(runtimeDirectory: string, request: ClientRequest): Promise<Reply>;
+export declare function errorObject(error: ServiceError, format?: {
+    readonly commandId?: string;
+}): Fields;
+export declare function commandJson(reply: Reply, format?: {
+    readonly commandId?: string;
+}): Fields;

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

@@ -0,0 +1,43 @@
+import {} from "../protocol.js";
+import { send } from "./client.js";
+import { withCiReruns } from "./github-ci-progress.js";
+import { statusJson } from "./render.js";
+export function readCommandRequest(command) {
+    const { kind, runId, limit, after, follow } = command;
+    const parameters = kind === "questions"
+        ? { runId }
+        : { runId, limit, after, ...(follow === undefined ? {} : { follow }) };
+    return {
+        operation: kind,
+        parameters: Object.fromEntries(Object.entries(parameters).filter(([, value]) => value !== null && value !== undefined)),
+    };
+}
+export async function readCommandReply(runtimeDirectory, request) {
+    const reply = await send(runtimeDirectory, request);
+    return request.operation === "status"
+        ? await withCiReruns(runtimeDirectory, reply)
+        : reply;
+}
+export 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,
+    };
+}
+export function commandJson(reply, format = {}) {
+    return reply.kind === "error"
+        ? errorObject(reply.error, format)
+        : statusJson(reply.result);
+}

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

@@ -0,0 +1,9 @@
+import { type Shown } from "./watch-element.ts";
+import type { CommandWaitView } from "../authority/command-wait-view.ts";
+export declare function shownCommandWaits(value: unknown): readonly CommandWaitView[];
+export declare function commandWaitText(wait: CommandWaitView): string;
+export declare function CommandWaits(props: {
+    readonly waits: readonly CommandWaitView[];
+}): Shown;
+export declare function effectBudgetText(spent: number | null | undefined, limit: number | null | undefined): string;
+export declare function activeCommandWait(waits: readonly CommandWaitView[]): boolean;

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

@@ -0,0 +1,51 @@
+import { element } from "./watch-element.js";
+import { record } from "../protocol.js";
+function waitTime(value) {
+    return typeof value === "string" ? value : null;
+}
+export function shownCommandWaits(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        const fields = record(entry);
+        if (typeof fields?.["name"] !== "string" ||
+            typeof fields["command"] !== "string" ||
+            typeof fields["state"] !== "string" ||
+            typeof fields["maximumWaitSeconds"] !== "number" ||
+            typeof fields["remainingSeconds"] !== "number" ||
+            typeof fields["checkCount"] !== "number")
+            return [];
+        return [
+            {
+                name: fields["name"],
+                command: fields["command"],
+                state: fields["state"],
+                maximumWaitSeconds: fields["maximumWaitSeconds"],
+                remainingSeconds: fields["remainingSeconds"],
+                checkCount: fields["checkCount"],
+                startedAt: waitTime(fields["startedAt"]),
+                deadline: waitTime(fields["deadline"]),
+                nextCheckAt: waitTime(fields["nextCheckAt"]),
+                reason: waitTime(fields["reason"]),
+            },
+        ];
+    });
+}
+export function commandWaitText(wait) {
+    const reason = wait.reason === null ? "" : ` · ${wait.reason}`;
+    return `Command wait ${wait.name} · ${wait.command} · ${wait.state} · ${String(wait.remainingSeconds)} s left · deadline ${wait.deadline ?? "none"} · next check ${wait.nextCheckAt ?? "none"} · checks ${String(wait.checkCount)}${reason}`;
+}
+export function CommandWaits(props) {
+    return props.waits.map((wait) => element("p", {
+        class: "meta command-wait",
+        children: commandWaitText(wait),
+    }));
+}
+export function effectBudgetText(spent, limit) {
+    return spent == null || limit == null
+        ? ""
+        : `${String(spent)} of ${String(limit)} effect units`;
+}
+export function activeCommandWait(waits) {
+    return waits.some((wait) => wait.state === "waiting");
+}

package/dist/src/cli/commands.js

@@ -1,30 +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);
@@ -42,16 +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 send(environment.runtimeDirectory, exchange.request);
+    const reply = await readCommandReply(environment.runtimeDirectory, exchange.request);
     return presented(environment, {
-        reply: exchange.request.operation === "status"
-            ? await withCiReruns(environment.runtimeDirectory, reply)
-            : reply,
+        reply,
         format: exchange.format,
     });
 }
@@ -153,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) {
@@ -200,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,
@@ -240,6 +211,11 @@ export function runtimeCommand(invocation, environment) {
     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")
@@ -256,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-file.d.ts

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

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

@@ -2,7 +2,7 @@ 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, } from "../configuration-change.js";
+import { changedConfiguration, selectedHarnessConfiguration, } from "../configuration-change.js";
 export async function readConfigFile(path) {
     try {
         return await readFile(path, "utf8");
@@ -38,7 +38,9 @@ export async function changeConfigFile(path, change) {
 }
 async function writeChange(path, change) {
     const previous = await readConfigFile(path);
-    const next = changedConfiguration(previous, change);
+    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;

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

@@ -1,3 +1,6 @@
-import type { DoctorWorkflow } from "../doctor-report.ts";
-export declare const bundledDoctorWorkflows: DoctorWorkflow[];
+import type { DoctorObservation, DoctorWorkflow } from "../doctor-report.ts";
+export declare function workflowObservation(context: {
+    readonly workflows: readonly DoctorWorkflow[];
+    readonly prerequisite: string | undefined;
+}): DoctorObservation;
 export declare function doctorWorkflows(repository: string, environment: Readonly<NodeJS.ProcessEnv>): Promise<readonly DoctorWorkflow[]>;

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

@@ -3,12 +3,17 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { configurationRoot, absoluteWorkflowFolder, } from "../project-settings.js";
 import { isCandidateDeclaration } from "../workflow-candidate.js";
-import { bundledWorkflowIds } from "../workflow-discovery.js";
-export const bundledDoctorWorkflows = Object.values(bundledWorkflowIds).map((workflowId) => ({
-    scope: "bundled",
-    workflowId,
-    capabilities: ["claude", "github"],
-}));
+export function workflowObservation(context) {
+    if (context.prerequisite !== undefined)
+        return { result: "skip", detail: context.prerequisite };
+    const found = context.workflows.length > 0;
+    return {
+        result: found ? "ok" : "fail",
+        detail: found
+            ? "Project or user workflow found"
+            : "No project or user workflow",
+    };
+}
 export async function doctorWorkflows(repository, environment) {
     const discovered = [];
     for (const [scope, folder] of [
@@ -41,5 +46,5 @@ export async function doctorWorkflows(repository, environment) {
                 discovered.push({ scope, ...declaration.workflow });
         }
     }
-    return [...bundledDoctorWorkflows, ...discovered];
+    return discovered;
 }

package/dist/src/cli/doctor.js

@@ -3,7 +3,7 @@ import { dirname, delimiter, join } from "node:path";
 import { doctorCodes, doctorExitCode, doctorFixes, requiredDoctorCodes, } from "../doctor-report.js";
 import { privateSettingsPath, projectSettings } from "./project-settings.js";
 import { githubObservations } from "./doctor-github.js";
-import { bundledDoctorWorkflows, doctorWorkflows } from "./doctor-workflows.js";
+import { doctorWorkflows, workflowObservation } from "./doctor-workflows.js";
 import { runtimeObservation, serviceObservation } from "./doctor-runtime.js";
 import { harnessObservations } from "./doctor-harness.js";
 import { commandObservation, nodeObservation, privateTextsObservation, queueObservation, } from "./doctor-local.js";
@@ -40,7 +40,7 @@ export async function doctorReport(options) {
     const found = repository === undefined
         ? {
             observations: {},
-            required: requiredDoctorCodes([], { queueSeconds: undefined }),
+            required: requiredDoctorCodes([]),
         }
         : await repositoryObservations({ ...options, repository });
     const git = repository === undefined
@@ -94,18 +94,15 @@ async function repositoryObservations(options) {
         settingsValid,
         environment,
     });
-    const required = requiredDoctorCodes(workflowContext.workflows, {
-        queueSeconds: settingsValid
-            ? environment["CLOVING_QUEUE_SECONDS"]
-            : undefined,
-    });
+    observations["no-workflow"] = workflowObservation(workflowContext);
+    const required = requiredDoctorCodes(workflowContext.workflows);
     const dependent = await configuredObservations({ ...options, environment }, { prerequisite: workflowContext.prerequisite, project, serviceEnvironment });
     return { observations: { ...observations, ...dependent }, required };
 }
 async function workflowRequirements(repository, context) {
     if (!context.settingsValid)
         return {
-            workflows: bundledDoctorWorkflows,
+            workflows: [],
             prerequisite: "Settings files are invalid",
         };
     try {
@@ -116,7 +113,7 @@ async function workflowRequirements(repository, context) {
     }
     catch (error) {
         return {
-            workflows: bundledDoctorWorkflows,
+            workflows: [],
             prerequisite: `Workflow requirements unavailable: ${error instanceof Error ? error.message : "discovery failed"}`,
         };
     }

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

@@ -1,8 +1,10 @@
 import type { ProbeRunner } from "./probe-command.ts";
+import { type ShellMode } from "../agent-harness-shell.ts";
 export interface HarnessEntry {
     readonly name: string;
     readonly kind: "file" | "shell";
     readonly path: string;
+    readonly shellMode?: ShellMode;
     readonly version: string | null;
     readonly working: boolean;
     readonly reason: string | null;

package/dist/src/cli/harness-probes.js

@@ -87,7 +87,7 @@ async function probeShell(candidate, context) {
         env,
     });
     const stdout = shellBlock(output.stdout, 0);
-    return probeEntry({ name, kind, path }, {
+    return probeEntry({ name, kind, path, ...(kind === "shell" ? { shellMode: mode } : {}) }, {
         stdout: stdout ?? "",
         reason: output.reason ?? (stdout === null ? "shell-protocol" : null),
     });

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

@@ -0,0 +1,6 @@
+interface HarnessProcessEffects {
+    readonly snapshot: () => string;
+    readonly kill: (identifier: number, signal: "SIGTERM") => boolean;
+}
+export declare function terminateHarness(identifier: number | undefined, effects: HarnessProcessEffects): void;
+export {};

package/dist/src/cli/harness-processes.js

@@ -0,0 +1,36 @@
+function harnessProcesses(identifier, effects) {
+    let snapshot;
+    try {
+        snapshot = effects.snapshot();
+    }
+    catch {
+        return [identifier];
+    }
+    const rows = snapshot
+        .trim()
+        .split("\n")
+        .map((row) => row.trim().split(/\s+/).map(Number));
+    const identifiers = [identifier];
+    for (let index = 0; index < identifiers.length; index++) {
+        for (const [child, parent] of rows) {
+            if (parent === identifiers[index] && child !== undefined && child > 0)
+                identifiers.push(child);
+        }
+    }
+    return identifiers;
+}
+export function terminateHarness(identifier, effects) {
+    if (identifier === undefined)
+        return;
+    for (const target of harnessProcesses(identifier, effects).reverse()) {
+        try {
+            effects.kill(target, "SIGTERM");
+        }
+        catch (error) {
+            if (!(error instanceof Error) ||
+                !("code" in error) ||
+                error.code !== "ESRCH")
+                throw error;
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import { type HarnessStartRequest } from "../harness-start.ts";
+import type { ProbeRunner } from "./probe-command.ts";
+export declare function initCommand(context: {
+    readonly repository: string | undefined;
+    readonly environment: Readonly<NodeJS.ProcessEnv>;
+    readonly probe: ProbeRunner;
+    readonly harness: string | undefined;
+    readonly start: (request: HarnessStartRequest) => Promise<number | null>;
+}): Promise<number>;

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

@@ -0,0 +1,52 @@
+import { createInterface } from "node:readline/promises";
+import { harnessStartRequest, } from "../harness-start.js";
+import { changeConfigFile } from "./config-file.js";
+import { chooseHarness, selectedHarness } from "./init-selection.js";
+import { privateSettingsPath, projectSettings } from "./project-settings.js";
+export async function initCommand(context) {
+    if (context.repository === undefined) {
+        process.stderr.write("not-a-repository: run git init.\n");
+        return 1;
+    }
+    try {
+        const entry = context.harness === undefined
+            ? await promptHarness({ ...context, repository: context.repository })
+            : await selectedHarness(context.harness, context);
+        await changeConfigFile(privateSettingsPath(context.environment, context.repository), {
+            harness: { name: entry.name, kind: entry.kind, path: entry.path },
+            scope: "private",
+        });
+        const request = harnessStartRequest(entry, {
+            repository: context.repository,
+            environment: context.environment,
+            message: "run `cloving init-prompt`",
+        });
+        const status = await context.start(request);
+        if (status !== null)
+            return status;
+        process.stderr.write("Open your agent in this repository and tell it: run `cloving init-prompt`.\n");
+        return 1;
+    }
+    catch (error) {
+        process.stderr.write((error instanceof Error ? error.message : "init-failed") + "\n");
+        return 2;
+    }
+}
+async function promptHarness(context) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        throw new Error("harness-not-selected");
+    const terminal = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        return await chooseHarness({
+            ...context,
+            current: projectSettings(context.environment, context.repository).harness,
+            question: (text) => terminal.question(text),
+        });
+    }
+    finally {
+        terminal.close();
+    }
+}

package/dist/src/cli/init-prompt-command.d.ts

@@ -0,0 +1,10 @@
+import { type InitPromptFacts } from "./init-prompt.ts";
+import type { ProbeRunner } from "./probe-command.ts";
+interface PromptContext {
+    readonly repository: string | undefined;
+    readonly environment: Readonly<NodeJS.ProcessEnv>;
+    readonly probe: ProbeRunner;
+}
+export declare function initPromptFacts(context: PromptContext): Promise<InitPromptFacts>;
+export declare function initPromptCommand(context: PromptContext): Promise<number>;
+export {};