@phreshos/cli 0.1.61 → 0.1.63

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,10 +36,10 @@ 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-development-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"),
@@ -56,12 +56,12 @@ 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,
+            serverDevelopmentCommand: options.serverDevelopmentCommand,
             client: options.client === true
                 || options.clientLocation !== undefined
                 || options.clientDevelopmentUrl !== undefined

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));
 }

package/dist/init.js

@@ -61,14 +61,16 @@ export default async function init(options = {}, directory = process.cwd(), core
         const location = options.serverLocation ?? (interactive ? await ask("The system runs the production Server from this project-relative directory.", "Where are the production Server files?", clientSelected ? "dist/server" : "dist") : "");
         if (!location)
             throw new Error("--server-location is required without a terminal");
-        const production = options.serverStartCommand === undefined && options.serverEntryFile === undefined && interactive
+        const production = options.serverCommand === undefined && options.serverWorker === undefined && options.serverSandbox === undefined && interactive
             ? await askExecution(interaction, "production", "node main.js")
-            : execution(options.serverStartCommand, options.serverEntryFile, "production Server");
-        let development = explicitExecution(options.serverDevelopmentStartCommand, options.serverDevelopmentEntryFile, "development Server");
+            : execution(options.serverCommand, options.serverWorker, options.serverSandbox, "production Server");
+        let development = developmentExecution(options.serverDevelopmentCommand, "development Server");
         if (interactive && development === undefined) {
             const suggested = manifest.scripts?.dev && projectScript(directory, manifest.packageManager, "dev");
             if (await yes("Development mode can run the Server directly from the project source.", "Run the Server from source during development?", Boolean(suggested && !clientSelected))) {
-                development = await askExecution(interaction, "development", suggested || undefined);
+                development = {
+                    command: await ask("This command runs from the project directory with access to development tooling.", "What command starts the development Server?", suggested || undefined)
+                };
             }
         }
         server = { location, ...production, ...development && { development } };
@@ -119,7 +121,7 @@ export default async function init(options = {}, directory = process.cwd(), core
     await ensureProjectDependency("@phreshos/core", coreRange, directory);
     writeFileSync(path, compose(config));
     if (config.server)
-        interaction.detail(config.server.startCommand ? "server" : "server worker", config.server.startCommand ?? config.server.entryFile, `./${config.server.location}`);
+        interaction.detail(`server ${serverExecution(config.server)[0]}`, serverExecution(config.server)[1], `./${config.server.location}`);
     if (config.client)
         interaction.detail("client", `./${config.client.location}`);
     const next = [config.server?.development || config.client?.development ? "phresh dev" : null, "phresh start", "phresh install"].filter(Boolean);
@@ -140,9 +142,7 @@ function compose(config) {
         field("buildCommand", config.buildCommand),
         half("server", config.server && {
             location: config.server.location,
-            ...(config.server.startCommand !== undefined
-                ? { startCommand: config.server.startCommand }
-                : { entryFile: config.server.entryFile }),
+            [serverExecution(config.server)[0]]: serverExecution(config.server)[1],
             ...config.server.development && { development: config.server.development }
         }),
         half("client", config.client && {
@@ -182,35 +182,54 @@ function httpUrl(value) {
         return false;
     }
 }
-function execution(startCommand, entryFile, owner) {
-    const selected = explicitExecution(startCommand, entryFile, owner);
-    if (!selected)
-        throw new Error(`Choose exactly one --server-start-command or --server-entry-file for the ${owner}`);
-    return selected;
-}
-function explicitExecution(startCommand, entryFile, owner) {
-    if (startCommand !== undefined && entryFile !== undefined)
-        throw new Error(`The ${owner} cannot declare both a start command and an entry file`);
-    if (startCommand !== undefined) {
-        if (startCommand.trim().length === 0)
+function execution(command, worker, sandbox, owner) {
+    const selected = [command, worker, sandbox].filter(value => value !== undefined);
+    if (selected.length !== 1)
+        throw new Error(`Choose exactly one --server-command, --server-worker, or --server-sandbox for the ${owner}`);
+    if (command !== undefined) {
+        if (!command.trim())
             throw new Error(`The ${owner} command must not be empty`);
-        return { startCommand };
+        return { command };
     }
-    if (entryFile !== undefined) {
-        if (entryFile.trim().length === 0)
-            throw new Error(`The ${owner} entry file must not be empty`);
-        if (!containedServerEntry(entryFile))
-            throw new Error(`The ${owner} entry file must remain inside its Server directory`);
-        return { entryFile };
+    if (worker !== undefined) {
+        if (!worker.trim())
+            throw new Error(`The ${owner} worker must not be empty`);
+        if (!containedServerEntry(worker))
+            throw new Error(`The ${owner} worker entry must remain inside its Server directory`);
+        return { worker };
     }
+    if (!sandbox?.trim())
+        throw new Error(`The ${owner} sandbox must not be empty`);
+    if (!containedServerEntry(sandbox))
+        throw new Error(`The ${owner} sandbox entry must remain inside its Server directory`);
+    return { sandbox };
+}
+function developmentExecution(command, owner) {
+    if (command === undefined)
+        return undefined;
+    if (!command.trim())
+        throw new Error(`The ${owner} command must not be empty`);
+    return { command };
 }
 async function askExecution(interaction, mode, suggestedCommand) {
-    const worker = await interaction.yes("A Worker uses fewer resources but shares the System's Node.js process.", `Run the ${mode} Server as a System-owned Worker?`, false);
+    const sandbox = await interaction.yes("A Sandbox provides only JavaScript and the permission-constrained System API.", `Run the ${mode} Server in a Sandbox?`, false);
+    if (sandbox)
+        return {
+            sandbox: await interaction.ask("This bundled JavaScript module remains inside the Server files.", `What is the ${mode} Server Sandbox entry?`, "main.js")
+        };
+    const worker = await interaction.yes("A Worker uses Node.js host capabilities in an isolated thread.", `Run the ${mode} Server as a Worker?`, false);
     if (worker)
         return {
-            entryFile: await interaction.ask("This JavaScript module remains inside the Server files.", `What is the ${mode} Server entry file?`, mode === "production" ? "main.js" : "source/server/main.js")
+            worker: await interaction.ask("This JavaScript module remains inside the Server files.", `What is the ${mode} Server Worker entry?`, "main.js")
         };
     return {
-        startCommand: await interaction.ask(`This command runs from the ${mode === "production" ? "production Server directory" : "project directory"}.`, `What command starts the ${mode} Server?`, suggestedCommand)
+        command: await interaction.ask("This command runs from the production Server directory.", `What command starts the ${mode} Server?`, suggestedCommand)
     };
 }
+function serverExecution(server) {
+    if (server.command !== undefined)
+        return ["command", server.command];
+    if (server.worker !== undefined)
+        return ["worker", server.worker];
+    return ["sandbox", server.sandbox];
+}

package/dist/launch.js

@@ -8,8 +8,14 @@ export default async function launch(mode, directory = process.cwd(), options =
     heading(`${definition.name ?? definition.identity}${definition.version ? ` ${definition.version}` : ""}`, mode);
     if (mode === "production" && project.config.buildCommand)
         line("build", project.config.buildCommand);
-    if (definition.server)
-        line(definition.server.startCommand ? "server" : "server worker", String(definition.server.startCommand ?? definition.server.entryFile), place(project.directory, definition.server.location));
+    if (definition.server) {
+        const [execution, value] = definition.server.command !== undefined
+            ? ["command", definition.server.command]
+            : definition.server.worker !== undefined
+                ? ["worker", definition.server.worker]
+                : ["sandbox", definition.server.sandbox];
+        line(`server ${execution}`, value, place(project.directory, definition.server.location));
+    }
     if (definition.client)
         line("client", project.config.client?.development?.startCommand ?? place(project.directory, definition.client.location));
     line("storage", place(project.directory, String(definition.storage)));

package/dist/output/format.js

@@ -0,0 +1,35 @@
+/** Render records as readable field blocks without terminal-table layout work. */
+export function renderList(fields, rows) {
+    return rows.map(row => renderFields(fields, row)).join("\n\n");
+}
+/** Render one value as aligned labels with indented multiline values. */
+export function renderFields(fields, source) {
+    const width = Math.max(...fields.map(field => field.label.length), 0);
+    return fields.map(field => {
+        const value = display(readPath(source, field.path), true);
+        const lines = value.split("\n");
+        const prefix = `${field.label.padEnd(width)}  `;
+        const continuation = " ".repeat(prefix.length);
+        return [prefix + lines[0], ...lines.slice(1).map(line => continuation + line)].join("\n");
+    }).join("\n");
+}
+export function readPath(source, path) {
+    if (!path)
+        return source;
+    return path.split(".").reduce((current, key) => {
+        if (typeof current !== "object" || current === null)
+            return undefined;
+        return current[key];
+    }, source);
+}
+export function display(value, expanded = false) {
+    if (value === null || value === undefined || value === "")
+        return "—";
+    if (typeof value === "boolean")
+        return value ? "yes" : "no";
+    if (typeof value === "string" || typeof value === "number" || typeof value === "bigint")
+        return String(value);
+    if (Array.isArray(value) && !expanded)
+        return value.length ? value.map(item => display(item)).join(", ") : "—";
+    return JSON.stringify(value, null, expanded ? 2 : undefined);
+}