@phreshos/cli 0.1.62 → 0.1.64

package/README.md

@@ -14,8 +14,8 @@ It owns command parsing, terminal output, packaging presentation, System release
 acquisition, and native service management.
 
 The CLI owns its command contract. Runtime command executors use
-`@phreshos/node` and its shared System domain handles; the CLI does not define a
-second System interface or transport request language.
+`@phreshos/node` and Core's shared Execute operation catalog; the CLI does not
+define a second System interface or transport request language.
 
 ## Installation
 
@@ -34,6 +34,7 @@ phresh dev
 phresh install
 phresh system status
 phresh program list
+phresh execute '{"$domain":"operation","$operation":"list"}'
 ```
 
 Use `phresh describe` to inspect a command, or `phresh describe --all --json`
@@ -41,9 +42,9 @@ to read the complete machine-discoverable contract. See the
 [CLI documentation](https://docs.phreshos.com/sdks/cli) for Program project,
 System, and runtime commands.
 
-Runtime commands render responsive tables or labeled fields for people by
-default. Add `--json` to receive the complete result as one JSON value for
-automation.
+Runtime commands render direct lists or labeled fields for people by default.
+Add `--json` to receive the complete result as one JSON value for automation.
+`phresh execute` accepts and returns JSON directly.
 
 ## Development
 

package/dist/commands/access.js

@@ -3,8 +3,12 @@ import processCommands from "./process.js";
 import programCommands from "./program.js";
 import { connectSystem } from "./connection.js";
 import windowCommands from "./window.js";
+import executeCommand from "./execute.js";
+import operationCommands from "./operation.js";
 /** Expose the shared System domains through explicit Node SDK executors. */
 export default function accessCommands(program, connect = connectSystem) {
+    executeCommand(program, connect);
+    operationCommands(program, connect);
     programCommands(program, connect);
     processCommands(program, connect);
     endpointCommands(program, connect);

package/dist/commands/endpoint.js

@@ -1,11 +1,11 @@
+import { parseExecuteRequest } from "@phreshos/core";
 import { defineCommand } from "../contract/command.js";
 import { value } from "../contract/schema.js";
 import { clientOverrideOptions, endpointOptions, option, serverOverrideOptions, timeoutOption, withJson } from "./options.js";
 import { dataOutput, endpointActionPresentation, endpointOutput, endpointPresentation, eventOutput, eventPresentation, lifecyclePresentation, valuePresentation } from "./schemas.js";
-import { connected, requireProcess } from "./connection.js";
+import { connected } from "./connection.js";
 import { bounded, clientLaunch, payload, serverLaunch } from "./input.js";
-import { wait } from "./observation.js";
-import { endpoint, endpointView } from "./projection.js";
+import { executeDescription } from "./execution.js";
 export default function endpointCommands(root, connect) {
     const endpoints = defineCommand(root, {
         name: "endpoint",
@@ -14,63 +14,55 @@ export default function endpointCommands(root, connect) {
     });
     defineCommand(endpoints, {
         name: "inspect",
-        description: "read whether one Endpoint is declared and running",
+        description: executeDescription("endpoint", "inspect"),
         requiresSystem: true,
         options: withJson(...endpointOptions),
         output: dataOutput(endpointOutput, "The selected Endpoint", endpointPresentation),
         examples: ["phresh endpoint inspect --process main --program terminal --endpoint server"]
-    }, async ({ options }) => withEndpoint(connect, options, async (process, name) => {
-        return await endpointView(process, name);
-    }));
+    }, async ({ options }) => executeEndpoint(connect, options, { $operation: "inspect" }));
     defineCommand(endpoints, {
         name: "start",
-        description: "start a fresh Endpoint incarnation",
+        description: executeDescription("endpoint", "start"),
         requiresSystem: true,
         options: withJson(...endpointOptions, ...clientOverrideOptions, ...serverOverrideOptions),
         output: dataOutput(endpointOutput, "The started Endpoint", endpointActionPresentation),
         examples: ["phresh endpoint start --process main --program terminal --endpoint server --server-service"]
-    }, async ({ options }) => withEndpoint(connect, options, async (process, name) => {
+    }, async ({ options }) => {
         const client = clientLaunch(options);
         const server = serverLaunch(options);
-        if (name === "server" && client !== undefined)
+        if (options.endpoint === "server" && client !== undefined)
             throw new Error("Client overrides require --endpoint client");
-        if (name === "client" && server !== undefined)
+        if (options.endpoint === "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);
-        return await endpointView(process, name);
-    }));
+        const launch = options.endpoint === "client"
+            ? typeof client === "object" ? client : undefined
+            : typeof server === "object" ? server : undefined;
+        return executeEndpoint(connect, options, { $operation: "start", ...(launch ? { launch } : {}) });
+    });
     defineCommand(endpoints, {
         name: "stop",
-        description: "stop one Endpoint",
+        description: executeDescription("endpoint", "stop"),
         requiresSystem: true,
         options: withJson(...endpointOptions),
         output: dataOutput(endpointOutput, "The stopped Endpoint", endpointActionPresentation),
         examples: ["phresh endpoint stop --process main --program terminal --endpoint client"]
-    }, async ({ options }) => withEndpoint(connect, options, async (process, name) => {
-        await endpoint(process, name).stop();
-        return await endpointView(process, name);
-    }));
+    }, async ({ options }) => executeEndpoint(connect, options, { $operation: "stop" }));
     defineCommand(endpoints, {
         name: "waitReady",
         aliases: ["wait-ready"],
-        description: "wait until the Server Endpoint reports readiness",
+        description: executeDescription("endpoint", "waitReady"),
         requiresSystem: true,
         options: withJson(...endpointOptions, timeoutOption),
         output: dataOutput(endpointOutput, "The ready Server Endpoint", endpointActionPresentation),
         examples: ["phresh endpoint wait-ready --process main --program terminal --endpoint server --timeout 30000"]
-    }, 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));
-        return await endpointView(process, "server");
+    }, async ({ options }) => executeEndpoint(connect, options, {
+        $operation: "waitReady",
+        ...(options.timeout === undefined ? {} : { timeout: timeout(options.timeout) })
     }));
     defineCommand(endpoints, {
         name: "waitLifecycle",
         aliases: ["wait-lifecycle"],
-        description: "wait for one lifecycle transition of an exact Endpoint",
+        description: executeDescription("endpoint", "waitLifecycle"),
         requiresSystem: true,
         options: withJson(...endpointOptions, option("--event <event>", "Endpoint lifecycle event", { mandatory: true, choices: ["start", "stop"] }), timeoutOption),
         output: dataOutput(value.object({
@@ -78,56 +70,61 @@ export default function endpointCommands(root, connect) {
             event: value.enumeration(["start", "stop"], "observed lifecycle event")
         }, ["scope", "event"], "Endpoint lifecycle event"), "One Endpoint lifecycle event", lifecyclePresentation),
         examples: ["phresh endpoint wait-lifecycle --process main --program terminal --endpoint server --event start"]
-    }, async ({ options }) => withEndpoint(connect, options, async (process, name) => {
-        await wait(endpoint(process, name).lifecycle, options.event, timeout(options.timeout));
-        return { scope: `endpoint:${process.identity}:${name}:lifecycle`, event: options.event };
+    }, async ({ options }) => executeEndpoint(connect, options, {
+        $operation: "waitLifecycle",
+        event: options.event,
+        ...(options.timeout === undefined ? {} : { timeout: timeout(options.timeout) })
     }));
     defineCommand(endpoints, {
         name: "ask",
-        description: "ask a Server event and return its answer",
+        description: executeDescription("endpoint", "ask"),
         requiresSystem: true,
         options: withJson(...endpointOptions, option("--event <event>", "event name", { mandatory: true }), option("--payload <json>", "arbitrary event payload as JSON"), timeoutOption),
         output: dataOutput(value.any("answer returned by the Server event contract"), "The Server answer", valuePresentation),
         examples: ["phresh endpoint ask --process main --program terminal --endpoint server --event status --json"]
-    }, async ({ options }) => withEndpoint(connect, options, async (process, name) => {
-        if (name !== "server")
-            throw new Error("ask requires --endpoint server");
+    }, async ({ options }) => {
         const input = payload(options.payload);
-        const answer = options.timeout === undefined
-            ? await process.server.ask(options.event, input)
-            : await process.server.timeout(timeout(options.timeout)).ask(options.event, input);
-        return answer;
-    }));
+        return executeEndpoint(connect, options, {
+            $operation: "ask",
+            event: options.event,
+            ...(options.payload === undefined ? {} : { input }),
+            ...(options.timeout === undefined ? {} : { timeout: timeout(options.timeout) })
+        });
+    });
     defineCommand(endpoints, {
         name: "publish",
-        description: "publish one event without waiting for an answer",
+        description: executeDescription("endpoint", "publish"),
         requiresSystem: true,
         options: withJson(...endpointOptions, option("--event <event>", "event name", { mandatory: true }), option("--payload <json>", "arbitrary event payload as JSON")),
         output: dataOutput(endpointOutput, "The Endpoint after publishing", endpointActionPresentation),
         examples: ["phresh endpoint publish --process main --program terminal --endpoint client --event changed --payload '{\"value\":1}'"]
-    }, async ({ options }) => withEndpoint(connect, options, async (process, name) => {
-        endpoint(process, name).publish(options.event, payload(options.payload));
-        return await endpointView(process, name);
+    }, async ({ options }) => executeEndpoint(connect, options, {
+        $operation: "publish",
+        event: options.event,
+        ...(options.payload === undefined ? {} : { input: payload(options.payload) })
     }));
     defineCommand(endpoints, {
         name: "wait",
-        description: "wait for the next event emitted by one live Endpoint",
+        description: executeDescription("endpoint", "wait"),
         requiresSystem: true,
         options: withJson(...endpointOptions, option("--event <event>", "event name", { mandatory: true }), timeoutOption),
         output: dataOutput(eventOutput("The observed Endpoint event"), "One Endpoint event", eventPresentation),
         examples: ["phresh endpoint wait --process main --program terminal --endpoint client --event changed --json"]
-    }, async ({ options }) => withEndpoint(connect, options, async (process, name) => {
-        return {
-            scope: `endpoint:${process.identity}:${name}`,
-            event: options.event,
-            payload: await wait(endpoint(process, name), options.event, timeout(options.timeout))
-        };
+    }, async ({ options }) => executeEndpoint(connect, options, {
+        $operation: "wait",
+        event: options.event,
+        ...(options.timeout === undefined ? {} : { timeout: timeout(options.timeout) })
     }));
 }
-async function withEndpoint(connect, options, action) {
-    return await connected(connect, async (system) => {
-        return await action(await requireProcess(system, options.process, options.program), options.endpoint);
+async function executeEndpoint(connect, options, operation) {
+    const request = parseExecuteRequest({
+        $domain: "endpoint",
+        ...operation,
+        process: options.process,
+        ...(options.program ? { program: options.program } : {}),
+        endpoint: options.endpoint
     });
+    return connected(connect, system => system.execute(request));
 }
 function timeout(value) {
     return value === undefined ? undefined : bounded(value, "--timeout", 1);

package/dist/commands/execute.js

@@ -0,0 +1,30 @@
+import { parseExecuteRequest } from "@phreshos/core";
+import { defineCommand } from "../contract/command.js";
+import { value } from "../contract/schema.js";
+import { connected } from "./connection.js";
+import { dataOutput } from "./schemas.js";
+/** Expose the shared SDK Execute adapter as an exact JSON interface. */
+export default function executeCommand(root, connect) {
+    defineCommand(root, {
+        name: "execute",
+        description: "execute one raw JSON operation through the Node SDK",
+        arguments: [{ syntax: "<request>", description: "Execute request encoded as JSON" }],
+        guidance: ["Use operation.list and operation.describe to discover the available request contracts."],
+        examples: [
+            "phresh execute '{\"$domain\":\"operation\",\"$operation\":\"list\"}'",
+            "phresh execute '{\"$domain\":\"endpoint\",\"$operation\":\"ask\",\"program\":\"tilo\",\"process\":\"main\",\"endpoint\":\"server\",\"event\":\"board.list\",\"input\":null}'"
+        ],
+        output: dataOutput(value.any("JSON result returned by the selected Execute operation"), "Execute result", { format: "json" }),
+        requiresSystem: true
+    }, async ({ arguments: [source] }) => {
+        let value;
+        try {
+            value = JSON.parse(source);
+        }
+        catch {
+            throw new Error("The Execute request must be valid JSON");
+        }
+        const request = parseExecuteRequest(value);
+        return connected(connect, system => system.execute(request));
+    });
+}

package/dist/commands/execution.js

@@ -0,0 +1,44 @@
+import { describeExecuteOperation } from "@phreshos/core";
+/** Human-facing CLI path for every operation in Core's Execute catalog. */
+export const executeCommandPaths = Object.freeze({
+    "operation.list": ["operation", "list"],
+    "operation.describe": ["operation", "describe"],
+    "program.list": ["program", "list"],
+    "program.find": ["program", "inspect"],
+    "program.agent": ["program", "agent"],
+    "program.getLaunch": ["program", "getLaunch"],
+    "program.setLaunch": ["program", "setLaunch"],
+    "program.logs": ["program", "logs"],
+    "program.wait": ["program", "wait"],
+    "process.list": ["process", "list"],
+    "process.find": ["process", "inspect"],
+    "process.create": ["process", "create"],
+    "process.findOrCreate": ["process", "findOrCreate"],
+    "process.exit": ["process", "exit"],
+    "process.wait": ["process", "wait"],
+    "endpoint.inspect": ["endpoint", "inspect"],
+    "endpoint.start": ["endpoint", "start"],
+    "endpoint.stop": ["endpoint", "stop"],
+    "endpoint.waitReady": ["endpoint", "waitReady"],
+    "endpoint.ask": ["endpoint", "ask"],
+    "endpoint.publish": ["endpoint", "publish"],
+    "endpoint.wait": ["endpoint", "wait"],
+    "endpoint.waitLifecycle": ["endpoint", "waitLifecycle"],
+    "window.inspect": ["window", "inspect"],
+    "window.move": ["window", "move"],
+    "window.resize": ["window", "resize"],
+    "window.setGeometry": ["window", "setGeometry"],
+    "window.minimize": ["window", "minimize"],
+    "window.maximize": ["window", "maximize"],
+    "window.changeTitle": ["window", "changeTitle"],
+    "window.changeHeader": ["window", "changeHeader"],
+    "window.raise": ["window", "raise"],
+    "window.wait": ["window", "wait"]
+});
+/** Read command language from the same catalog that defines raw execution. */
+export function executeDescription(domain, operation) {
+    const description = describeExecuteOperation(domain, operation);
+    if (!description)
+        throw new Error(`Unknown Execute operation ${domain}.${operation}`);
+    return description.description;
+}

package/dist/commands/input.js

@@ -2,11 +2,14 @@ import { parseLaunch } from "@phreshos/core";
 export function payload(value) {
     if (value === undefined)
         return undefined;
+    return json(value, "--payload");
+}
+export function json(value, name) {
     try {
         return JSON.parse(value);
     }
     catch {
-        throw new Error("--payload must be valid JSON");
+        throw new Error(`${name} must be valid JSON`);
     }
 }
 export function metric(value) {

package/dist/commands/operation.js

@@ -0,0 +1,65 @@
+import { defineCommand } from "../contract/command.js";
+import { value } from "../contract/schema.js";
+import { connected } from "./connection.js";
+import { executeDescription } from "./execution.js";
+import { option, withJson } from "./options.js";
+import { dataOutput, valuePresentation } from "./schemas.js";
+const summary = value.object({
+    domain: value.string("operation domain"),
+    operation: value.string("operation name"),
+    description: value.string("operation meaning")
+}, ["domain", "operation", "description"], "Execute operation");
+const description = value.object({
+    domain: value.string("operation domain"),
+    operation: value.string("operation name"),
+    description: value.string("operation meaning"),
+    request: value.any("request JSON Schema"),
+    result: value.any("successful result JSON Schema")
+}, ["domain", "operation", "description", "request", "result"], "Execute operation contract");
+export default function operationCommands(root, connect) {
+    const operations = defineCommand(root, {
+        name: "operation",
+        description: "discover operations available through Execute"
+    });
+    defineCommand(operations, {
+        name: "list",
+        description: executeDescription("operation", "list"),
+        requiresSystem: true,
+        options: withJson(option("--domain <domain>", "restrict results to one operation domain")),
+        output: dataOutput(value.array(summary, "Execute operations"), "Available Execute operations", {
+            format: "list",
+            rows: "",
+            fields: [
+                { label: "Domain", path: "domain" },
+                { label: "Operation", path: "operation" },
+                { label: "Description", path: "description" }
+            ],
+            item: "Operation",
+            items: "Operations",
+            empty: "No matching operations"
+        }),
+        examples: ["phresh operation list", "phresh operation list --domain endpoint --json"]
+    }, ({ options }) => connected(connect, system => system.execute({
+        $domain: "operation",
+        $operation: "list",
+        ...(options.domain ? { domain: options.domain } : {})
+    })));
+    defineCommand(operations, {
+        name: "describe",
+        description: executeDescription("operation", "describe"),
+        requiresSystem: true,
+        options: withJson(option("--domain <domain>", "operation domain", { mandatory: true }), option("--operation <operation>", "operation name", { mandatory: true })),
+        output: dataOutput(description, "Execute operation contract", valuePresentation),
+        examples: ["phresh operation describe --domain endpoint --operation ask --json"]
+    }, ({ options }) => connected(connect, async (system) => {
+        const result = await system.execute({
+            $domain: "operation",
+            $operation: "describe",
+            domain: options.domain,
+            operation: options.operation
+        });
+        if (!result)
+            throw new Error(`Unknown Execute operation ${options.domain}.${options.operation}`);
+        return result;
+    }));
+}

package/dist/commands/process.js

@@ -2,10 +2,9 @@ import { defineCommand } from "../contract/command.js";
 import { value } from "../contract/schema.js";
 import { launchOptions, namedLaunchOptions, option, processOptions, timeoutOption, withJson } from "./options.js";
 import { dataOutput, eventOutput, eventPresentation, pageOutput, processActionPresentation, processIdentityPresentation, processListPresentation, processOutput, processPresentation } from "./schemas.js";
-import { connected, requireProcess, requireProgram } from "./connection.js";
+import { connected } from "./connection.js";
 import { bounded, integer, launch, page } from "./input.js";
-import { wait } from "./observation.js";
-import { processView } from "./projection.js";
+import { executeDescription } from "./execution.js";
 export default function processCommands(root, connect) {
     const processes = defineCommand(root, {
         name: "process",
@@ -14,99 +13,97 @@ export default function processCommands(root, connect) {
     });
     defineCommand(processes, {
         name: "list",
-        description: "list live Processes with bounded filtering",
+        description: executeDescription("process", "list"),
         requiresSystem: true,
         options: withJson(option("--program <identity>", "restrict results to one Program"), option("--search <text>", "case-insensitive identity or name search"), option("--limit <count>", "maximum returned Processes", { parse: value => integer(value), default: 30 }), option("--offset <count>", "number of matching Processes to skip", { parse: value => integer(value), default: 0 })),
         output: dataOutput(pageOutput(processOutput, "matching Processes"), "A bounded page of Processes", processListPresentation),
         examples: ["phresh process list", "phresh process list --program terminal --json"]
     }, async ({ options }) => connected(connect, async (system) => {
-        const processes = options.program
-            ? await (await requireProgram(system, options.program)).processes()
-            : await system.process.list();
+        const processes = await system.execute({
+            $domain: "process",
+            $operation: "list",
+            ...(options.program ? { program: options.program } : {})
+        });
         const selected = page(processes, options.search, bounded(options.offset, "--offset", 0), bounded(options.limit, "--limit", 1, 100), current => `${current.identity}\n${current.name ?? ""}`);
-        return { ...selected, data: await Promise.all(selected.data.map(processView)) };
+        return selected;
     }));
     defineCommand(processes, {
         name: "inspect",
-        description: "read one live Process and its Endpoint state",
+        description: executeDescription("process", "find"),
         requiresSystem: true,
         options: withJson(...processOptions),
         output: dataOutput(processOutput, "The selected Process", processPresentation),
         examples: ["phresh process inspect --process main --program terminal"]
     }, async ({ options }) => connected(connect, async (system) => {
-        return await processView(await requireProcess(system, options.process, options.program));
+        const process = await system.execute({
+            $domain: "process",
+            $operation: "find",
+            process: options.process,
+            ...(options.program ? { program: options.program } : {})
+        });
+        if (!process)
+            throw new Error(`Unknown Process "${options.process}"`);
+        return process;
     }));
     defineCommand(processes, {
         name: "create",
-        description: "create a Process",
+        description: executeDescription("process", "create"),
         requiresSystem: true,
         options: withJson(option("--program <identity>", "owning Program identity", { mandatory: true }), ...launchOptions),
         output: dataOutput(processOutput, "The created Process", processActionPresentation),
         examples: ["phresh process create --program terminal --server --client", "phresh process create --program terminal --name main --json"]
     }, async ({ options }) => connected(connect, async (system) => {
-        const program = await requireProgram(system, options.program);
-        return await processView(await program.createProcess(launch(options)));
+        return system.execute({
+            $domain: "process",
+            $operation: "create",
+            program: options.program,
+            launch: launch(options)
+        });
     }));
     defineCommand(processes, {
         name: "findOrCreate",
         aliases: ["find-or-create"],
-        description: "find the named Process or create it atomically",
+        description: executeDescription("process", "findOrCreate"),
         requiresSystem: true,
         options: withJson(option("--program <identity>", "owning Program identity", { mandatory: true }), ...namedLaunchOptions),
         output: dataOutput(processOutput, "The existing or created Process", processActionPresentation),
         examples: ["phresh process find-or-create --program terminal --name main --json"]
     }, async ({ options }) => connected(connect, async (system) => {
-        const program = await requireProgram(system, options.program);
-        return await processView(await program.findOrCreateProcess(launch(options, true)));
+        return system.execute({
+            $domain: "process",
+            $operation: "findOrCreate",
+            program: options.program,
+            launch: launch(options, true)
+        });
     }));
     defineCommand(processes, {
         name: "exit",
-        description: "exit one Process and all of its live Endpoints",
+        description: executeDescription("process", "exit"),
         requiresSystem: true,
         options: withJson(...processOptions),
         output: dataOutput(processOutput, "The Process state immediately before exit", processIdentityPresentation),
         examples: ["phresh process exit --process main --program terminal"]
     }, async ({ options }) => connected(connect, async (system) => {
-        const process = await requireProcess(system, options.process, options.program);
-        const snapshot = await processView(process);
-        await process.exit();
-        return snapshot;
+        return system.execute({
+            $domain: "process",
+            $operation: "exit",
+            process: options.process,
+            ...(options.program ? { program: options.program } : {})
+        });
     }));
     defineCommand(processes, {
         name: "wait",
-        description: "wait for one Process lifecycle event",
+        description: executeDescription("process", "wait"),
         requiresSystem: true,
         options: withJson(option("--event <event>", "Process lifecycle event", { mandatory: true, choices: ["create", "exit"] }), option("--process <identity>", "scope the event to one Process"), option("--program <identity>", "scope the event to one Program"), timeoutOption),
         output: dataOutput(eventOutput("The observed Process event", value.any("Process state or exit result")), "One Process event", eventPresentation),
         examples: ["phresh process wait --event create", "phresh process wait --event exit --process main --program terminal --json"]
-    }, async ({ options }) => connected(connect, async (system) => {
-        if (options.process && options.event === "create")
-            throw new Error("An individual Process does not emit create");
-        const timeout = options.timeout === undefined ? undefined : bounded(options.timeout, "--timeout", 1);
-        const target = options.process
-            ? await requireProcess(system, options.process, options.program)
-            : options.program
-                ? await requireProgram(system, options.program)
-                : system.process;
-        const message = options.program && !options.process
-            ? await wait(target, options.event === "create" ? "processCreate" : "processExit", timeout)
-            : await wait(target, options.event, timeout);
-        return {
-            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)
-        };
-    }));
-}
-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
-    };
+    }, async ({ options }) => connected(connect, system => system.execute({
+        $domain: "process",
+        $operation: "wait",
+        event: options.event,
+        ...(options.process ? { process: options.process } : {}),
+        ...(options.program ? { program: options.program } : {}),
+        ...(options.timeout === undefined ? {} : { timeout: bounded(options.timeout, "--timeout", 1) })
+    })));
 }