@phreshos/cli 0.1.48 → 0.1.49

package/dist/commands/window.js

@@ -0,0 +1,102 @@
+import { defineCommand } from "../contract/command.js";
+import { option, processOptions, timeoutOption, withJson } from "./options.js";
+import { eventOutput, jsonOutput, windowOutput } from "./schemas.js";
+import { connected, requireProcess } from "./connection.js";
+import { bounded, position, size } from "./input.js";
+import { wait } from "./observation.js";
+import { windowOf, windowView } from "./projection.js";
+export default function windowCommands(root, connect) {
+    const windows = defineCommand(root, {
+        name: "window",
+        description: "inspect and control authoritative Client Windows",
+        guidance: ["A Window belongs to the Client Endpoint of one exact Process."]
+    });
+    defineCommand(windows, state("inspect", "read the complete current Window state"), async ({ options }) => {
+        return await withWindow(connect, options, windowView);
+    });
+    defineCommand(windows, {
+        ...state("move", "change Window position"),
+        options: withJson(...processOptions, option("--x <value>", "horizontal pixels or workspace-relative expression", { mandatory: true }), option("--y <value>", "vertical pixels or workspace-relative expression", { mandatory: true })),
+        examples: ["phresh window move --process main --program terminal --x 50% --y 0"]
+    }, async ({ options }) => withWindow(connect, options, async (process) => {
+        await windowOf(process).move(position(options.x, options.y));
+        return await windowView(process);
+    }));
+    defineCommand(windows, {
+        ...state("resize", "change Window size"),
+        options: withJson(...processOptions, option("--width <value>", "width in pixels or a workspace-relative expression", { mandatory: true }), option("--height <value>", "height in pixels or a workspace-relative expression", { mandatory: true })),
+        examples: ["phresh window resize --process main --program terminal --width 800 --height 600"]
+    }, async ({ options }) => withWindow(connect, options, async (process) => {
+        await windowOf(process).resize(size(options.width, options.height));
+        return await windowView(process);
+    }));
+    defineCommand(windows, {
+        ...state("setGeometry", "change Window position and size atomically"),
+        aliases: ["set-geometry"],
+        options: withJson(...processOptions, option("--x <value>", "horizontal pixels or workspace-relative expression", { mandatory: true }), option("--y <value>", "vertical pixels or workspace-relative expression", { mandatory: true }), option("--width <value>", "width in pixels or a workspace-relative expression", { mandatory: true }), option("--height <value>", "height in pixels or a workspace-relative expression", { mandatory: true })),
+        examples: ["phresh window set-geometry --process main --program terminal --x 0 --y 0 --width 100% --height 100%"]
+    }, async ({ options }) => withWindow(connect, options, async (process) => {
+        await windowOf(process).setGeometry({
+            position: position(options.x, options.y),
+            size: size(options.width, options.height)
+        });
+        return await windowView(process);
+    }));
+    defineCommand(windows, {
+        ...state("minimize", "set Window visibility without changing its order"),
+        options: withJson(...processOptions, option("--restore", "restore rather than minimize the Window")),
+        examples: ["phresh window minimize --process main --program terminal", "phresh window minimize --process main --program terminal --restore"]
+    }, async ({ options }) => withWindow(connect, options, async (process) => {
+        await windowOf(process).minimize(options.restore !== true);
+        return await windowView(process);
+    }));
+    defineCommand(windows, {
+        ...state("changeTitle", "change the human-readable Window title"),
+        aliases: ["change-title"],
+        options: withJson(...processOptions, option("--title <title>", "new Window title", { mandatory: true })),
+        examples: ["phresh window change-title --process main --program terminal --title Shell"]
+    }, async ({ options }) => withWindow(connect, options, async (process) => {
+        await windowOf(process).changeTitle(options.title);
+        return await windowView(process);
+    }));
+    defineCommand(windows, {
+        ...state("raise", "raise the Window within its own layer"),
+        examples: ["phresh window raise --process main --program terminal"]
+    }, async ({ options }) => withWindow(connect, options, async (process) => {
+        await windowOf(process).raise();
+        return await windowView(process);
+    }));
+    defineCommand(windows, {
+        name: "wait",
+        description: "wait for one authoritative Window change",
+        requiresSystem: true,
+        options: withJson(...processOptions, option("--event <event>", "Window event", {
+            mandatory: true,
+            choices: ["move", "resize", "geometry", "minimize", "changeTitle", "front"]
+        }), timeoutOption),
+        output: jsonOutput(eventOutput("The observed Window event"), "One Window event"),
+        examples: ["phresh window wait --process main --program terminal --event geometry --json"]
+    }, async ({ options }) => withWindow(connect, options, async (process) => {
+        return {
+            scope: `window:${process.identity}`,
+            event: options.event,
+            payload: await wait(windowOf(process), options.event, options.timeout === undefined
+                ? undefined
+                : bounded(options.timeout, "--timeout", 1))
+        };
+    }));
+}
+function state(name, description) {
+    return {
+        name,
+        description,
+        requiresSystem: true,
+        options: withJson(...processOptions),
+        output: jsonOutput(windowOutput, "The current Window state")
+    };
+}
+async function withWindow(connect, options, action) {
+    return await connected(connect, async (system) => {
+        return await action(await requireProcess(system, options.process, options.program));
+    });
+}

package/dist/contract/command.js

@@ -0,0 +1,92 @@
+import { Argument, Command, Option } from "commander";
+import { assertValue } from "./schema.js";
+const contracts = new WeakMap();
+/** Register one command from the contract used by help, discovery, and execution. */
+export function defineCommand(parent, contract, execute) {
+    const command = parent.command(contract.name);
+    attachCommandContract(command, contract);
+    for (const alias of contract.aliases ?? [])
+        command.alias(alias);
+    for (const argument of contract.arguments ?? []) {
+        const configured = new Argument(argument.syntax, argument.description);
+        if (argument.choices)
+            configured.choices([...argument.choices]);
+        if (Object.hasOwn(argument, "default"))
+            configured.default(argument.default);
+        command.addArgument(configured);
+    }
+    for (const option of contract.options ?? [])
+        command.addOption(configureOption(option));
+    if (contract.allowUnknownOptions)
+        command.allowUnknownOption();
+    if (execute)
+        command.action(async (...received) => {
+            const owner = received.pop();
+            const options = received.pop();
+            const result = await execute({ arguments: received, options, command: owner });
+            if (contract.output?.format === "json")
+                writeJson(result, contract.output, options.json === true);
+        });
+    return command;
+}
+/** Associate the root command with the same public contract as its descendants. */
+export function attachCommandContract(command, contract) {
+    command.description(contract.description);
+    contracts.set(command, freezeContract(contract));
+    const detail = [...contract.guidance ?? [], ...(contract.examples?.length ? ["", "Examples:", ...contract.examples.map(example => `  ${example}`)] : [])];
+    if (detail.length)
+        command.addHelpText("after", `\n${detail.map(line => line ? `  ${line}` : "").join("\n")}\n`);
+    return command;
+}
+export function readCommandContract(command) {
+    return contracts.get(command);
+}
+/** Reject any Commander node that bypassed the authoritative CLI contract. */
+export function assertCommandContracts(root) {
+    for (const command of descendants(root)) {
+        if (!contracts.has(command))
+            throw new Error(`Command "${pathOf(command).join(" ")}" has no CLI contract`);
+    }
+}
+function configureOption(contract) {
+    const option = new Option(contract.flags, contract.description);
+    if (contract.mandatory)
+        option.makeOptionMandatory();
+    if (contract.choices)
+        option.choices([...contract.choices]);
+    if (contract.parse)
+        option.argParser(contract.parse);
+    if (Object.hasOwn(contract, "default"))
+        option.default(contract.default);
+    return option;
+}
+function freezeContract(contract) {
+    return Object.freeze({
+        ...contract,
+        ...(contract.aliases ? { aliases: Object.freeze([...contract.aliases]) } : {}),
+        ...(contract.arguments ? { arguments: Object.freeze(contract.arguments.map(value => Object.freeze({ ...value }))) } : {}),
+        ...(contract.options ? { options: Object.freeze(contract.options.map(value => Object.freeze({ ...value }))) } : {}),
+        ...(contract.guidance ? { guidance: Object.freeze([...contract.guidance]) } : {}),
+        ...(contract.examples ? { examples: Object.freeze([...contract.examples]) } : {})
+    });
+}
+function descendants(command) {
+    return [command, ...command.commands.flatMap(descendants)];
+}
+function pathOf(command) {
+    const path = [];
+    let current = command;
+    while (current) {
+        path.unshift(current.name());
+        current = current.parent;
+    }
+    return path;
+}
+function writeJson(result, contract, compact) {
+    const normalized = result ?? null;
+    if (contract.value)
+        assertValue(normalized, contract.value);
+    console.log(JSON.stringify(normalized, null, compact ? undefined : 2));
+    if (!compact)
+        console.log();
+}

package/dist/contract/schema.js

@@ -0,0 +1,80 @@
+export const value = Object.freeze({
+    any: (description) => ({ description }),
+    string: (description) => ({ type: "string", description }),
+    number: (description) => ({ type: "number", description }),
+    integer: (description) => ({ type: "integer", description }),
+    boolean: (description) => ({ type: "boolean", description }),
+    literal: (literal, description) => ({
+        ...(literal === null ? { type: "null" } : { type: typeof literal }),
+        enum: [literal],
+        description
+    }),
+    enumeration: (values, description) => ({
+        type: "string",
+        enum: values,
+        description
+    }),
+    array: (items, description) => ({ type: "array", items, description }),
+    object: (properties, required, description, additionalProperties = false) => ({ type: "object", properties, required, additionalProperties, description }),
+    nullable: (schema) => ({ anyOf: [schema, { type: "null" }] })
+});
+/** Validate one emitted JSON value against its declared CLI output contract. */
+export function assertValue(value, contract, path = "result") {
+    if (contract.anyOf) {
+        if (contract.anyOf.some(candidate => accepts(value, candidate)))
+            return;
+        throw new Error(`${path} does not match its CLI contract`);
+    }
+    if (contract.enum && !contract.enum.some(candidate => Object.is(candidate, value))) {
+        throw new Error(`${path} is not one of its declared values`);
+    }
+    if (!contract.type)
+        return;
+    if (contract.type === "null") {
+        if (value !== null)
+            throw new Error(`${path} must be null`);
+        return;
+    }
+    if (contract.type === "array") {
+        if (!Array.isArray(value))
+            throw new Error(`${path} must be an array`);
+        if (contract.items)
+            value.forEach((item, index) => assertValue(item, contract.items, `${path}[${index}]`));
+        return;
+    }
+    if (contract.type === "object") {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error(`${path} must be an object`);
+        const record = value;
+        for (const name of contract.required ?? []) {
+            if (!Object.hasOwn(record, name))
+                throw new Error(`${path}.${name} is required by its CLI contract`);
+        }
+        for (const [name, item] of Object.entries(record)) {
+            const property = contract.properties?.[name];
+            if (property)
+                assertValue(item, property, `${path}.${name}`);
+            else if (contract.additionalProperties === false)
+                throw new Error(`${path}.${name} is not declared by its CLI contract`);
+            else if (typeof contract.additionalProperties === "object")
+                assertValue(item, contract.additionalProperties, `${path}.${name}`);
+        }
+        return;
+    }
+    if (contract.type === "integer") {
+        if (!Number.isInteger(value))
+            throw new Error(`${path} must be an integer`);
+        return;
+    }
+    if (typeof value !== contract.type)
+        throw new Error(`${path} must be ${contract.type}`);
+}
+function accepts(value, contract) {
+    try {
+        assertValue(value, contract);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/system/command.js

@@ -1,48 +1,42 @@
 import SystemLifecycle from "./lifecycle.js";
 import prompts, { ReportedFailure } from "../prompts.js";
 import { accent, caution, dim, negative, positive } from "../style.js";
-import { commandContract } from "../command-contract.js";
+import { defineCommand } from "../contract/command.js";
+import { textOutput } from "../commands/schemas.js";
 /** Attach the System lifecycle without mixing it with Program commands. */
 export default function systemCommands(program, provided) {
     let lifecycle = provided;
     const current = () => lifecycle ?? (lifecycle = new SystemLifecycle());
-    const system = commandContract(program.command("system")
-        .description("install and manage the PhreshOS System"), {
+    const system = defineCommand(program, {
+        name: "system",
+        description: "install and manage the PhreshOS System",
         guidance: [
             "Choose one native System lifecycle operation.",
             "Running-System Programs, Processes, Endpoints, and Windows are top-level capabilities, not System subcommands."
         ]
     });
-    system.command("install")
-        .description("install or update the System and start its service")
-        .action(async function () {
+    defineCommand(system, lifecycleContract("install", "install or update the System and start its service"), async function () {
         const interaction = prompts();
         interaction.begin("Install System", "official stable release");
         const status = await interaction.progress("Installing PhreshOS", "PhreshOS installed", () => current().install());
         interaction.detail("desktop", accent(status.desktop));
         interaction.finish(`PhreshOS ${accent(status.installed?.version ?? "")} installed`);
     });
-    system.command("uninstall")
-        .description("remove the System installation and service")
-        .action(async function () {
+    defineCommand(system, lifecycleContract("uninstall", "remove the System installation and service"), async function () {
         const interaction = prompts();
         interaction.begin("Uninstall System");
         await interaction.progress("Removing PhreshOS", "PhreshOS removed", () => current().uninstall());
         interaction.message("Persistent System data was kept.");
         interaction.finish("System uninstalled");
     });
-    system.command("status")
-        .description("show the System version and operating state")
-        .action(async function () {
+    defineCommand(system, lifecycleContract("status", "show the System version and operating state"), async function () {
         const status = await installed(current());
         const interaction = prompts();
         interaction.begin("System Status");
         report(interaction, status);
         interaction.finish(status.ready ? positive("System ready") : caution("System not ready"));
     });
-    system.command("version")
-        .description("show the installed System version")
-        .action(async function () {
+    defineCommand(system, lifecycleContract("version", "show the installed System version"), async function () {
         const status = await installed(current());
         const interaction = prompts();
         interaction.begin("System Version");
@@ -55,9 +49,7 @@ export default function systemCommands(program, provided) {
     return system;
 }
 function action(system, name, description, current, work) {
-    system.command(name)
-        .description(description)
-        .action(async function () {
+    defineCommand(system, lifecycleContract(name, description), async function () {
         const lifecycle = current();
         await installed(lifecycle);
         const interaction = prompts();
@@ -68,6 +60,13 @@ function action(system, name, description, current, work) {
         interaction.finish(`System ${past(name)}`);
     });
 }
+function lifecycleContract(name, description) {
+    return {
+        name,
+        description,
+        output: textOutput(description)
+    };
+}
 function report(interaction, status) {
     interaction.detail("version", accent(status.installed?.version ?? "unknown"));
     interaction.detail("desktop", accent(status.desktop));

package/dist/template/package.json

@@ -22,7 +22,7 @@
         "react-dom": "^19.2.8"
     },
     "devDependencies": {
-        "@phreshos/cli": "^0.1.48",
+        "@phreshos/cli": "^0.1.49",
         "@types/node": "^26.4.0",
         "@types/react": "^19.2.18",
         "@types/react-dom": "^19.2.5",

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@phreshos/cli",
     "type": "module",
-    "version": "0.1.48",
+    "version": "0.1.49",
     "description": "The Phresh command-line interface for Program projects and system management.",
     "engines": {
         "node": ">=20.10"
@@ -49,8 +49,8 @@
     "packageManager": "bun@1.3.14",
     "dependencies": {
         "@clack/prompts": "^1.7.0",
-        "@phreshos/core": "^0.1.37",
-        "@phreshos/node": "^0.1.13",
+        "@phreshos/core": "^0.1.39",
+        "@phreshos/node": "^0.1.14",
         "adm-zip": "^0.6.0",
         "commander": "^15.0.0",
         "picocolors": "^1.1.1"

package/dist/command-contract.js

@@ -1,12 +0,0 @@
-const contracts = new WeakMap();
-/** Attach machine-readable policy to the same Commander node that owns syntax. */
-export function commandContract(command, contract = {}) {
-    contracts.set(command, Object.freeze({
-        ...contract,
-        ...(contract.guidance ? { guidance: Object.freeze([...contract.guidance]) } : {})
-    }));
-    return command;
-}
-export function readCommandContract(command) {
-    return contracts.get(command);
-}

package/dist/control/endpoint.js

@@ -1,99 +0,0 @@
-import { Option } from "commander";
-import { commandContract } from "../command-contract.js";
-import { clientOverrideOptions, endpointOptions, outputOptions, serverOverrideOptions } from "./options.js";
-import { bounded, clientLaunch, connected, endpoint, endpointView, integer, output, payload, requireProcess, serverLaunch, wait } from "./shared.js";
-export default function endpointCommands(root, connect) {
-    const endpoints = commandContract(root.command("endpoint")
-        .description("inspect, control, and communicate with Process Endpoints"));
-    outputOptions(endpointOptions(endpoints.command("inspect")
-        .description("read whether one Endpoint is declared and running")))
-        .action(async (options) => withEndpoint(connect, options, async (process, name) => {
-        output(await endpointView(process, name), options.compact);
-    }));
-    outputOptions(serverOverrideOptions(clientOverrideOptions(endpointOptions(endpoints.command("start")
-        .description("start a fresh Endpoint incarnation")))))
-        .action(async (options) => withEndpoint(connect, options, async (process, name) => {
-        const client = clientLaunch(options);
-        const server = serverLaunch(options);
-        if (name === "server" && client !== undefined)
-            throw new Error("Client overrides require --endpoint client");
-        if (name === "client" && server !== undefined)
-            throw new Error("Server overrides require --endpoint server");
-        if (name === "client")
-            await process.client.start(typeof client === "object" ? client : undefined);
-        else
-            await process.server.start(typeof server === "object" ? server : undefined);
-        output(await endpointView(process, name), options.compact);
-    }));
-    outputOptions(endpointOptions(endpoints.command("stop")
-        .description("stop one Endpoint")))
-        .action(async (options) => withEndpoint(connect, options, async (process, name) => {
-        await endpoint(process, name).stop();
-        output(await endpointView(process, name), options.compact);
-    }));
-    outputOptions(endpointOptions(endpoints.command("waitReady")
-        .alias("wait-ready")
-        .description("wait until the Server Endpoint reports readiness")
-        .option("--timeout <milliseconds>", "maximum wait in milliseconds", integer)))
-        .action(async (options) => withEndpoint(connect, options, async (process, name) => {
-        if (name !== "server")
-            throw new Error("waitReady requires --endpoint server");
-        await process.server.waitReady(timeout(options.timeout));
-        output(await endpointView(process, "server"), options.compact);
-    }));
-    outputOptions(endpointOptions(endpoints.command("waitLifecycle")
-        .alias("wait-lifecycle")
-        .description("wait for one lifecycle transition of an exact Endpoint")
-        .addOption(new Option("--event <event>", "Endpoint lifecycle event")
-        .choices(["start", "stop"])
-        .makeOptionMandatory())
-        .option("--timeout <milliseconds>", "maximum wait in milliseconds", integer)))
-        .action(async (options) => withEndpoint(connect, options, async (process, name) => {
-        await wait(endpoint(process, name).lifecycle, options.event, timeout(options.timeout));
-        output({
-            scope: `endpoint:${process.identity}:${name}:lifecycle`,
-            event: options.event
-        }, options.compact);
-    }));
-    outputOptions(endpointOptions(endpoints.command("ask")
-        .description("ask a Server event and return its answer")
-        .requiredOption("--event <event>", "event name")
-        .option("--payload <json>", "arbitrary event payload as JSON")
-        .option("--timeout <milliseconds>", "maximum wait in milliseconds", integer)))
-        .action(async (options) => withEndpoint(connect, options, async (process, name) => {
-        if (name !== "server")
-            throw new Error("ask requires --endpoint server");
-        const value = payload(options.payload);
-        const answer = options.timeout === undefined
-            ? await process.server.ask(options.event, value)
-            : await process.server.timeout(timeout(options.timeout)).ask(options.event, value);
-        output(answer, options.compact);
-    }));
-    outputOptions(endpointOptions(endpoints.command("publish")
-        .description("publish one event without waiting for an answer")
-        .requiredOption("--event <event>", "event name")
-        .option("--payload <json>", "arbitrary event payload as JSON")))
-        .action(async (options) => withEndpoint(connect, options, async (process, name) => {
-        endpoint(process, name).publish(options.event, payload(options.payload));
-        output(await endpointView(process, name), options.compact);
-    }));
-    outputOptions(endpointOptions(endpoints.command("wait")
-        .description("wait for the next event emitted by one live Endpoint")
-        .requiredOption("--event <event>", "event name")
-        .option("--timeout <milliseconds>", "maximum wait in milliseconds", integer)))
-        .action(async (options) => withEndpoint(connect, options, async (process, name) => {
-        output({
-            scope: `endpoint:${process.identity}:${name}`,
-            event: options.event,
-            payload: await wait(endpoint(process, name), options.event, timeout(options.timeout))
-        }, options.compact);
-    }));
-}
-async function withEndpoint(connect, options, action) {
-    await connected(connect, async (system) => {
-        await action(await requireProcess(system, options.process, options.program), options.endpoint);
-    });
-}
-function timeout(value) {
-    return value === undefined ? undefined : bounded(value, "--timeout", 1);
-}

package/dist/control/options.js

@@ -1,44 +0,0 @@
-import { Option } from "commander";
-import { collect } from "./shared.js";
-export function outputOptions(command) {
-    return command.option("--compact", "write machine-readable JSON on one line");
-}
-export function processOptions(command) {
-    return command
-        .requiredOption("--process <identity>", "Process identity or Program-local name")
-        .option("--program <identity>", "owning Program identity when resolving a Process name");
-}
-export function endpointOptions(command) {
-    return processOptions(command)
-        .addOption(new Option("--endpoint <endpoint>", "Endpoint kind").choices(["server", "client"]).makeOptionMandatory());
-}
-export function clientOptions(command) {
-    return clientOverrideOptions(command)
-        .option("--client", "start the Client Endpoint")
-        .option("--no-client", "do not start the Client Endpoint");
-}
-export function clientOverrideOptions(command) {
-    return command
-        .option("--client-service", "address this Client incarnation through system.service()")
-        .option("--no-client-service", "do not address this Client incarnation through system.service()")
-        .option("--client-title <title>", "initial Window title")
-        .option("--client-width <value>", "initial Window width")
-        .option("--client-height <value>", "initial Window height")
-        .option("--client-x <value>", "initial Window horizontal position")
-        .option("--client-y <value>", "initial Window vertical position")
-        .addOption(new Option("--client-layer <layer>", "initial Window layer").choices(["window", "under", "over"]))
-        .option("--client-location <location>", "initial page beneath the Client location")
-        .option("--client-minimized", "open the Window minimized");
-}
-export function serverOverrideOptions(command) {
-    return command
-        .option("--server-service", "address this Server incarnation through system.service()")
-        .option("--no-server-service", "do not address this Server incarnation through system.service()");
-}
-export function launchOptions(command) {
-    return serverOverrideOptions(clientOptions(command))
-        .option("--name <name>", "stable Program-local Process name")
-        .option("--server", "start the Server Endpoint")
-        .option("--no-server", "do not start the Server Endpoint")
-        .option("--option <name=value>", "immutable Process option; repeat for more values", collect, []);
-}

package/dist/control/process.js

@@ -1,86 +0,0 @@
-import { Option } from "commander";
-import { commandContract } from "../command-contract.js";
-import { launchOptions, outputOptions, processOptions } from "./options.js";
-import { bounded, connected, integer, launch, output, page, processView, requireProcess, requireProgram, wait } from "./shared.js";
-export default function processCommands(root, connect) {
-    const process = commandContract(root.command("process")
-        .description("discover and control live Program executions"));
-    outputOptions(process.command("list")
-        .description("list live Processes with bounded filtering")
-        .option("--program <identity>", "restrict results to one Program")
-        .option("--search <text>", "case-insensitive identity or name search")
-        .option("--limit <count>", "maximum returned Processes", integer, 30)
-        .option("--offset <count>", "number of matching Processes to skip", integer, 0))
-        .action(async (options) => connected(connect, async (system) => {
-        const processes = options.program
-            ? await (await requireProgram(system, options.program)).process.list()
-            : await system.process.list();
-        const selected = page(processes, options.search, bounded(options.offset, "--offset", 0), bounded(options.limit, "--limit", 1, 100), value => `${value.identity}\n${value.name ?? ""}`);
-        output({ ...selected, data: await Promise.all(selected.data.map(processView)) }, options.compact);
-    }));
-    outputOptions(processOptions(process.command("inspect")
-        .description("read one live Process and its Endpoint state")))
-        .action(async (options) => connected(connect, async (system) => {
-        output(await processView(await requireProcess(system, options.process, options.program)), options.compact);
-    }));
-    outputOptions(launchOptions(process.command("create")
-        .description("create a Process")
-        .requiredOption("--program <identity>", "owning Program identity")))
-        .action(async (options) => connected(connect, async (system) => {
-        const program = await requireProgram(system, options.program);
-        output(await processView(await program.process.create(launch(options))), options.compact);
-    }));
-    outputOptions(launchOptions(process.command("findOrCreate")
-        .alias("find-or-create")
-        .description("find the named Process or create it atomically")
-        .requiredOption("--program <identity>", "owning Program identity")))
-        .action(async (options) => connected(connect, async (system) => {
-        const program = await requireProgram(system, options.program);
-        output(await processView(await program.process.findOrCreate(launch(options, true))), options.compact);
-    }));
-    outputOptions(processOptions(process.command("exit")
-        .description("exit one Process and all of its live Endpoints")))
-        .action(async (options) => connected(connect, async (system) => {
-        const process = await requireProcess(system, options.process, options.program);
-        const snapshot = await processView(process);
-        await process.exit();
-        output(snapshot, options.compact);
-    }));
-    outputOptions(process.command("wait")
-        .description("wait for one Process lifecycle event")
-        .addOption(new Option("--event <event>", "Process lifecycle event")
-        .choices(["create", "exit"])
-        .makeOptionMandatory())
-        .option("--process <identity>", "scope the event to one Process")
-        .option("--program <identity>", "scope the event to one Program")
-        .option("--timeout <milliseconds>", "maximum wait in milliseconds", integer))
-        .action(async (options) => connected(connect, async (system) => {
-        if (options.process && options.event === "create")
-            throw new Error("An individual Process does not emit create");
-        const target = options.process
-            ? await requireProcess(system, options.process, options.program)
-            : options.program
-                ? (await requireProgram(system, options.program)).process
-                : system.process;
-        const message = await wait(target, options.event, options.timeout === undefined
-            ? undefined
-            : bounded(options.timeout, "--timeout", 1));
-        output({
-            scope: options.process ? `process:${options.process}` : options.program ? `program:${options.program}` : "process",
-            event: options.event,
-            payload: await eventView(options.event, message, options.process ? target : undefined)
-        }, options.compact);
-    }));
-}
-async function eventView(event, message, scoped) {
-    if (event === "create")
-        return processView(message);
-    const exit = message;
-    const process = exit.process ?? scoped;
-    return {
-        ...(process ? { process: await processView(process) } : {}),
-        status: exit.status,
-        code: exit.code,
-        signal: exit.signal
-    };
-}