cloving 1.1.0 → 1.3.0

package/dist/src/cli/main.js

@@ -1,27 +1,27 @@
+import { configCommand } from "./config-command.js";
+import { doctorCommand } from "./doctor.js";
 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 { phoneCommand } from "./phone-command.js";
 import { runtimeCommand } from "./commands.js";
 import { clientCommand, runtimeDirectory } from "./runtime-directory.js";
-import { chatsRedactUsage, chatsImportUsage, usage, validateUsage, } from "./usage.js";
+import { commandUsage, configUsage, phoneUsage, 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,
+    "phone-help": phoneUsage,
+    "doctor-help": String(commandUsage["doctor"]),
+    "config-help": configUsage,
 };
 function helpInvocation(invocation) {
     return Object.hasOwn(helpTexts, invocation.kind);
 }
-export async function main(argumentsList, watchPr) {
+export async function main(argumentsList, context = { repository: undefined }) {
+    const { repository, environment = process.env } = context;
     const invocation = parseInvocation(argumentsList);
-    if (refuseChatPlatform(invocation))
-        return;
     if (helpInvocation(invocation)) {
         process.stdout.write(helpTexts[invocation.kind]);
         return;
@@ -32,31 +32,32 @@ export async function main(argumentsList, watchPr) {
     else if (invocation.kind === "validate") {
         await validationCommand(invocation);
     }
-    else if (invocation.kind === "chats-redact") {
-        await redactionCommand(invocation.importId);
+    else if (invocation.kind === "doctor") {
+        if (context.doctorProbe === undefined)
+            throw new Error("doctor-probe-unavailable");
+        process.exitCode = await doctorCommand({
+            probe: context.doctorProbe,
+            repository,
+            environment,
+            json: invocation.json,
+        });
     }
-    else if (invocation.kind === "chats-import") {
-        const result = await importChats({
-            ...invocation,
-            workingDirectory: process.cwd(),
-            runtimeDirectory: runtimeDirectory(process.env),
+    else if (invocation.kind === "config") {
+        process.exitCode = await configCommand(invocation, repository);
+    }
+    else if (invocation.kind === "phone") {
+        process.exitCode = await phoneCommand(invocation, {
+            runtimeDirectory: runtimeDirectory(process.env, repository),
+            terminal,
         });
-        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),
+            runtimeDirectory: runtimeDirectory(process.env, repository),
+            ...watchSettings(context.watchPr, environment),
+            client: clientCommand(process.env, repository),
             workingDirectory: process.cwd(),
-            terminal: {
-                out: (text) => process.stdout.write(text),
-                error: (text) => process.stderr.write(text),
-            },
+            terminal,
             identifier: randomUUID,
             interrupted: () => new Promise((settle) => {
                 for (const signal of ["SIGINT", "SIGTERM"])
@@ -67,15 +68,16 @@ export async function main(argumentsList, watchPr) {
         });
     }
 }
-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;
+const terminal = {
+    out: (text) => process.stdout.write(text),
+    error: (text) => process.stderr.write(text),
+};
+function watchSettings(watchPr, environment) {
+    const watchActions = environment["CLOVING_WATCH_ACTIONS"];
+    return {
+        ...(watchActions === undefined ? {} : { watchActions }),
+        ...(watchPr === undefined ? {} : { watchPr }),
+    };
 }
 function presentUsageError(invocation) {
     if (invocation.json)
@@ -101,27 +103,3 @@ function present(report, format) {
     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/phone-arguments.d.ts

@@ -0,0 +1,14 @@
+export type PhoneCommandName = "status" | "list" | "remove" | "reset";
+export type PhoneInvocation = {
+    readonly kind: "phone-help";
+} | {
+    readonly kind: "phone";
+    readonly command: PhoneCommandName;
+    readonly deviceId: string | null;
+    readonly json: boolean;
+} | {
+    readonly kind: "usage-error";
+    readonly code: string;
+    readonly json: boolean;
+};
+export declare function phoneInvocation(argumentsList: readonly string[]): PhoneInvocation;

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

@@ -0,0 +1,37 @@
+const commands = [
+    "status",
+    "list",
+    "remove",
+    "reset",
+];
+function phoneCommandName(name) {
+    return commands.find((command) => command === name);
+}
+function unexpected(tokens, command) {
+    const allowed = command === "remove" ? 1 : 0;
+    const options = tokens.filter((token) => token.startsWith("-"));
+    const subjects = tokens.filter((token) => !token.startsWith("-"));
+    if (options.some((option) => option !== "--json"))
+        return "unexpected-option";
+    if (subjects.length > allowed)
+        return "unexpected-argument";
+    return subjects.length < allowed ? "missing-argument" : undefined;
+}
+export function phoneInvocation(argumentsList) {
+    const json = argumentsList.includes("--json");
+    if (argumentsList.includes("--help") || argumentsList.includes("-h"))
+        return { kind: "phone-help" };
+    const [name, ...rest] = argumentsList;
+    const command = phoneCommandName(name);
+    if (command === undefined)
+        return {
+            kind: "usage-error",
+            code: name === undefined ? "missing-argument" : "unknown-command",
+            json,
+        };
+    const code = unexpected(rest, command);
+    if (code !== undefined)
+        return { kind: "usage-error", code, json };
+    const deviceId = rest.find((token) => !token.startsWith("-")) ?? null;
+    return { kind: "phone", command, deviceId, json };
+}

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

@@ -0,0 +1,2 @@
+import { type Reply, type ServiceRequest } from "../protocol.ts";
+export declare function phoneRequest(runtimeDirectory: string, request: ServiceRequest): Promise<Reply | undefined>;

package/dist/src/cli/phone-client.js

@@ -0,0 +1,32 @@
+import net from "node:net";
+import { join } from "node:path";
+import { socketAddress } from "../broker/socket-address.js";
+import { parseReplyLine, requestLine, } from "../protocol.js";
+const absent = ["ENOENT", "ECONNREFUSED"];
+export function phoneRequest(runtimeDirectory, request) {
+    const address = socketAddress(join(runtimeDirectory, "phone.sock"));
+    if (address.kind === "refused")
+        return Promise.resolve({
+            kind: "error",
+            error: { code: address.reason, detail: address.detail },
+        });
+    return new Promise((settle, reject) => {
+        const socket = net.connect(address.path);
+        let buffered = "";
+        socket.setEncoding("utf8");
+        socket.once("connect", () => socket.write(requestLine(request)));
+        socket.on("data", (data) => {
+            buffered += data;
+        });
+        socket.once("end", () => {
+            const parsed = parseReplyLine(buffered.trim());
+            settle(parsed?.kind === "event" ? undefined : parsed);
+        });
+        socket.once("error", (error) => {
+            if (absent.includes(error.code ?? ""))
+                settle(undefined);
+            else
+                reject(error);
+        });
+    });
+}

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

@@ -0,0 +1,13 @@
+import type { PhoneInvocation } from "./phone-arguments.ts";
+type Invocation = Extract<PhoneInvocation, {
+    readonly kind: "phone";
+}>;
+export interface PhoneContext {
+    readonly runtimeDirectory: string | undefined;
+    readonly terminal: {
+        readonly out: (text: string) => void;
+        readonly error: (text: string) => void;
+    };
+}
+export declare function phoneCommand(invocation: Invocation, context: PhoneContext): Promise<number>;
+export {};

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

@@ -0,0 +1,101 @@
+import { record } from "../protocol.js";
+import { phoneRequest } from "./phone-client.js";
+import { oneLine } from "./render.js";
+function counted(count) {
+    return count === 1 ? "1 phone" : `${String(count)} phones`;
+}
+function listed(state) {
+    const devices = state["devices"];
+    if (!Array.isArray(devices))
+        return [];
+    return devices.flatMap((device) => {
+        const fields = record(device);
+        return fields === undefined ? [] : [fields];
+    });
+}
+function stateText(state) {
+    const registration = state["registered"] === true
+        ? `Registered as ${oneLine(state["daemonId"])} with ${oneLine(state["origin"])}.`
+        : "Not registered.";
+    return `${registration} ${counted(listed(state).length)}.\n`;
+}
+function deviceLine(device) {
+    const removedAt = device["removedAt"];
+    const condition = typeof removedAt === "string" ? `removed ${removedAt}` : device["state"];
+    return `${oneLine(device["deviceId"])}  ${oneLine(device["name"])} (${oneLine(device["platform"])})  ${oneLine(condition)}  paired ${oneLine(device["pairedAt"])}\n`;
+}
+function listText(state) {
+    const devices = listed(state);
+    return devices.length === 0
+        ? "No phones.\n"
+        : devices.map(deviceLine).join("");
+}
+function failed(context, reply) {
+    if (reply.kind === "result")
+        return 0;
+    context.terminal.error(`${oneLine(reply.error.code)}: ${oneLine(reply.error.detail)}\n`);
+    return 1;
+}
+function warned(context, result) {
+    const warning = result["warning"];
+    if (typeof warning === "string")
+        context.terminal.error(`warning: ${oneLine(warning)}\n`);
+}
+const operations = {
+    status: "phone-state",
+    list: "phone-state",
+    remove: "phone-remove",
+    reset: "phone-reset",
+};
+function jsonShown(command, result) {
+    if (command === "list")
+        return { devices: listed(result) };
+    if (command === "status")
+        return { relay: "on", ...result };
+    return result;
+}
+function shown(exchange, result) {
+    const { invocation } = exchange;
+    if (invocation.json)
+        return `${JSON.stringify(jsonShown(invocation.command, result))}\n`;
+    if (invocation.command === "status")
+        return stateText(result);
+    if (invocation.command === "list")
+        return listText(result);
+    if (invocation.command === "remove")
+        return `Removed the phone ${String(invocation.deviceId)}.\n`;
+    return `Removed the registration and ${counted(Number(result["removed"]))}.\n`;
+}
+function relayOff(exchange) {
+    const { invocation, context } = exchange;
+    if (invocation.command !== "status") {
+        context.terminal.error("phone-relay-off: The phone relay is off or not started.\n");
+        return 1;
+    }
+    context.terminal.out(invocation.json
+        ? `${JSON.stringify({ relay: "off" })}\n`
+        : "The phone relay is off or not started.\n");
+    return 0;
+}
+async function exchanged(exchange) {
+    const { invocation, context, runtimeDirectory } = exchange;
+    const reply = await phoneRequest(runtimeDirectory, {
+        operation: operations[invocation.command],
+        parameters: invocation.deviceId === null ? {} : { deviceId: invocation.deviceId },
+    });
+    if (reply === undefined)
+        return relayOff(exchange);
+    if (reply.kind === "error")
+        return failed(context, reply);
+    warned(context, reply.result);
+    context.terminal.out(shown(exchange, reply.result));
+    return 0;
+}
+export async function phoneCommand(invocation, context) {
+    const { runtimeDirectory } = context;
+    if (runtimeDirectory === undefined) {
+        context.terminal.error("repository-unknown: Change to the service repository, use --repository <directory>, or set CLOVING_RUNTIME_DIR.\n");
+        return 1;
+    }
+    return exchanged({ invocation, context, runtimeDirectory });
+}

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

@@ -0,0 +1,36 @@
+import type { Readable } from "node:stream";
+interface ProbeChild {
+    readonly pid?: number | undefined;
+    readonly stdout: Readable;
+    kill(signal: NodeJS.Signals): boolean;
+    once(event: "error", listener: (error: Error) => void): this;
+    once(event: "close", listener: (code: number | null) => void): this;
+}
+interface ProbeEffects {
+    readonly spawn: (input: {
+        readonly executable: string;
+        readonly arguments: string[];
+        readonly options: {
+            readonly env: Readonly<NodeJS.ProcessEnv>;
+            readonly cwd?: string;
+            readonly stdio: ["ignore", "pipe", "ignore"];
+            readonly detached: true;
+        };
+    }) => ProbeChild;
+    readonly kill: (identifier: number, signal: NodeJS.Signals) => boolean;
+}
+export interface ProbeOptions {
+    readonly arguments: readonly string[];
+    readonly env: Readonly<NodeJS.ProcessEnv>;
+    readonly directory?: string;
+    readonly milliseconds?: number;
+    readonly bytes?: number;
+}
+export type ProbeRunner = (executable: string, options: ProbeOptions) => Promise<ProbeOutput>;
+export interface ProbeOutput {
+    readonly exitCode?: number | null;
+    readonly stdout: string;
+    readonly reason: string | null;
+}
+export declare function createProbeRunner(effects: ProbeEffects): ProbeRunner;
+export {};

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

@@ -0,0 +1,59 @@
+function killProbe(child, effects) {
+    if (child.pid === undefined)
+        return;
+    try {
+        effects.kill(-child.pid, "SIGKILL");
+    }
+    catch {
+        child.kill("SIGKILL");
+    }
+}
+export function createProbeRunner(effects) {
+    return (executable, options) => executeProbe({ executable, options, effects });
+}
+function executeProbe(input) {
+    const { executable, options, effects } = input;
+    return new Promise((complete) => {
+        const child = effects.spawn({
+            executable,
+            arguments: [...options.arguments],
+            options: {
+                env: options.env,
+                ...(options.directory === undefined ? {} : { cwd: options.directory }),
+                stdio: ["ignore", "pipe", "ignore"],
+                detached: true,
+            },
+        });
+        const chunks = [];
+        let bytes = 0;
+        let reason = null;
+        const stop = (failure) => {
+            if (reason !== null)
+                return;
+            reason = failure;
+            killProbe(child, effects);
+            child.stdout.destroy();
+        };
+        child.stdout.on("data", (chunk) => {
+            bytes += chunk.length;
+            if (bytes > (options.bytes ?? 65536))
+                stop("probe-output-limit");
+            else
+                chunks.push(chunk);
+        });
+        const timer = setTimeout(() => {
+            stop("probe-timeout");
+        }, options.milliseconds ?? 10000);
+        child.once("error", () => {
+            reason ??= "probe-start";
+        });
+        child.once("close", (code) => {
+            clearTimeout(timer);
+            complete({
+                exitCode: code,
+                stdout: Buffer.concat(chunks).toString("utf8"),
+                reason: reason ?? (code === 0 ? null : "probe-exit"),
+            });
+        });
+    });
+}

package/dist/src/cli/project-settings.d.ts

@@ -0,0 +1,4 @@
+import { resolveSettings } from "../project-settings.ts";
+export declare function privateSettingsPath(environment: Readonly<NodeJS.ProcessEnv>, repository: string): string;
+export declare function projectSettings(environment: Readonly<NodeJS.ProcessEnv>, repository: string): ReturnType<typeof resolveSettings>;
+export declare function settingsEnvironment(environment: Readonly<NodeJS.ProcessEnv>, repository: string): Readonly<NodeJS.ProcessEnv>;

package/dist/src/cli/project-settings.js

@@ -0,0 +1,33 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { configurationRoot, resolveSettings } from "../project-settings.js";
+import { repositoryRuntimeName } from "./runtime-directory.js";
+export function privateSettingsPath(environment, repository) {
+    return join(configurationRoot(environment, homedir()), "cloving/projects", `${repositoryRuntimeName(repository)}.json`);
+}
+function read(file) {
+    try {
+        return readFileSync(file.path, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return undefined;
+        throw new Error(`unreadable-config-file: ${file.scope}`, { cause: error });
+    }
+}
+export function projectSettings(environment, repository) {
+    return resolveSettings(environment, {
+        project: read({
+            path: join(repository, ".cloving/config.json"),
+            scope: "project",
+        }),
+        private: read({
+            path: privateSettingsPath(environment, repository),
+            scope: "private",
+        }),
+    });
+}
+export function settingsEnvironment(environment, repository) {
+    return projectSettings(environment, repository).environment;
+}

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

@@ -1,7 +1,9 @@
 import { type Fields } from "../protocol.ts";
+export declare function oneLine(value: unknown): string;
 export declare function errorText(error: Fields): string;
 export declare function runOverview(result: Fields): Fields;
-export declare function statusJson(result: Fields): Fields;
+export declare function queueLines(value: unknown): readonly string[];
+export { statusJson } from "./usage-render.ts";
 export declare function runStatus(result: Fields): readonly string[];
 export declare function decisionLines(decision: unknown): readonly string[];
 export declare function decisionList(result: Fields): readonly string[];