cloving 1.1.0 → 1.3.0

package/dist/src/cli/arguments.js

@@ -1,4 +1,7 @@
 import { parseArgs } from "node:util";
+import { configInvocation } from "./config-arguments.js";
+import { repositoryArguments } from "./repository-arguments.js";
+import { phoneInvocation } from "./phone-arguments.js";
 import { isRuntimeCommand, runtimeInvocation, } from "./runtime-arguments.js";
 const errorCodes = {
     ERR_PARSE_ARGS_UNKNOWN_OPTION: "unknown-option",
@@ -21,6 +24,8 @@ const options = {
     limit: { type: "string" },
     after: { type: "string" },
     follow: { type: "boolean" },
+    since: { type: "string" },
+    repository: { type: "string" },
 };
 const textOptions = ["--prompt", "--text"];
 function knownFlag(token) {
@@ -48,10 +53,27 @@ function textValues(argumentsList) {
     return option === undefined ? joined : [...joined, option];
 }
 export function parseInvocation(given) {
-    if (given[0] === "chats" && given[1] === "import")
-        return chatsImport(given.slice(2));
-    if (given[0] === "chats" && given[1] === "redact")
-        return chatsRedact(given.slice(2));
+    const selected = repositoryArguments(given, options);
+    if (typeof selected === "string")
+        return {
+            kind: "usage-error",
+            code: selected,
+            json: given.includes("--json"),
+        };
+    const invocation = selectedInvocation(selected.argumentsList);
+    return selected.repository === undefined
+        ? invocation
+        : { ...invocation, repository: selected.repository };
+}
+function selectedInvocation(given) {
+    if (given[0] === "config") {
+        const outcome = configInvocation(given.slice(1));
+        return typeof outcome === "string"
+            ? { kind: "usage-error", code: outcome, json: given.includes("--json") }
+            : outcome;
+    }
+    if (given[0] === "phone")
+        return phoneInvocation(given.slice(1));
     const argumentsList = textValues(given);
     const json = given.includes("--json");
     const parsed = parsedArguments(argumentsList);
@@ -61,6 +83,8 @@ export function parseInvocation(given) {
     const [command, ...remaining] = positionals;
     if (command === undefined)
         return topLevel(values);
+    if (command === "doctor")
+        return doctorInvocation(values, remaining);
     if (command === "workflows" && remaining[0] === "validate")
         return validation(values, remaining.slice(1));
     const outcome = runtimeInvocation({
@@ -72,109 +96,13 @@ export function parseInvocation(given) {
         return { kind: "usage-error", code: outcome, json };
     return outcome;
 }
-function chatsRedact(argumentsList) {
-    if (argumentsList.length === 1 &&
-        ["--help", "-h"].includes(String(argumentsList[0])))
-        return { kind: "chats-redact-help" };
-    const importId = argumentsList[0];
-    if (argumentsList.length !== 1 ||
-        importId === undefined ||
-        !/^[a-f\d]{8}-[a-f\d]{4}-4[a-f\d]{3}-[89ab][a-f\d]{3}-[a-f\d]{12}$/.test(importId))
-        return { kind: "usage-error", code: "invalid-import-id", json: false };
-    return { kind: "chats-redact", importId };
-}
-function chatsImport(argumentsList) {
-    const error = (code) => ({
-        kind: "usage-error",
-        code,
-        json: false,
-    });
-    if (argumentsList.length === 1 &&
-        ["--help", "-h"].includes(String(argumentsList[0])))
-        return { kind: "chats-import-help" };
-    const state = {
-        paths: [],
-        roots: [],
-        excludeProjects: [],
-        literal: false,
-        option: undefined,
-        previousImportId: undefined,
-    };
-    for (const argument of argumentsList) {
-        const failure = importArgument(state, argument);
-        if (failure !== undefined)
-            return error(failure);
-    }
-    if (state.option !== undefined)
-        return error("missing-value");
-    if (state.excludeProjects.length > 0 && state.roots.length === 0)
-        return error("roots-required");
-    if (state.paths.length + state.roots.length === 0)
-        return error("missing-argument");
-    return importInvocation(state);
-}
-function importInvocation(state) {
-    const previous = state.previousImportId === undefined
-        ? {}
-        : { previousImportId: state.previousImportId };
-    return state.roots.length === 0
-        ? { kind: "chats-import", paths: state.paths, ...previous }
-        : {
-            kind: "chats-import",
-            paths: state.paths,
-            ...previous,
-            roots: state.roots,
-            excludeProjects: state.excludeProjects,
-        };
-}
-function importArgument(state, argument) {
-    if (state.option !== undefined)
-        return importValue(state, argument);
-    if (argument === "")
-        return "missing-argument";
-    if (state.literal) {
-        state.paths.push(argument);
-        return;
-    }
-    if (argument === "--previous-import" && state.previousImportId !== undefined)
-        return "repeated-previous-import";
-    if (["--root", "--exclude-project", "--previous-import"].includes(argument)) {
-        state.option = argument;
-        return;
-    }
-    if (argument === "--") {
-        state.literal = true;
-        return;
-    }
-    if (argument.startsWith("-"))
-        return "unexpected-option";
-    state.paths.push(argument);
-    return;
-}
-function importValue(state, argument) {
-    if (argument === "" || argument.startsWith("-"))
-        return "missing-value";
-    const option = state.option;
-    state.option = undefined;
-    if (option === "--root") {
-        state.roots.push(argument);
-        return;
-    }
-    if (option === "--exclude-project" && !validProjectName(argument))
-        return "invalid-exclusion";
-    if (option === "--exclude-project") {
-        state.excludeProjects.push(argument);
-        return;
-    }
-    if (!/^[a-f\d]{8}-[a-f\d]{4}-4[a-f\d]{3}-[89ab][a-f\d]{3}-[a-f\d]{12}$/.test(argument))
-        return "invalid-import-id";
-    state.previousImportId = argument;
-    return;
-}
-function validProjectName(name) {
-    return (name !== "." &&
-        name !== ".." &&
-        !["/", "\\", "\0", "*", "?", "[", "]"].some((character) => name.includes(character)));
+function doctorInvocation(values, remaining) {
+    const json = values.json === true;
+    if (unexpected(values, ["help", "json"]))
+        return { kind: "usage-error", code: "unexpected-option", json };
+    if (remaining.length > 0)
+        return { kind: "usage-error", code: "unexpected-argument", json };
+    return values.help ? { kind: "doctor-help" } : { kind: "doctor", json };
 }
 function parsedArguments(argumentsList) {
     try {
@@ -206,6 +134,8 @@ function knownCommand(positionals) {
         return true;
     if (command === "workflows")
         return subcommand === "validate";
+    if (command === "doctor")
+        return true;
     return isRuntimeCommand(command);
 }
 function givenOptions(tokens) {

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

@@ -0,0 +1,7 @@
+import type { CommandEffect } from "../command-settings.ts";
+import { type Shown } from "./watch-element.ts";
+export declare function shownCommands(value: unknown): readonly CommandEffect[];
+export declare function commandText(effect: CommandEffect): string;
+export declare function Commands(props: {
+    readonly effects: readonly CommandEffect[];
+}): Shown;

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

@@ -0,0 +1,39 @@
+import { record } from "../protocol.js";
+import { element } from "./watch-element.js";
+export function shownCommands(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        const fields = record(entry);
+        if (typeof fields?.["operationId"] !== "string" ||
+            typeof fields["name"] !== "string" ||
+            typeof fields["state"] !== "string")
+            return [];
+        return [
+            {
+                operationId: fields["operationId"],
+                name: fields["name"],
+                state: fields["state"],
+                exitCode: typeof fields["exitCode"] === "number" ? fields["exitCode"] : null,
+                durationMilliseconds: typeof fields["durationMilliseconds"] === "number"
+                    ? fields["durationMilliseconds"]
+                    : null,
+            },
+        ];
+    });
+}
+export function commandText(effect) {
+    const duration = effect.durationMilliseconds === null
+        ? "duration unknown"
+        : `${String(effect.durationMilliseconds)} ms`;
+    return `Command ${effect.name} · ${effect.state} · exit ${effect.exitCode === null ? "unknown" : String(effect.exitCode)} · ${duration}`;
+}
+export function Commands(props) {
+    return props.effects.map((effect) => element("section", {
+        class: "command-effect code-window",
+        children: element("h3", {
+            class: "code-head",
+            children: commandText(effect),
+        }),
+    }));
+}

package/dist/src/cli/commands.js

@@ -1,3 +1,5 @@
+import { reportCommand } from "./report.js";
+import { withCiReruns } from "./github-ci-progress.js";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { record, } from "../protocol.js";
@@ -45,8 +47,11 @@ function presented(environment, outcome) {
     return 0;
 }
 async function requested(environment, exchange) {
+    const reply = await send(environment.runtimeDirectory, exchange.request);
     return presented(environment, {
-        reply: await send(environment.runtimeDirectory, exchange.request),
+        reply: exchange.request.operation === "status"
+            ? await withCiReruns(environment.runtimeDirectory, reply)
+            : reply,
         format: exchange.format,
     });
 }
@@ -138,7 +143,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"
@@ -227,14 +232,16 @@ 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 === "report")
+        return reportCommand(invocation, environment);
     if (invocation.kind === "run")
         return run(environment, invocation);
     if (invocation.kind === "status")

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 } from "../configuration-change.ts";
+export declare function readConfigFile(path: string): Promise<string | undefined>;
+export declare function changeConfigFile(path: string, change: SettingChange): Promise<void>;

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

@@ -0,0 +1,50 @@
+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";
+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 = 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;
+}>;