@phreshos/cli 0.1.62 → 0.1.64

package/dist/commands/program.js

@@ -1,11 +1,10 @@
 import { defineCommand } from "../contract/command.js";
 import { value } from "../contract/schema.js";
-import { option, timeoutOption, withJson } from "./options.js";
+import { launchOptions, option, timeoutOption, withJson } from "./options.js";
 import { dataOutput, eventOutput, eventPresentation, pageOutput, programListPresentation, programOutput, programPresentation } from "./schemas.js";
-import { connected, requireProgram } from "./connection.js";
-import { bounded, integer, page } from "./input.js";
-import { wait } from "./observation.js";
-import { processView, programView } from "./projection.js";
+import { connected } from "./connection.js";
+import { bounded, integer, json, launch, page } from "./input.js";
+import { executeDescription } from "./execution.js";
 export default function programCommands(root, connect) {
     const programs = defineCommand(root, {
         name: "program",
@@ -14,29 +13,36 @@ export default function programCommands(root, connect) {
     });
     defineCommand(programs, {
         name: "list",
-        description: "list Programs with bounded filtering",
+        description: executeDescription("program", "list"),
         requiresSystem: true,
         options: withJson(option("--installed-only", "return only installed Programs"), option("--search <text>", "case-insensitive identity, name, or description search"), option("--limit <count>", "maximum returned Programs", { parse: value => integer(value), default: 30 }), option("--offset <count>", "number of matching Programs to skip", { parse: value => integer(value), default: 0 })),
         output: dataOutput(pageOutput(programOutput, "matching Programs"), "A bounded page of Programs", programListPresentation),
         examples: ["phresh program list", "phresh program list --installed-only --json"]
     }, async ({ options }) => connected(connect, async (system) => {
-        const programs = await system.program.list(options.installedOnly === true);
+        const programs = await system.execute({
+            $domain: "program",
+            $operation: "list",
+            installedOnly: options.installedOnly === true
+        });
         const selected = page(programs, options.search, bounded(options.offset, "--offset", 0), bounded(options.limit, "--limit", 1, 100), current => `${current.identity}\n${current.name}\n${current.description ?? ""}`);
-        return { ...selected, data: await Promise.all(selected.data.map(programView)) };
+        return selected;
     }));
     defineCommand(programs, {
         name: "inspect",
-        description: "read one Program declaration and installed state",
+        description: executeDescription("program", "find"),
         requiresSystem: true,
         options: withJson(option("--program <identity>", "Program identity", { mandatory: true })),
         output: dataOutput(programOutput, "The selected Program", programPresentation),
         examples: ["phresh program inspect --program terminal"]
     }, async ({ options }) => connected(connect, async (system) => {
-        return await programView(await requireProgram(system, options.program));
+        const program = await system.execute({ $domain: "program", $operation: "find", identity: options.program });
+        if (!program)
+            throw new Error(`Unknown Program "${options.program}"`);
+        return program;
     }));
     defineCommand(programs, {
         name: "agent",
-        description: "read a Program's own agent operating policy",
+        description: executeDescription("program", "agent"),
         requiresSystem: true,
         options: withJson(option("--program <identity>", "Program identity", { mandatory: true })),
         output: dataOutput(value.object({
@@ -48,15 +54,60 @@ export default function programCommands(root, connect) {
         }),
         examples: ["phresh program agent --program terminal --json"]
     }, async ({ options }) => connected(connect, async (system) => {
-        const program = await requireProgram(system, options.program);
-        const content = await program.agent();
-        if (content === null)
-            throw new Error(`Program "${program.identity}" has no agent documentation`);
-        return { program: program.identity, content };
+        const result = await system.execute({ $domain: "program", $operation: "agent", identity: options.program });
+        if (result.content === null)
+            throw new Error(`Program "${result.program}" has no agent documentation`);
+        return result;
+    }));
+    defineCommand(programs, {
+        name: "getLaunch",
+        aliases: ["get-launch"],
+        description: executeDescription("program", "getLaunch"),
+        requiresSystem: true,
+        options: withJson(option("--program <identity>", "Program identity", { mandatory: true })),
+        output: dataOutput(value.any("Saved Process launch or null"), "The saved Program launch", { format: "value" }),
+        examples: ["phresh program get-launch --program terminal --json"]
+    }, ({ options }) => connected(connect, system => system.execute({
+        $domain: "program",
+        $operation: "getLaunch",
+        identity: options.program
+    })));
+    defineCommand(programs, {
+        name: "setLaunch",
+        aliases: ["set-launch"],
+        description: executeDescription("program", "setLaunch"),
+        requiresSystem: true,
+        options: withJson(option("--program <identity>", "Program identity", { mandatory: true }), ...launchOptions),
+        output: dataOutput(value.any("Saved Process launch"), "The saved Program launch", { format: "value" }),
+        examples: ["phresh program set-launch --program terminal --client --name main --json"]
+    }, ({ options }) => connected(connect, system => system.execute({
+        $domain: "program",
+        $operation: "setLaunch",
+        identity: options.program,
+        launch: launch(options)
+    })));
+    defineCommand(programs, {
+        name: "logs",
+        description: executeDescription("program", "logs"),
+        requiresSystem: true,
+        options: withJson(option("--program <identity>", "Program identity", { mandatory: true }), option("--statement <sql>", "read-only SQL statement", { mandatory: true }), option("--values <json>", "bound statement values encoded as a JSON array")),
+        output: dataOutput(value.array(value.any("log query row"), "log query rows"), "Program log query result", { format: "value" }),
+        examples: ["phresh program logs --program terminal --statement 'select createdAt, process, source, kind, content from logs order by createdAt desc limit 100' --json"]
+    }, ({ options }) => connected(connect, system => {
+        const parsed = options.values === undefined ? undefined : json(options.values, "--values");
+        if (parsed !== undefined && !Array.isArray(parsed))
+            throw new Error("--values must be a JSON array");
+        return system.execute({
+            $domain: "program",
+            $operation: "logs",
+            identity: options.program,
+            statement: options.statement,
+            ...(parsed === undefined ? {} : { values: parsed })
+        });
     }));
     defineCommand(programs, {
         name: "wait",
-        description: "wait for one Program registry event",
+        description: executeDescription("program", "wait"),
         requiresSystem: true,
         options: withJson(option("--event <event>", "Program lifecycle event", {
             mandatory: true,
@@ -64,39 +115,11 @@ export default function programCommands(root, connect) {
         }), option("--program <identity>", "observe events belonging to one Program"), timeoutOption),
         output: dataOutput(eventOutput("The observed Program event", value.any("Program state or uninstall result")), "One Program event", eventPresentation),
         examples: ["phresh program wait --event create", "phresh program wait --event uninstall --program terminal --json"]
-    }, async ({ options }) => connected(connect, async (system) => {
-        if (options.program && (options.event === "create" || options.event === "install")) {
-            throw new Error(`An individual Program does not emit ${options.event}`);
-        }
-        if (!options.program && (options.event === "processCreate" || options.event === "processExit")) {
-            throw new Error(`${options.event} belongs to an individual Program`);
-        }
-        const target = options.program ? await requireProgram(system, options.program) : system.program;
-        const message = await wait(target, options.event, timeout(options.timeout));
-        return {
-            scope: options.program ? `program:${options.program}` : "program",
-            event: options.event,
-            payload: await eventView(options.event, message, options.program ? target : undefined)
-        };
-    }));
-}
-async function eventView(event, message, scoped) {
-    if (event === "uninstall") {
-        if (scoped)
-            return { program: await programView(scoped), purge: message.purge };
-        const current = message;
-        return { program: await programView(current.program), purge: current.purge };
-    }
-    if (event === "processCreate")
-        return processView(message);
-    if (event === "processExit") {
-        const current = message;
-        return { process: await processView(current.process), status: current.status, code: current.code, signal: current.signal };
-    }
-    if (scoped)
-        return programView(scoped);
-    return programView(message);
-}
-function timeout(value) {
-    return value === undefined ? undefined : bounded(value, "--timeout", 1);
+    }, async ({ options }) => connected(connect, system => system.execute({
+        $domain: "program",
+        $operation: "wait",
+        event: options.event,
+        ...(options.program ? { program: options.program } : {}),
+        ...(options.timeout === undefined ? {} : { timeout: bounded(options.timeout, "--timeout", 1) })
+    })));
 }

package/dist/commands/project.js

@@ -36,14 +36,14 @@ export default function projectCommands(program, coreRange) {
             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("--server-command <command>", "production Server host command"),
+            option("--server-worker <path>", "production Server Node Worker entry"),
+            option("--server-sandbox <path>", "production Server Sandbox entry"),
+            option("--server-dev-command <command>", "development Server command"),
             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("--client-dev-url <url>", "fixed or external development Client URL"),
+            option("--client-dev-command <command>", "development Client command"),
             option("--force", "replace an existing phresh.config.ts")
         ],
         guidance: [
@@ -56,19 +56,19 @@ export default function projectCommands(program, coreRange) {
         await init({
             name: options.name,
             buildCommand: options.buildCommand,
-            server: options.server === true || options.serverLocation !== undefined || options.serverStartCommand !== undefined || options.serverEntryFile !== undefined,
+            server: options.server === true || options.serverLocation !== undefined || options.serverCommand !== undefined || options.serverWorker !== undefined || options.serverSandbox !== undefined,
             serverLocation: options.serverLocation,
-            serverStartCommand: options.serverStartCommand,
-            serverEntryFile: options.serverEntryFile,
-            serverDevelopmentStartCommand: options.serverDevelopmentStartCommand,
-            serverDevelopmentEntryFile: options.serverDevelopmentEntryFile,
+            serverCommand: options.serverCommand,
+            serverWorker: options.serverWorker,
+            serverSandbox: options.serverSandbox,
+            serverDevCommand: options.serverDevCommand,
             client: options.client === true
                 || options.clientLocation !== undefined
-                || options.clientDevelopmentUrl !== undefined
-                || options.clientDevelopmentStartCommand !== undefined,
+                || options.clientDevUrl !== undefined
+                || options.clientDevCommand !== undefined,
             clientLocation: options.clientLocation,
-            clientDevelopmentUrl: options.clientDevelopmentUrl,
-            clientDevelopmentStartCommand: options.clientDevelopmentStartCommand,
+            clientDevUrl: options.clientDevUrl,
+            clientDevCommand: options.clientDevCommand,
             force: options.force === true
         }, process.cwd(), coreRange);
     });

package/dist/commands/projection.js

@@ -46,8 +46,9 @@ export async function endpointView(process, name) {
 }
 export async function windowView(process) {
     const window = process.client.window;
-    const [title, position, size, minimized, maximized, front, layer] = await Promise.all([
+    const [title, header, position, size, minimized, maximized, front, layer] = await Promise.all([
         window.title(),
+        window.header(),
         window.position(),
         window.size(),
         window.minimized(),
@@ -55,5 +56,5 @@ export async function windowView(process) {
         window.front(),
         window.layer()
     ]);
-    return { process: process.identity, title, position, size, minimized, maximized, front, layer };
+    return { process: process.identity, title, header, position, size, minimized, maximized, front, layer };
 }

package/dist/commands/schemas.js

@@ -55,31 +55,32 @@ export const windowOutput = value.object({
     layer: value.enumeration(layers, "Window layer")
 }, ["process", "title", "position", "size", "minimized", "maximized", "front", "layer"], "Window state");
 export const programPresentation = fields(["Identity", "identity"], ["Asset", "assetId"], ["Name", "name"], ["Version", "version"], ["Description", "description"], ["Installed", "installed"], ["Agent", "hasAgent"], ["Server", "server"], ["Client", "client"]);
-export const programListPresentation = table("data", "Program", "Programs", "No matching Programs", [
-    { label: "Name", path: "name", width: 2 },
-    { label: "Identity", path: "identity", width: 2 },
+export const programListPresentation = list("data", "Program", "Programs", "No matching Programs", [
+    { label: "Name", path: "name" },
+    { label: "Identity", path: "identity" },
     { label: "Version", path: "version" },
     { label: "Installed", path: "installed" }
 ]);
 export const processPresentation = fields(["Identity", "identity"], ["Name", "name"], ["Program", "program"], ["Started", "startedAt"], ["Server declared", "server.declared"], ["Server running", "server.running"], ["Server service", "server.service"], ["Client declared", "client.declared"], ["Client running", "client.running"], ["Client service", "client.service"]);
 export const processActionPresentation = fields(["Process", "identity"], ["Name", "name"], ["Program", "program"], ["Server", "server.running"], ["Client", "client.running"]);
 export const processIdentityPresentation = fields(["Process", "identity"], ["Program", "program"]);
-export const processListPresentation = table("data", "Process", "Processes", "No matching Processes", [
-    { label: "Name", path: "name", width: 2 },
-    { label: "Identity", path: "identity", width: 2 },
-    { label: "Program", path: "program", width: 2 },
+export const processListPresentation = list("data", "Process", "Processes", "No matching Processes", [
+    { label: "Name", path: "name" },
+    { label: "Identity", path: "identity" },
+    { label: "Program", path: "program" },
     { label: "Server", path: "server.running" },
     { label: "Client", path: "client.running" }
 ]);
 export const endpointPresentation = fields(["Process", "process"], ["Program", "program"], ["Endpoint", "endpoint"], ["Declared", "declared"], ["Running", "running"], ["Service", "service"]);
 export const endpointActionPresentation = fields(["Process", "process"], ["Endpoint", "endpoint"], ["Running", "running"], ["Service", "service"]);
-export const windowPresentation = fields(["Process", "process"], ["Title", "title"], ["Position", "position"], ["Size", "size"], ["Minimized", "minimized"], ["Maximized", "maximized"], ["Front", "front"], ["Layer", "layer"], ["Location", "location"]);
+export const windowPresentation = fields(["Process", "process"], ["Title", "title"], ["Header", "header"], ["Position", "position"], ["Size", "size"], ["Minimized", "minimized"], ["Maximized", "maximized"], ["Front", "front"], ["Layer", "layer"], ["Location", "location"]);
 export const windowPositionPresentation = fields(["Process", "process"], ["Position", "position"]);
 export const windowSizePresentation = fields(["Process", "process"], ["Size", "size"]);
 export const windowGeometryPresentation = fields(["Process", "process"], ["Position", "position"], ["Size", "size"]);
 export const windowMinimizePresentation = fields(["Process", "process"], ["Minimized", "minimized"]);
 export const windowMaximizePresentation = fields(["Process", "process"], ["Maximized", "maximized"]);
 export const windowTitlePresentation = fields(["Process", "process"], ["Title", "title"]);
+export const windowHeaderPresentation = fields(["Process", "process"], ["Header", "header"]);
 export const windowRaisePresentation = fields(["Process", "process"], ["Front", "front"]);
 export const eventPresentation = fields(["Scope", "scope"], ["Event", "event"], ["Payload", "payload"]);
 export const lifecyclePresentation = fields(["Scope", "scope"], ["Event", "event"]);
@@ -118,6 +119,6 @@ function fields(...values) {
         fields: values.map(([label, path]) => ({ label, path }))
     };
 }
-function table(rows, item, items, empty, columns) {
-    return { format: "table", rows, columns, item, items, empty, total: "total", truncated: "truncated" };
+function list(rows, item, items, empty, fields) {
+    return { format: "list", rows, fields, item, items, empty, total: "total", truncated: "truncated" };
 }

package/dist/commands/window.js

@@ -1,110 +1,96 @@
+import { parseExecuteRequest } from "@phreshos/core";
 import { defineCommand } from "../contract/command.js";
 import { option, processOptions, timeoutOption, withJson } from "./options.js";
-import { dataOutput, eventOutput, eventPresentation, windowGeometryPresentation, windowMinimizePresentation, windowMaximizePresentation, windowOutput, windowPositionPresentation, windowPresentation, windowRaisePresentation, windowSizePresentation, windowTitlePresentation } from "./schemas.js";
-import { connected, requireProcess } from "./connection.js";
+import { dataOutput, eventOutput, eventPresentation, windowGeometryPresentation, windowHeaderPresentation, windowMinimizePresentation, windowMaximizePresentation, windowOutput, windowPositionPresentation, windowPresentation, windowRaisePresentation, windowSizePresentation, windowTitlePresentation } from "./schemas.js";
+import { connected } from "./connection.js";
 import { bounded, position, size } from "./input.js";
-import { wait } from "./observation.js";
-import { windowOf, windowView } from "./projection.js";
+import { executeDescription } from "./execution.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", windowPresentation), async ({ options }) => {
-        return await withWindow(connect, options, windowView);
+    defineCommand(windows, state("inspect", windowPresentation), async ({ options }) => {
+        return executeWindow(connect, options, { $operation: "inspect" });
     });
     defineCommand(windows, {
-        ...state("move", "change Window position", windowPositionPresentation),
+        ...state("move", windowPositionPresentation),
         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);
-    }));
+    }, async ({ options }) => executeWindow(connect, options, { $operation: "move", position: position(options.x, options.y) }));
     defineCommand(windows, {
-        ...state("resize", "change Window size", windowSizePresentation),
+        ...state("resize", windowSizePresentation),
         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);
-    }));
+    }, async ({ options }) => executeWindow(connect, options, { $operation: "resize", size: size(options.width, options.height) }));
     defineCommand(windows, {
-        ...state("setGeometry", "change Window position and size atomically", windowGeometryPresentation),
+        ...state("setGeometry", windowGeometryPresentation),
         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);
+    }, async ({ options }) => executeWindow(connect, options, {
+        $operation: "setGeometry",
+        position: position(options.x, options.y),
+        size: size(options.width, options.height)
     }));
     defineCommand(windows, {
-        ...state("minimize", "set Window visibility without changing its order", windowMinimizePresentation),
+        ...state("minimize", windowMinimizePresentation),
         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);
-    }));
+    }, async ({ options }) => executeWindow(connect, options, { $operation: "minimize", minimized: options.restore !== true }));
     defineCommand(windows, {
-        ...state("maximize", "set Window maximization without changing visibility or stored geometry", windowMaximizePresentation),
+        ...state("maximize", windowMaximizePresentation),
         options: withJson(...processOptions, option("--restore", "restore rather than maximize the Window")),
         examples: ["phresh window maximize --process main --program terminal", "phresh window maximize --process main --program terminal --restore"]
-    }, async ({ options }) => withWindow(connect, options, async (process) => {
-        await windowOf(process).maximize(options.restore !== true);
-        return await windowView(process);
-    }));
+    }, async ({ options }) => executeWindow(connect, options, { $operation: "maximize", maximized: options.restore !== true }));
     defineCommand(windows, {
-        ...state("changeTitle", "change the human-readable Window title", windowTitlePresentation),
+        ...state("changeTitle", windowTitlePresentation),
         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);
-    }));
+    }, async ({ options }) => executeWindow(connect, options, { $operation: "changeTitle", title: options.title }));
+    defineCommand(windows, {
+        ...state("changeHeader", windowHeaderPresentation),
+        aliases: ["change-header"],
+        options: withJson(...processOptions, option("--hide", "hide rather than show the Window header")),
+        examples: ["phresh window change-header --process main --program terminal --hide", "phresh window change-header --process main --program terminal"]
+    }, async ({ options }) => executeWindow(connect, options, { $operation: "changeHeader", header: options.hide !== true }));
     defineCommand(windows, {
-        ...state("raise", "raise the Window within its own layer", windowRaisePresentation),
+        ...state("raise", windowRaisePresentation),
         examples: ["phresh window raise --process main --program terminal"]
-    }, async ({ options }) => withWindow(connect, options, async (process) => {
-        await windowOf(process).raise();
-        return await windowView(process);
-    }));
+    }, async ({ options }) => executeWindow(connect, options, { $operation: "raise" }));
     defineCommand(windows, {
         name: "wait",
-        description: "wait for one authoritative Window change",
+        description: executeDescription("window", "wait"),
         requiresSystem: true,
         options: withJson(...processOptions, option("--event <event>", "Window event", {
             mandatory: true,
-            choices: ["move", "resize", "geometry", "minimize", "maximize", "changeTitle", "front"]
+            choices: ["move", "resize", "geometry", "minimize", "maximize", "changeTitle", "changeHeader", "front"]
         }), timeoutOption),
         output: dataOutput(eventOutput("The observed Window event"), "One Window event", eventPresentation),
         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))
-        };
+    }, async ({ options }) => executeWindow(connect, options, {
+        $operation: "wait",
+        event: options.event,
+        ...(options.timeout === undefined ? {} : { timeout: bounded(options.timeout, "--timeout", 1) })
     }));
 }
-function state(name, description, presentation) {
+function state(name, presentation) {
     return {
         name,
-        description,
+        description: executeDescription("window", name),
         requiresSystem: true,
         options: withJson(...processOptions),
         output: dataOutput(windowOutput, "The current Window state", presentation)
     };
 }
-async function withWindow(connect, options, action) {
-    return await connected(connect, async (system) => {
-        return await action(await requireProcess(system, options.process, options.program));
+async function executeWindow(connect, options, operation) {
+    const request = parseExecuteRequest({
+        $domain: "window",
+        ...operation,
+        process: options.process,
+        ...(options.program ? { program: options.program } : {})
     });
+    return connected(connect, system => system.execute(request));
 }