@phreshos/cli 0.1.48 → 0.1.50

package/README.md

@@ -1,11 +1,21 @@
 # `@phreshos/cli`
 
-The `phresh` command for creating and operating Programs and managing the
-PhreshOS System on the current machine.
+The `phresh` command for Program projects, runtime operations, and PhreshOS
+System management.
 
-The CLI uses the same public System interface as the Node and Server SDKs. It
-adds command parsing, terminal presentation, project workflows, packaging, and
-native service management.
+[Documentation](https://docs.phreshos.com/sdks/cli) ·
+[Installation](https://docs.phreshos.com/installation) ·
+[Source](https://github.com/PhreshOS/cli)
+
+## Role
+
+The CLI presents public Project and System operations as human-facing commands.
+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.
 
 ## Installation
 
@@ -18,61 +28,18 @@ native service management.
 
 Node.js 20.10 or newer is required.
 
-## Program projects
-
 ```sh
 phresh create
-phresh init
 phresh dev
-phresh start
 phresh install
-phresh uninstall
-phresh pack
-```
-
-`create` produces the official starter Program. The remaining commands operate
-on the current Program project through the Node Project contract and present
-its build, development, installation, and runtime lifecycles.
-
-## System
-
-```sh
-phresh system install
 phresh system status
-phresh system start
-phresh system stop
-phresh system enable
-phresh system disable
-phresh system uninstall
-```
-
-System installation acquires and verifies the official release archive and
-configures the native per-user service. Starting and stopping control current
-execution; enabling and disabling control automatic startup.
-
-## Runtime
-
-```sh
 phresh program list
-phresh process list --program my-program
-phresh endpoint inspect \
-  --program my-program \
-  --process main \
-  --endpoint server
-phresh window inspect --program my-program --process main
-```
-
-The command hierarchy follows the runtime ownership hierarchy. Unknown
-commands, flags, and malformed values reject rather than being guessed.
-
-```sh
-phresh describe
-phresh describe program
-phresh describe process list
 ```
 
-`describe` exposes the command tree and exact options as machine-readable
-contracts.
+Use `phresh describe` to inspect a command, or `phresh describe --all --json`
+to read the complete machine-discoverable contract. See the
+[CLI documentation](https://docs.phreshos.com/sdks/cli) for Program project,
+System, and runtime commands.
 
 ## Development
 
@@ -84,15 +51,20 @@ bun run verify
 `verify` checks the scripts, builds the CLI and bundled starter, runs the
 command tests, and validates the package artifact.
 
-See the [CLI documentation](https://github.com/PhreshOS/docs/blob/main/content/docs/sdks/cli.mdx)
-for the command model.
+## Related repositories
 
-## Repository boundary
+- [`@phreshos/node`](https://github.com/PhreshOS/node) owns the Project and
+  external System APIs composed by the CLI.
+- [`@phreshos/core`](https://github.com/PhreshOS/core) owns the shared System
+  domain contracts used by the Node SDK.
+- [PhreshOS System](https://github.com/PhreshOS/system) provides the managed
+  runtime and official release artifact.
+- [Phresh Program](https://github.com/PhreshOS/phresh-program) is the starter
+  bundled by `phresh create`.
+- [PhreshOS Install](https://github.com/PhreshOS/install) bootstraps this CLI on
+  clean machines.
 
-This repository owns terminal interaction, command routing, System acquisition,
-and host service integration. Node owns the external JavaScript interface and
-Project workflows, Core owns shared contracts, and the System owns authoritative
-state.
+## Contributing
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) for the repository workflow and
 [SECURITY.md](SECURITY.md) for private vulnerability reporting.

package/dist/cli.js

@@ -1,138 +1,42 @@
 #!/usr/bin/env node
-import { Command, Option } from "commander";
+import { Command } from "commander";
 import { createRequire } from "node:module";
+import accessCommands from "./commands/access.js";
+import describeCommands from "./commands/describe.js";
+import projectCommands from "./commands/project.js";
+import { assertCommandContracts, attachCommandContract } from "./contract/command.js";
 import { PromptCancelled, ReportedFailure } from "./prompts.js";
-import create from "./create.js";
-import install from "./install.js";
-import launch from "./launch.js";
-import init from "./init.js";
-import pack from "./pack.js";
-import uninstall from "./uninstall.js";
-import systemCommands from "./system/command.js";
-import controlCommands from "./control/command.js";
-import describeCommands from "./describe-command.js";
-import { commandContract } from "./command-contract.js";
 import { blank, failure } from "./style.js";
+import systemCommands from "./system/command.js";
 const metadata = createRequire(import.meta.url)("../package.json");
-const { version } = metadata;
-const coreRange = metadata.dependencies["@phreshos/core"];
-const runOptionPrefix = "--run-option-";
 const program = new Command()
     .name("phresh")
-    .description("Create Programs and manage PhreshOS")
-    .version(version, "-v, --version")
+    .version(metadata.version, "-v, --version")
     .showHelpAfterError()
     .showSuggestionAfterError()
     .configureOutput({
     writeOut: value => process.stdout.write(spaced(value)),
     writeErr: value => process.stderr.write(spaced(value))
 });
-commandContract(program);
-program.addHelpText("after", "\nRun phresh <command> --help for detailed command guidance.\n");
-describe(program.command("create")
-    .description("create a new Program project")
-    .argument("[directory]", "directory for the new Program")
-    .option("--name <name>", "human-readable Program name")
-    .addOption(new Option("--package-manager <manager>", "package manager used to install dependencies").choices(["bun", "npm", "pnpm", "yarn"]))
-    .option("--no-install", "create files without installing dependencies")
-    .action(async function (directory, options) {
-    await create({
-        directory,
-        name: options.name,
-        packageManager: options.packageManager,
-        install: options.install
-    });
-}), [
-    "Creates a complete Server and Client project from the maintained",
-    "Phresh Program template bundled with this CLI.",
-    "",
-    "In a terminal, omitted values are collected interactively. Automation",
-    "supplies the directory and optional choices through named options."
-]);
-describe(program.command("init")
-    .description("initialize an existing Program project")
-    .option("--name <name>", "human-readable Program name")
-    .option("--build-command <command>", "prepare production files before use")
-    .option("--server", "include a Server endpoint")
-    .option("--server-location <path>", "production Server directory")
-    .option("--server-start-command <command>", "production Server command")
-    .option("--server-entry-file <path>", "production Server worker entry")
-    .option("--server-development-start-command <command>", "development Server command")
-    .option("--server-development-entry-file <path>", "development Server worker entry")
-    .option("--client", "include a Client endpoint")
-    .option("--client-location <path>", "production Client directory")
-    .option("--client-development-url <url>", "fixed or external development Client URL")
-    .option("--client-development-start-command <command>", "development Client command")
-    .option("--force", "replace an existing phresh.config.ts")
-    .action(async function (options) {
-    await init({
-        name: options.name,
-        buildCommand: options.buildCommand,
-        server: options.server === true || options.serverLocation !== undefined || options.serverStartCommand !== undefined || options.serverEntryFile !== undefined,
-        serverLocation: options.serverLocation,
-        serverStartCommand: options.serverStartCommand,
-        serverEntryFile: options.serverEntryFile,
-        serverDevelopmentStartCommand: options.serverDevelopmentStartCommand,
-        serverDevelopmentEntryFile: options.serverDevelopmentEntryFile,
-        client: options.client === true
-            || options.clientLocation !== undefined
-            || options.clientDevelopmentUrl !== undefined
-            || options.clientDevelopmentStartCommand !== undefined,
-        clientLocation: options.clientLocation,
-        clientDevelopmentUrl: options.clientDevelopmentUrl,
-        clientDevelopmentStartCommand: options.clientDevelopmentStartCommand,
-        force: options.force === true
-    }, process.cwd(), coreRange);
-}), [
-    "Reads identity, version, and description from package.json, then writes",
-    "phresh.config.ts. A terminal asks only for values the project cannot",
-    "provide. Without a terminal, declare at least one endpoint with options."
-]);
-describe(program.command("pack")
-    .description("build and package this Program")
-    .action(async function () {
-    await pack();
-}), [
-    "Runs an optional buildCommand, then packages the production files",
-    "declared for each endpoint."
-]);
-describe(program.command("install")
-    .description("install a local or official Program")
-    .argument("[name]", "name of an official Program")
-    .option("--run", "run the installed Program now")
-    .action(async function (name, options) {
-    await install({ name, run: options.run === true });
-}), [
-    "Without a name, builds and installs the Program declared by this project.",
-    "A name installs its verified official production release. --run launches",
-    "the installed Program now."
-]);
-describe(program.command("uninstall")
-    .description("uninstall a local or installed Program")
-    .argument("[name]", "name of an installed Program")
-    .option("--everything", "also remove Processes, data, and runtime state")
-    .action(async function (name, options) {
-    await uninstall({ name, everything: options.everything === true });
-}), [
-    "Without a name, uses the Program declared by this project. Removes its",
-    "installed files while preserving its Processes, data,",
-    "and runtime Program. --everything removes all system-owned state."
-]);
-attached("start", "run the production Program without installing", [
-    "Runs this Program attached to the terminal. Output arrives here, and",
-    "ending this command stops the Program. An optional buildCommand runs",
-    "before launch, and the Program's exit status becomes this command's status."
-], "production");
-attached("dev", "run the development Program without installing", [
-    "Runs the same attached lifecycle as start using the development",
-    "declarations. A Client URL must respond within 15 seconds before launch."
-], "development");
+attachCommandContract(program, {
+    name: "phresh",
+    description: "create Programs and manage PhreshOS",
+    options: [{ flags: "-v, --version", description: "display the CLI version" }],
+    guidance: ["Run phresh <command> --help for human guidance, or phresh describe for the machine-readable command contract."],
+    examples: ["phresh create", "phresh describe --all --json"]
+});
+const coreRange = metadata.dependencies["@phreshos/core"];
+if (!coreRange)
+    throw new Error("The CLI package does not declare @phreshos/core");
+projectCommands(program, coreRange);
 systemCommands(program);
-controlCommands(program);
+accessCommands(program);
 describeCommands(program);
+assertCommandContracts(program);
 // Every command begins with the same breathing room. Keep this at the entry
-// point so individual commands never need to manufacture their own opening.
-blank();
+// point so individual commands never manufacture their own opening.
+if (!process.argv.includes("--json"))
+    blank();
 if (process.argv.length === 2)
     program.help();
 try {
@@ -153,33 +57,3 @@ function spaced(value) {
         return value;
     return value.endsWith("\n") ? `${value}\n` : `${value}\n\n`;
 }
-function attached(name, summary, detail, mode) {
-    describe(program.command(name)
-        .description(summary)
-        .argument("[run-options...]", "--run-option-<name>=<value> values passed to the Program")
-        .allowUnknownOption()
-        .action(async function (args) {
-        await launch(mode, process.cwd(), runOptions(name, args));
-    }), detail);
-}
-function describe(command, paragraphs) {
-    command.addHelpText("after", `\n${paragraphs.map(line => line ? `  ${line}` : "").join("\n")}\n`);
-    commandContract(command, { guidance: paragraphs.filter(Boolean) });
-    return command;
-}
-function runOptions(command, args) {
-    const options = {};
-    for (const argument of args) {
-        if (!argument.startsWith(runOptionPrefix))
-            throw new Error(`${command} accepts Program options only as ${runOptionPrefix}<name>=<value>; received "${argument}"`);
-        const said = argument.slice(runOptionPrefix.length);
-        const at = said.indexOf("=");
-        if (at < 1)
-            throw new Error(`"${argument}" says no value — write ${runOptionPrefix}<name>=<value>, and end with = for an empty value`);
-        const name = said.slice(0, at);
-        if (Object.hasOwn(options, name))
-            throw new Error(`The run option "${name}" was given more than once`);
-        options[name] = said.slice(at + 1);
-    }
-    return options;
-}

package/dist/{control/command.js → commands/access.js}

@@ -1,10 +1,10 @@
 import endpointCommands from "./endpoint.js";
 import processCommands from "./process.js";
 import programCommands from "./program.js";
-import { connectSystem } from "./shared.js";
+import { connectSystem } from "./connection.js";
 import windowCommands from "./window.js";
-/** Expose the shared System handles as explicit CLI commands. */
-export default function controlCommands(program, connect = connectSystem) {
+/** Expose the shared System domains through explicit Node SDK executors. */
+export default function accessCommands(program, connect = connectSystem) {
     programCommands(program, connect);
     processCommands(program, connect);
     endpointCommands(program, connect);

package/dist/commands/connection.js

@@ -0,0 +1,26 @@
+import { System } from "@phreshos/node";
+export const connectSystem = () => System.connect();
+/** Give one command exclusive ownership of one Node SDK System connection. */
+export async function connected(connect, action) {
+    const system = await connect();
+    try {
+        return await action(system);
+    }
+    finally {
+        await system.disconnect();
+    }
+}
+export async function requireProgram(system, identity) {
+    const program = await system.program.find(identity);
+    if (!program)
+        throw new Error(`Unknown Program "${identity}"`);
+    return program;
+}
+export async function requireProcess(system, identity, programIdentity) {
+    const process = programIdentity
+        ? await (await requireProgram(system, programIdentity)).process.find(identity)
+        : await system.process.find(identity);
+    if (!process)
+        throw new Error(`Unknown Process "${identity}"`);
+    return process;
+}

package/dist/commands/describe.js

@@ -0,0 +1,75 @@
+import { defineCommand, readCommandContract } from "../contract/command.js";
+import { value } from "../contract/schema.js";
+import { jsonOption, option } from "./options.js";
+import { jsonOutput } from "./schemas.js";
+/** Expose the authoritative CLI contract without contacting the System. */
+export default function describeCommands(root) {
+    defineCommand(root, {
+        name: "describe",
+        description: "describe Phresh commands as machine-readable data",
+        arguments: [{ syntax: "[path...]", description: "command path to describe" }],
+        options: [
+            option("--all", "include every descendant beneath the selected path"),
+            jsonOption
+        ],
+        guidance: ["Omit the path to start at the CLI root. Add --all to retrieve the complete selected contract tree."],
+        examples: ["phresh describe", "phresh describe process create", "phresh describe --all --json"],
+        output: jsonOutput(value.any("one command contract or a complete contract tree"), "CLI command contract")
+    }, ({ arguments: [path], options }) => {
+        const command = resolveCommand(root, path);
+        return options.all ? describeTree(command, path) : describe(command, path);
+    });
+}
+function resolveCommand(root, path) {
+    let command = root;
+    for (const name of path) {
+        const child = command.commands.find(candidate => {
+            const contract = readCommandContract(candidate);
+            return candidate.name() === name || contract?.aliases?.includes(name);
+        });
+        if (!child)
+            throw new Error(`Unknown command path "${path.join(" ")}"`);
+        command = child;
+    }
+    return command;
+}
+function describeTree(command, path) {
+    return {
+        ...describe(command, path),
+        commands: command.commands.map(child => describeTree(child, [...path, child.name()]))
+    };
+}
+function describe(command, path) {
+    const contract = readCommandContract(command);
+    if (!contract)
+        throw new Error(`Command "${path.join(" ") || command.name()}" has no CLI contract`);
+    return {
+        path,
+        name: contract.name,
+        aliases: contract.aliases ?? [],
+        description: contract.description,
+        arguments: contract.arguments ?? [],
+        options: (contract.options ?? []).map(publicOption),
+        guidance: contract.guidance ?? [],
+        examples: contract.examples ?? [],
+        requiresSystem: contract.requiresSystem === true,
+        output: contract.output ?? null,
+        commands: command.commands.map(child => {
+            const childContract = readCommandContract(child);
+            if (!childContract)
+                throw new Error(`Command "${[...path, child.name()].join(" ")}" has no CLI contract`);
+            return { name: childContract.name, aliases: childContract.aliases ?? [], description: childContract.description };
+        })
+    };
+}
+function publicOption(option) {
+    return {
+        flags: option.flags,
+        description: option.description,
+        mandatory: option.mandatory === true,
+        value: option.flags.includes("<") ? "required" : option.flags.includes("[") ? "optional" : "none",
+        repeatable: option.repeatable === true,
+        choices: option.choices ?? [],
+        ...(Object.hasOwn(option, "default") ? { default: option.default } : {})
+    };
+}

package/dist/commands/endpoint.js

@@ -0,0 +1,134 @@
+import { defineCommand } from "../contract/command.js";
+import { value } from "../contract/schema.js";
+import { clientOverrideOptions, endpointOptions, option, serverOverrideOptions, timeoutOption, withJson } from "./options.js";
+import { endpointOutput, eventOutput, jsonOutput } from "./schemas.js";
+import { connected, requireProcess } from "./connection.js";
+import { bounded, clientLaunch, payload, serverLaunch } from "./input.js";
+import { wait } from "./observation.js";
+import { endpoint, endpointView } from "./projection.js";
+export default function endpointCommands(root, connect) {
+    const endpoints = defineCommand(root, {
+        name: "endpoint",
+        description: "inspect, control, and communicate with Process Endpoints",
+        guidance: ["Select the exact Process and either its server or client Endpoint."]
+    });
+    defineCommand(endpoints, {
+        name: "inspect",
+        description: "read whether one Endpoint is declared and running",
+        requiresSystem: true,
+        options: withJson(...endpointOptions),
+        output: jsonOutput(endpointOutput, "The selected Endpoint"),
+        examples: ["phresh endpoint inspect --process main --program terminal --endpoint server"]
+    }, async ({ options }) => withEndpoint(connect, options, async (process, name) => {
+        return await endpointView(process, name);
+    }));
+    defineCommand(endpoints, {
+        name: "start",
+        description: "start a fresh Endpoint incarnation",
+        requiresSystem: true,
+        options: withJson(...endpointOptions, ...clientOverrideOptions, ...serverOverrideOptions),
+        output: jsonOutput(endpointOutput, "The started Endpoint"),
+        examples: ["phresh endpoint start --process main --program terminal --endpoint server --server-service"]
+    }, 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);
+        return await endpointView(process, name);
+    }));
+    defineCommand(endpoints, {
+        name: "stop",
+        description: "stop one Endpoint",
+        requiresSystem: true,
+        options: withJson(...endpointOptions),
+        output: jsonOutput(endpointOutput, "The stopped Endpoint"),
+        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);
+    }));
+    defineCommand(endpoints, {
+        name: "waitReady",
+        aliases: ["wait-ready"],
+        description: "wait until the Server Endpoint reports readiness",
+        requiresSystem: true,
+        options: withJson(...endpointOptions, timeoutOption),
+        output: jsonOutput(endpointOutput, "The ready Server Endpoint"),
+        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");
+    }));
+    defineCommand(endpoints, {
+        name: "waitLifecycle",
+        aliases: ["wait-lifecycle"],
+        description: "wait for one lifecycle transition of an exact Endpoint",
+        requiresSystem: true,
+        options: withJson(...endpointOptions, option("--event <event>", "Endpoint lifecycle event", { mandatory: true, choices: ["start", "stop"] }), timeoutOption),
+        output: jsonOutput(value.object({
+            scope: value.string("Endpoint lifecycle subscription scope"),
+            event: value.enumeration(["start", "stop"], "observed lifecycle event")
+        }, ["scope", "event"], "Endpoint lifecycle event"), "One Endpoint lifecycle event"),
+        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 };
+    }));
+    defineCommand(endpoints, {
+        name: "ask",
+        description: "ask a Server event and return its answer",
+        requiresSystem: true,
+        options: withJson(...endpointOptions, option("--event <event>", "event name", { mandatory: true }), option("--payload <json>", "arbitrary event payload as JSON"), timeoutOption),
+        output: jsonOutput(value.any("answer returned by the Server event contract"), "The Server answer"),
+        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");
+        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;
+    }));
+    defineCommand(endpoints, {
+        name: "publish",
+        description: "publish one event without waiting for an answer",
+        requiresSystem: true,
+        options: withJson(...endpointOptions, option("--event <event>", "event name", { mandatory: true }), option("--payload <json>", "arbitrary event payload as JSON")),
+        output: jsonOutput(endpointOutput, "The Endpoint after publishing"),
+        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);
+    }));
+    defineCommand(endpoints, {
+        name: "wait",
+        description: "wait for the next event emitted by one live Endpoint",
+        requiresSystem: true,
+        options: withJson(...endpointOptions, option("--event <event>", "event name", { mandatory: true }), timeoutOption),
+        output: jsonOutput(eventOutput("The observed Endpoint event"), "One Endpoint event"),
+        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 function withEndpoint(connect, options, action) {
+    return await connected(connect, async (system) => {
+        return 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/shared.js → commands/input.js}

@@ -1,89 +1,3 @@
-import { System } from "@phreshos/node";
-import { blank } from "../style.js";
-export const connectSystem = () => System.connect();
-export async function connected(connect, action) {
-    const system = await connect();
-    try {
-        return await action(system);
-    }
-    finally {
-        await system.disconnect();
-    }
-}
-export async function requireProgram(system, identity) {
-    const program = await system.program.find(identity);
-    if (!program)
-        throw new Error(`Unknown Program "${identity}"`);
-    return program;
-}
-export async function requireProcess(system, identity, programIdentity) {
-    const process = programIdentity
-        ? await (await requireProgram(system, programIdentity)).process.find(identity)
-        : await system.process.find(identity);
-    if (!process)
-        throw new Error(`Unknown Process "${identity}"`);
-    return process;
-}
-export function endpoint(process, name) {
-    return name === "server" ? process.server : process.client;
-}
-export async function programView(program) {
-    return {
-        identity: program.identity,
-        assetId: program.assetId,
-        name: program.name,
-        version: program.version,
-        description: program.description,
-        installed: await program.installed(),
-        hasAgent: program.hasAgent,
-        server: program.server,
-        client: program.client
-    };
-}
-export async function processView(process) {
-    const [server, client, serverService, clientService] = await Promise.all([
-        process.server.exists(),
-        process.client.exists(),
-        process.server.isService(),
-        process.client.isService()
-    ]);
-    return {
-        identity: process.identity,
-        name: process.name,
-        program: process.program().identity,
-        startedAt: process.startedAt.toISOString(),
-        server: { declared: process.program().server !== null, running: server, service: serverService },
-        client: { declared: process.program().client !== null, running: client, service: clientService }
-    };
-}
-export async function endpointView(process, name) {
-    const program = process.program();
-    return {
-        process: process.identity,
-        program: program.identity,
-        endpoint: name,
-        declared: name === "server" ? program.server !== null : program.client !== null,
-        running: await endpoint(process, name).exists(),
-        service: await endpoint(process, name).isService()
-    };
-}
-export async function windowView(process) {
-    const window = process.client.window;
-    const [title, position, size, minimized, front, layer, location] = await Promise.all([
-        window.title(),
-        window.position(),
-        window.size(),
-        window.minimized(),
-        window.front(),
-        window.layer(),
-        window.location()
-    ]);
-    return { process: process.identity, title, position, size, minimized, front, layer, location };
-}
-export function output(value, compact) {
-    console.log(JSON.stringify(value ?? null, null, compact ? undefined : 2));
-    blank();
-}
 export function payload(value) {
     if (value === undefined)
         return undefined;
@@ -194,9 +108,3 @@ function entries(values = []) {
     }
     return result;
 }
-export async function wait(target, event, timeout) {
-    return target.waitFor(event, timeout);
-}
-export function windowOf(process) {
-    return process.client.window;
-}