@phreshos/cli 0.1.66 → 0.1.68

package/dist/commands/execution.js

@@ -6,8 +6,19 @@ export const executeCommandPaths = Object.freeze({
     "program.list": ["program", "list"],
     "program.find": ["program", "inspect"],
     "program.agent": ["program", "agent"],
-    "program.getLaunch": ["program", "getLaunch"],
-    "program.setLaunch": ["program", "setLaunch"],
+    "program.definition": ["program", "definition"],
+    "program.getStartup": ["program", "getStartup"],
+    "program.enableStartup": ["program", "enableStartup"],
+    "program.disableStartup": ["program", "disableStartup"],
+    "program.pinned": ["program", "pinned"],
+    "program.pin": ["program", "pin"],
+    "program.unpin": ["program", "unpin"],
+    "program.getPermission": ["program", "getPermission"],
+    "program.listPermissions": ["program", "listPermissions"],
+    "program.allowsPermission": ["program", "allowsPermission"],
+    "program.allowPermission": ["program", "allowPermission"],
+    "program.denyPermission": ["program", "denyPermission"],
+    "program.requestPermission": ["program", "requestPermission"],
     "program.logs": ["program", "logs"],
     "program.wait": ["program", "wait"],
     "process.list": ["process", "list"],

package/dist/commands/program.js

@@ -1,3 +1,4 @@
+import { parsePermissionName } from "@phreshos/core";
 import { defineCommand } from "../contract/command.js";
 import { value } from "../contract/schema.js";
 import { launchOptions, option, timeoutOption, withJson } from "./options.js";
@@ -60,32 +61,157 @@ export default function programCommands(root, connect) {
         return result;
     }));
     defineCommand(programs, {
-        name: "getLaunch",
-        aliases: ["get-launch"],
-        description: executeDescription("program", "getLaunch"),
+        name: "definition",
+        description: executeDescription("program", "definition"),
         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"]
+        output: dataOutput(value.any("Complete canonical Program definition"), "The Program definition", { format: "value" }),
+        examples: ["phresh program definition --program terminal --json"]
     }, ({ options }) => connected(connect, system => system.execute({
         $domain: "program",
-        $operation: "getLaunch",
+        $operation: "definition",
         identity: options.program
     })));
     defineCommand(programs, {
-        name: "setLaunch",
-        aliases: ["set-launch"],
-        description: executeDescription("program", "setLaunch"),
+        name: "getStartup",
+        aliases: ["get-startup"],
+        description: executeDescription("program", "getStartup"),
+        requiresSystem: true,
+        options: withJson(option("--program <identity>", "Program identity", { mandatory: true })),
+        output: dataOutput(value.any("Stored System-start launch or null"), "The Program startup launch", { format: "value" }),
+        examples: ["phresh program get-startup --program terminal --json"]
+    }, ({ options }) => connected(connect, system => system.execute({
+        $domain: "program",
+        $operation: "getStartup",
+        identity: options.program
+    })));
+    defineCommand(programs, {
+        name: "enableStartup",
+        aliases: ["enable-startup"],
+        description: executeDescription("program", "enableStartup"),
         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"]
+        output: dataOutput(value.any("Stored System-start launch"), "The Program startup launch", { format: "value" }),
+        examples: ["phresh program enable-startup --program terminal --client --name main --json"]
     }, ({ options }) => connected(connect, system => system.execute({
         $domain: "program",
-        $operation: "setLaunch",
+        $operation: "enableStartup",
         identity: options.program,
         launch: launch(options)
     })));
+    defineCommand(programs, {
+        name: "disableStartup",
+        aliases: ["disable-startup"],
+        description: executeDescription("program", "disableStartup"),
+        requiresSystem: true,
+        options: withJson(option("--program <identity>", "Program identity", { mandatory: true })),
+        output: dataOutput(value.nullable(value.any("disabled startup")), "Startup is disabled", { format: "value" }),
+        examples: ["phresh program disable-startup --program terminal"]
+    }, ({ options }) => connected(connect, system => system.execute({
+        $domain: "program",
+        $operation: "disableStartup",
+        identity: options.program
+    })));
+    for (const operation of ["pinned", "pin", "unpin"])
+        defineCommand(programs, {
+            name: operation,
+            description: executeDescription("program", operation),
+            requiresSystem: true,
+            options: withJson(option("--program <identity>", "Program identity", { mandatory: true })),
+            output: dataOutput(value.boolean("whether the Program is pinned"), "The Program pinned state", { format: "value" }),
+            examples: [`phresh program ${operation} --program terminal`]
+        }, ({ options }) => connected(connect, system => system.execute({
+            $domain: "program",
+            $operation: operation,
+            identity: options.program
+        })));
+    defineCommand(programs, {
+        name: "getPermission",
+        aliases: ["get-permission"],
+        description: executeDescription("program", "getPermission"),
+        requiresSystem: true,
+        options: withJson(option("--program <identity>", "Program identity", { mandatory: true }), option("--permission <name>", "permission name", { mandatory: true })),
+        output: dataOutput(value.any("effective permission assignment"), "The effective permission", { format: "value" }),
+        examples: ["phresh program get-permission --program terminal --permission network --json"]
+    }, ({ options }) => connected(connect, system => system.execute({
+        $domain: "program",
+        $operation: "getPermission",
+        identity: options.program,
+        permission: parsePermissionName(options.permission)
+    })));
+    defineCommand(programs, {
+        name: "listPermissions",
+        aliases: ["list-permissions"],
+        description: executeDescription("program", "listPermissions"),
+        requiresSystem: true,
+        options: withJson(option("--program <identity>", "Program identity", { mandatory: true })),
+        output: dataOutput(value.any("effective permission assignments"), "The effective permissions", { format: "value" }),
+        examples: ["phresh program list-permissions --program terminal --json"]
+    }, ({ options }) => connected(connect, system => system.execute({
+        $domain: "program",
+        $operation: "listPermissions",
+        identity: options.program
+    })));
+    defineCommand(programs, {
+        name: "allowsPermission",
+        aliases: ["allows-permission"],
+        description: executeDescription("program", "allowsPermission"),
+        requiresSystem: true,
+        options: withJson(option("--program <identity>", "Program identity", { mandatory: true }), option("--permission <name>", "permission name", { mandatory: true }), option("--value <json>", "requested permission value encoded as JSON")),
+        output: dataOutput(value.boolean("whether the requested access is allowed"), "The permission decision", { format: "value" }),
+        examples: ["phresh program allows-permission --program terminal --permission network --value '[\"https://example.com\"]'"]
+    }, ({ options }) => connected(connect, system => system.execute({
+        $domain: "program",
+        $operation: "allowsPermission",
+        identity: options.program,
+        permission: parsePermissionName(options.permission),
+        ...(options.value === undefined ? {} : { value: permissionRequest(options.value) })
+    })));
+    defineCommand(programs, {
+        name: "allowPermission",
+        aliases: ["allow-permission"],
+        description: executeDescription("program", "allowPermission"),
+        requiresSystem: true,
+        options: withJson(option("--program <identity>", "Program identity", { mandatory: true }), option("--permission <name>", "permission name", { mandatory: true }), option("--value <json>", "complete allowed permission value encoded as JSON")),
+        output: dataOutput(value.any("stored permission assignment"), "The stored permission", { format: "value" }),
+        examples: ["phresh program allow-permission --program terminal --permission network --value '[\"https://example.com\"]'"]
+    }, ({ options }) => connected(connect, system => system.execute({
+        $domain: "program",
+        $operation: "allowPermission",
+        identity: options.program,
+        permission: parsePermissionName(options.permission),
+        ...(options.value === undefined ? {} : { value: permissionRequest(options.value) })
+    })));
+    defineCommand(programs, {
+        name: "denyPermission",
+        aliases: ["deny-permission"],
+        description: executeDescription("program", "denyPermission"),
+        requiresSystem: true,
+        options: withJson(option("--program <identity>", "Program identity", { mandatory: true }), option("--permission <name>", "permission name", { mandatory: true })),
+        output: dataOutput(value.any("stored permission assignment"), "The stored permission", { format: "value" }),
+        examples: ["phresh program deny-permission --program terminal --permission network"]
+    }, ({ options }) => connected(connect, system => system.execute({
+        $domain: "program",
+        $operation: "denyPermission",
+        identity: options.program,
+        permission: parsePermissionName(options.permission)
+    })));
+    defineCommand(programs, {
+        name: "requestPermission",
+        aliases: ["request-permission"],
+        description: executeDescription("program", "requestPermission"),
+        requiresSystem: true,
+        options: withJson(option("--program <identity>", "Program identity", { mandatory: true }), option("--permission <name>", "permission name", { mandatory: true }), option("--value <json>", "complete requested permission value encoded as JSON"), timeoutOption),
+        output: dataOutput(value.any("permission decision"), "The permission decision", { format: "value" }),
+        examples: ["phresh program request-permission --program terminal --permission uploads"]
+    }, ({ options }) => connected(connect, system => system.execute({
+        $domain: "program",
+        $operation: "requestPermission",
+        identity: options.program,
+        permission: parsePermissionName(options.permission),
+        ...(options.value === undefined ? {} : { value: permissionRequest(options.value) }),
+        ...(options.timeout === undefined ? {} : { timeout: bounded(options.timeout, "--timeout", 0) })
+    })));
     defineCommand(programs, {
         name: "logs",
         description: executeDescription("program", "logs"),
@@ -111,7 +237,7 @@ export default function programCommands(root, connect) {
         requiresSystem: true,
         options: withJson(option("--event <event>", "Program lifecycle event", {
             mandatory: true,
-            choices: ["create", "forget", "install", "uninstall", "processCreate", "processExit"]
+            choices: ["create", "forget", "install", "uninstall", "pinned", "processCreate", "processExit"]
         }), 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"]
@@ -123,3 +249,12 @@ export default function programCommands(root, connect) {
         ...(options.timeout === undefined ? {} : { timeout: bounded(options.timeout, "--timeout", 1) })
     })));
 }
+function permissionRequest(source) {
+    const value = json(source, "--value");
+    if (value === true || strings(value))
+        return value;
+    throw new Error("--value must be true or a JSON array of strings");
+}
+function strings(value) {
+    return Array.isArray(value) && value.every(entry => typeof entry === "string");
+}

package/dist/commands/project.js

@@ -85,7 +85,7 @@ export default function projectCommands(program, coreRange) {
         name: "install",
         description: "install a local or official Program",
         arguments: [{ syntax: "[name]", description: "name of an official Program" }],
-        options: [option("--run", "launch the installed Program before startup"), option("--purge", "delete existing installed Program storage")],
+        options: [option("--run", "launch one default Process after installation"), option("--purge", "delete existing installed Program storage")],
         guidance: [
             "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."

package/dist/install.js

@@ -5,7 +5,7 @@ import { prepareOfficialProgram } from "./program-release.js";
 /**
  * Lay this program out on this machine's system.
  *
- * A local project is built and derived from its authoring declaration. An
+ * A local project is built and derived from its authoring definition. An
  * official name resolves a verified production package and turns its
  * canonical paths into the same concrete definition. From that point on,
  * both sources cross the exact same gateway and the System performs the exact
@@ -15,8 +15,7 @@ import { prepareOfficialProgram } from "./program-release.js";
  * production Program is derived and sent. The command remains authoring
  * metadata and never becomes part of the installed Program.
  *
- * The System executes the Program's stored startup after installation.
- * `run` requests an additional Process before startup, created by System. It belongs
+ * `run` overrides the Program's install launch with one default Process. It belongs
  * to the installed Program and
  * therefore outlives this command; `phresh start` and `phresh dev` remain
  * attached authoring runs whose lifetime is the terminal's.

package/dist/program-installation.js

@@ -17,8 +17,9 @@ export default async function installProgram(program, options = {}) {
         }
         else
             installed = await system.program.forceCreate(program);
-        if (options.run)
-            stopObserving = installed.subscribe("processCreate", created => { process ??= created.identity; });
+        // A definition-owned installLaunch can create the Process even when
+        // the CLI did not supply --run, so observation belongs to installation.
+        stopObserving = installed.subscribe("processCreate", created => { process ??= created.identity; });
         for await (const chunk of installed.install({ launch: options.run ? true : undefined, purge: options.purge }))
             writeProgramCommandOutput(chunk);
         installationFinished = true;

package/dist/template/package.json

@@ -1,7 +1,7 @@
 {
     "name": "phresh",
     "private": true,
-    "version": "0.1.40",
+    "version": "0.1.42",
     "description": "The official PhreshOS starter Program.",
     "type": "module",
     "scripts": {
@@ -14,15 +14,15 @@
         "starter"
     ],
     "dependencies": {
-        "@phreshos/client": "^0.1.46",
-        "@phreshos/core": "^0.1.54",
-        "@phreshos/react": "^0.1.28",
-        "@phreshos/server": "^0.1.50",
+        "@phreshos/client": "^0.1.48",
+        "@phreshos/core": "^0.1.56",
+        "@phreshos/react": "^0.1.29",
+        "@phreshos/server": "^0.1.52",
         "react": "^19.2.8",
         "react-dom": "^19.2.8"
     },
     "devDependencies": {
-        "@phreshos/cli": "^0.1.66",
+        "@phreshos/cli": "^0.1.68",
         "@types/node": "^26.4.0",
         "@types/react": "^19.2.18",
         "@types/react-dom": "^19.2.5",

package/dist/template/phresh.config.ts

@@ -4,7 +4,7 @@ export default defineConfig({
     identity: "phresh",
     name: "Phresh Program",
     description: "A minimal counter with direct Client and Server endpoints.",
-    version: "0.1.40",
+    version: "0.1.42",
     icon: "icon.png",
     categories: ["Development"],
     keywords: ["example", "counter", "client", "server"],

package/dist/template.json

@@ -1,6 +1,6 @@
 {
     "repository": "PhreshOS/phresh-program",
-    "version": "0.1.40",
-    "sha256": "7f2bb99438c7224e543147519a75d76a1db04313ff6ec6b024bb7532feb6a017",
+    "version": "0.1.42",
+    "sha256": "a05d624c773f52acaf7b16f65b0fd8f421bf61e7caad84348e4ec3871ae019cd",
     "development": true
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@phreshos/cli",
   "type": "module",
-  "version": "0.1.66",
+  "version": "0.1.68",
   "description": "The Phresh command-line interface for Program projects and system management.",
   "engines": {
     "node": ">=20.10"
@@ -47,8 +47,8 @@
   "packageManager": "bun@1.3.14",
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@phreshos/core": "^0.1.55",
-    "@phreshos/node": "^0.1.28",
+    "@phreshos/core": "^0.1.57",
+    "@phreshos/node": "^0.1.30",
     "adm-zip": "^0.6.0",
     "commander": "^15.0.0",
     "picocolors": "^1.1.1"