@phreshos/cli 0.1.6 → 0.1.8

package/README.md

@@ -41,6 +41,7 @@ System.
 phresh system install
 phresh system uninstall
 phresh system status
+phresh system version
 phresh system start
 phresh system stop
 phresh system enable
@@ -56,12 +57,14 @@ native per-user service. The selected release and the service entry therefore
 cannot become two competing sources of truth if installation is interrupted.
 It never reads a source checkout and never requires Bun or TypeScript.
 
-The System runs under `launchd` on macOS and `systemd --user` on Linux. The
-native manager owns it after the CLI exits and restarts a failed active
-service. `start` and `stop` change current execution only; `enable` and
-`disable` change automatic startup only. `status` reads installation,
-registration, startup, process, and local-intake readiness without changing
-any of them.
+The System runs under `launchd` on macOS and a real `systemd --user` manager on
+Linux. In Linux containers with no init manager, it runs as a detached
+user-owned background process that survives the terminal but ends with the
+container. Automatic startup is unavailable there rather than being reported
+as enabled. `start` and `stop` change current execution only; where a native
+manager exists, `enable` and `disable` change automatic startup only. `status`
+reports the installed version, service readiness, and automatic startup without
+changing them; `version` reports only the installed System release.
 
 Installation files and persistent System state have separate homes. Removing
 the System unregisters its service and removes its release files while keeping

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { Command, Option } from "commander";
 import metadata from "../package.json" with { type: "json" };
-import { PromptCancelled } from "./prompts.js";
+import { PromptCancelled, ReportedFailure } from "./prompts.js";
 import create from "./create.js";
 import install from "./install.js";
 import launch from "./launch.js";
@@ -17,7 +17,11 @@ const program = new Command()
     .description("Create Programs and manage PhreshOS")
     .version(version, "-v, --version")
     .showHelpAfterError()
-    .showSuggestionAfterError();
+    .showSuggestionAfterError()
+    .configureOutput({
+    writeOut: value => process.stdout.write(spaced(value)),
+    writeErr: value => process.stderr.write(spaced(value))
+});
 program.addHelpText("after", "\nRun phresh <command> --help for detailed command guidance.\n");
 describe(program.command("create")
     .description("create a new Program project")
@@ -119,11 +123,18 @@ try {
 catch (error) {
     if (error instanceof PromptCancelled)
         process.exitCode = 0;
+    else if (error instanceof ReportedFailure)
+        process.exitCode = 1;
     else {
         console.error(`\n  phresh: ${error instanceof Error ? error.message : String(error)}\n`);
         process.exitCode = 1;
     }
 }
+function spaced(value) {
+    if (value.endsWith("\n\n"))
+        return value;
+    return value.endsWith("\n") ? `${value}\n` : `${value}\n\n`;
+}
 function attached(name, summary, detail, mode) {
     describe(program.command(name)
         .description(summary)

package/dist/create.js

@@ -60,6 +60,7 @@ export default async function create(options = {}, directory = process.cwd()) {
     console.log(bold(`\n${bundled.development ? "Run Development Program" : "Run Program"}`));
     console.log(accent(script));
     console.log(bold("\nYou can now open the project and start building your Program"));
+    console.log("");
 }
 function template() {
     const candidates = [

package/dist/prompts.js

@@ -1,9 +1,12 @@
 import { cancel, confirm, intro, isCancel, log, outro, select, spinner, text } from "@clack/prompts";
 import colors from "picocolors";
-import { column, heading, line } from "./style.js";
+import { caution, column, ending, line, section } from "./style.js";
 /** Signals an ordinary interactive cancellation rather than an operation failure. */
 export class PromptCancelled extends Error {
 }
+/** An unsuccessful command whose complete explanation has already been shown. */
+export class ReportedFailure extends Error {
+}
 /**
  * One interaction language shared by commands that can ask questions.
  *
@@ -16,26 +19,32 @@ export default function prompts() {
         if (interactive)
             intro(`${colors.bold(title)}${context ? ` ${colors.dim(`· ${context}`)}` : ""}`);
         else
-            heading(title, context);
+            section(title, context);
     }
     function finish(message) {
         if (interactive)
             outro(colors.bold(message));
         else
-            heading(message);
+            ending(message);
     }
     function detail(label, value, source) {
         if (interactive)
-            log.message(`${colors.dim(column(label))}${value}${source ? `  ${colors.dim(source)}` : ""}`);
+            log.message(`${colors.dim(column(label))}${value}${source ? `  ${colors.dim(source)}` : ""}`, { spacing: 0 });
         else
             line(label, value, source);
     }
     function message(value = "") {
         if (interactive)
-            log.message(value);
+            log.message(value, { spacing: 0 });
         else
             console.log(value ? `  ${value}` : "");
     }
+    function warning(value) {
+        if (interactive)
+            log.warning(value, { spacing: 0 });
+        else
+            line("warning", caution(value));
+    }
     async function progress(message, completed, work) {
         if (!interactive)
             return await work();
@@ -55,7 +64,7 @@ export default function prompts() {
     async function ask(explanation, question, fallback) {
         if (!interactive)
             throw new Error(`${question} Supply the corresponding option when no terminal is attached`);
-        log.message(colors.dim(explanation));
+        log.message(colors.dim(explanation), { spacing: 0 });
         const value = await text({
             message: question,
             placeholder: fallback,
@@ -68,7 +77,7 @@ export default function prompts() {
     async function yes(explanation, question, fallback) {
         if (!interactive)
             throw new Error(`${question} Supply the corresponding option when no terminal is attached`);
-        log.message(colors.dim(explanation));
+        log.message(colors.dim(explanation), { spacing: 0 });
         const value = await confirm({ message: question, initialValue: fallback });
         if (isCancel(value))
             stop();
@@ -77,7 +86,7 @@ export default function prompts() {
     async function choose(explanation, question, values, fallback) {
         if (!interactive)
             throw new Error(`${question} Supply the corresponding option when no terminal is attached`);
-        log.message(colors.dim(explanation));
+        log.message(colors.dim(explanation), { spacing: 0 });
         const value = await select({
             message: question,
             options: values.map(value => ({ value, label: value })),
@@ -97,6 +106,7 @@ export default function prompts() {
         finish,
         detail,
         message,
+        warning,
         progress,
         ask,
         yes,

package/dist/style.js

@@ -3,6 +3,9 @@ import colors from "picocolors";
 export const dim = colors.dim;
 export const bold = colors.bold;
 export const accent = colors.cyan;
+export const positive = colors.green;
+export const caution = colors.yellow;
+export const negative = colors.red;
 // A label, what it says, and where that came from. The label is quiet
 // and the value is not, because the value is the thing being reported.
 //
@@ -17,6 +20,13 @@ export function column(label) {
 }
 export function heading(title, note) {
     console.log("");
+    section(title, note);
+    console.log("");
+}
+export function section(title, note) {
     console.log(`  ${bold(title)}${note ? `  ${dim("·")}  ${dim(note)}` : ""}`);
+}
+export function ending(message) {
+    console.log(`  ${bold(message)}`);
     console.log("");
 }

package/dist/system/command.js

@@ -1,5 +1,6 @@
 import SystemLifecycle from "./lifecycle.js";
-import prompts from "../prompts.js";
+import prompts, { ReportedFailure } from "../prompts.js";
+import { accent, caution, dim, negative, positive } from "../style.js";
 /** Attach the System lifecycle without mixing it with Program commands. */
 export default function systemCommands(program, provided) {
     let lifecycle = provided;
@@ -11,8 +12,7 @@ export default function systemCommands(program, provided) {
         const interaction = prompts();
         interaction.begin("Install System", "official stable release");
         const status = await interaction.progress("Installing PhreshOS", "PhreshOS installed", () => current().install());
-        report(interaction, status);
-        interaction.finish("System installed");
+        interaction.finish(`PhreshOS ${accent(status.installed?.version ?? "")} installed`);
     });
     system.command("uninstall")
         .description("remove the System installation and service")
@@ -24,37 +24,63 @@ export default function systemCommands(program, provided) {
         interaction.finish("System uninstalled");
     });
     system.command("status")
-        .description("show installation, service, and readiness state")
+        .description("show the System version and operating state")
         .action(async function () {
+        const status = await installed(current());
         const interaction = prompts();
         interaction.begin("System Status");
-        report(interaction, await current().status());
+        report(interaction, status);
+        interaction.finish(status.ready ? positive("System ready") : caution("System not ready"));
+    });
+    system.command("version")
+        .description("show the installed System version")
+        .action(async function () {
+        const status = await installed(current());
+        const interaction = prompts();
+        interaction.begin("System Version");
+        interaction.finish(`PhreshOS ${accent(status.installed.version)}`);
     });
-    action(system, "start", "start the background service", () => current().start());
-    action(system, "stop", "stop the background service", () => current().stop());
-    action(system, "enable", "enable automatic startup", () => current().enable());
-    action(system, "disable", "disable automatic startup", () => current().disable());
+    action(system, "start", "start the background service", current, lifecycle => lifecycle.start());
+    action(system, "stop", "stop the background service", current, lifecycle => lifecycle.stop());
+    action(system, "enable", "enable automatic startup", current, lifecycle => lifecycle.enable());
+    action(system, "disable", "disable automatic startup", current, lifecycle => lifecycle.disable());
     return system;
 }
-function action(system, name, description, work) {
+function action(system, name, description, current, work) {
     system.command(name)
         .description(description)
         .action(async function () {
+        const lifecycle = current();
+        await installed(lifecycle);
         const interaction = prompts();
         interaction.begin(`System ${title(name)}`);
-        const status = await interaction.progress(`${title(name)}ing PhreshOS`, `PhreshOS ${past(name)}`, work);
-        report(interaction, status);
+        await interaction.progress(`${title(name)}ing PhreshOS`, `PhreshOS ${past(name)}`, () => work(lifecycle));
         interaction.finish(`System ${past(name)}`);
     });
 }
 function report(interaction, status) {
-    interaction.detail("installation", status.installed ? `installed · ${status.installed.version}` : "not installed");
-    interaction.detail("service", status.registered ? "registered" : "not registered");
-    interaction.detail("startup", status.enabled ? "enabled" : "disabled");
-    interaction.detail("process", status.running ? `running${status.pid ? ` · ${status.pid}` : ""}` : "stopped");
-    interaction.detail("intake", status.ready ? `ready · ${status.intake}` : "not ready");
-    interaction.detail("files", status.root);
-    interaction.detail("log", status.log);
+    interaction.detail("version", accent(status.installed?.version ?? "unknown"));
+    interaction.detail("service", service(status));
+    interaction.detail("startup", status.automaticStartup ? status.enabled ? positive("enabled") : dim("disabled") : dim("unavailable"));
+}
+async function installed(lifecycle) {
+    const status = await lifecycle.status();
+    if (status.installed)
+        return { ...status, installed: status.installed };
+    const interaction = prompts();
+    interaction.begin("PhreshOS System");
+    interaction.warning("PhreshOS System is not installed");
+    interaction.finish(`${dim("Install it with")} ${accent("phresh system install")}`);
+    throw new ReportedFailure();
+}
+function service(status) {
+    if (status.ready)
+        return positive("ready");
+    if (status.running)
+        return caution("starting");
+    if (status.registered)
+        return caution("stopped");
+    return negative("not registered");
 }
 function title(value) {
     return `${value[0]?.toUpperCase()}${value.slice(1)}`;

package/dist/system/lifecycle.js

@@ -4,6 +4,7 @@ import { intakeReady, waitForIntake } from "./readiness.js";
 import systemPaths from "./paths.js";
 import systemService from "./service/index.js";
 import nodeExecutable from "./node.js";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 /** Coordinates acquisition, immutable files, and the native service as one transaction. */
 export default class SystemLifecycle {
@@ -34,7 +35,8 @@ export default class SystemLifecycle {
         const activation = await this.activate(prepared, previous, previousService);
         try {
             await service.register(definition(installation, executable));
-            await service.enable();
+            if ((await service.inspect()).automaticStartup)
+                await service.enable();
             await service.start();
             await this.waitUntilReady();
             await activation.commit();
@@ -123,7 +125,8 @@ export default class SystemLifecycle {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            throw new Error(`${message}. Service log: ${installation.paths.log}`, { cause: error });
+            const log = existsSync(installation.paths.log) ? `. Service log: ${installation.paths.log}` : "";
+            throw new Error(`${message}${log}`, { cause: error });
         }
     }
     async activate(prepared, previous, state) {

package/dist/system/service/background.js

@@ -0,0 +1,139 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, open, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+/**
+ * Owns the System for the lifetime of a Linux container with no init manager.
+ * Registration and the pid are user files; execution is a detached Node child.
+ */
+export default class BackgroundSystemService {
+    definition;
+    pid;
+    constructor(userHome) {
+        this.definition = join(userHome, ".config", "phreshos", "system-service.json");
+        this.pid = join(userHome, ".local", "state", "phreshos", "system.pid");
+    }
+    async inspect() {
+        const registered = existsSync(this.definition);
+        const pid = await this.readPid();
+        const running = pid !== undefined && await this.owns(pid);
+        if (pid !== undefined && !running)
+            await rm(this.pid, { force: true });
+        return {
+            registered,
+            automaticStartup: false,
+            enabled: false,
+            running,
+            ...(running ? { pid } : {})
+        };
+    }
+    async register(definition) {
+        await this.stop();
+        await atomic(this.definition, JSON.stringify(definition), 0o600);
+    }
+    async unregister() {
+        await this.stop();
+        await rm(this.definition, { force: true });
+    }
+    async start() {
+        const definition = await this.readDefinition();
+        if ((await this.inspect()).running)
+            return;
+        await mkdir(dirname(definition.output), { recursive: true });
+        const output = await open(definition.output, "a", 0o600);
+        try {
+            const child = spawn(definition.executable, [definition.entry], {
+                cwd: definition.directory,
+                detached: true,
+                stdio: ["ignore", output.fd, output.fd]
+            });
+            await new Promise(function (settle, refuse) {
+                child.once("spawn", settle);
+                child.once("error", refuse);
+            });
+            if (child.pid === undefined)
+                throw new Error("The PhreshOS System background process has no pid");
+            await atomic(this.pid, String(child.pid), 0o600);
+            child.unref();
+        }
+        finally {
+            await output.close();
+        }
+    }
+    async stop() {
+        const pid = await this.readPid();
+        if (pid === undefined)
+            return;
+        if (!await this.owns(pid)) {
+            await rm(this.pid, { force: true });
+            return;
+        }
+        process.kill(pid, "SIGTERM");
+        const until = Date.now() + 5_000;
+        while (Date.now() < until && await this.owns(pid))
+            await new Promise(settle => setTimeout(settle, 50));
+        if (await this.owns(pid))
+            process.kill(pid, "SIGKILL");
+        await rm(this.pid, { force: true });
+    }
+    async enable() {
+        throw new Error("Automatic System startup is unavailable because this Linux environment has no service manager");
+    }
+    async disable() {
+        throw new Error("Automatic System startup is unavailable because this Linux environment has no service manager");
+    }
+    async readDefinition() {
+        let value;
+        try {
+            value = JSON.parse(await readFile(this.definition, "utf8"));
+        }
+        catch {
+            throw new Error("The PhreshOS System service is not registered");
+        }
+        if (!definition(value))
+            throw new Error("The PhreshOS System service definition is invalid");
+        return value;
+    }
+    async readPid() {
+        try {
+            const value = (await readFile(this.pid, "utf8")).trim();
+            return /^[1-9][0-9]*$/.test(value) ? Number(value) : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async owns(pid) {
+        try {
+            process.kill(pid, 0);
+        }
+        catch {
+            return false;
+        }
+        if (process.platform !== "linux")
+            return true;
+        const definition = await this.readDefinition().catch(() => undefined);
+        if (!definition)
+            return false;
+        const command = await readFile(`/proc/${pid}/cmdline`, "utf8").catch(() => "");
+        return command.split("\0").includes(definition.entry);
+    }
+}
+async function atomic(path, content, mode) {
+    await mkdir(dirname(path), { recursive: true });
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, content, { mode });
+        await rename(temporary, path);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+function definition(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return ["executable", "entry", "directory", "output"].every(name => typeof candidate[name] === "string" && candidate[name] !== "");
+}

package/dist/system/service/index.js

@@ -1,7 +1,7 @@
 import { homedir } from "node:os";
 import LinuxSystemService from "./linux.js";
 import MacOSSystemService from "./macos.js";
-/** Select the native per-user service manager without changing its semantics. */
+/** Select the per-user service implementation available in this environment. */
 export default function systemService(platform = process.platform, userHome = homedir()) {
     if (platform === "darwin")
         return new MacOSSystemService(userHome);

package/dist/system/service/linux.js

@@ -1,94 +1,38 @@
 import { execute } from "../process.js";
-import { existsSync } from "node:fs";
-import { mkdir, rename, rm, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { randomUUID } from "node:crypto";
+import BackgroundSystemService from "./background.js";
+import SystemdSystemService from "./systemd.js";
 const command = "systemctl";
-const unit = "phreshos.service";
+/** Selects systemd only after proving that its user manager is real. */
 export default class LinuxSystemService {
-    run;
-    file;
+    selected;
     constructor(userHome, run = execute) {
-        this.run = run;
-        this.file = join(userHome, ".config", "systemd", "user", unit);
+        this.selected = select(userHome, run);
     }
     async inspect() {
-        const registered = existsSync(this.file);
-        const active = await this.run(command, ["--user", "is-active", "--quiet", unit]);
-        const enabled = await this.run(command, ["--user", "is-enabled", "--quiet", unit]);
-        const pid = active.code === 0 ? await this.run(command, ["--user", "show", unit, "--property", "MainPID", "--value"]) : undefined;
-        const value = pid && /^[0-9]+$/.test(pid.stdout.trim()) ? Number(pid.stdout.trim()) : undefined;
-        return {
-            registered,
-            enabled: registered && enabled.code === 0,
-            running: registered && active.code === 0,
-            ...(value ? { pid: value } : {})
-        };
+        return await (await this.selected).inspect();
     }
     async register(definition) {
-        await this.stop();
-        await mkdir(dirname(this.file), { recursive: true });
-        await mkdir(dirname(definition.output), { recursive: true });
-        const temporary = `${this.file}.${randomUUID()}.tmp`;
-        try {
-            await writeFile(temporary, service(definition), { mode: 0o600 });
-            await rename(temporary, this.file);
-        }
-        finally {
-            await rm(temporary, { force: true });
-        }
-        await this.require(["--user", "daemon-reload"]);
+        await (await this.selected).register(definition);
     }
     async unregister() {
-        await this.stop();
-        await this.run(command, ["--user", "disable", unit]);
-        await rm(this.file, { force: true });
-        await this.require(["--user", "daemon-reload"]);
-        await this.run(command, ["--user", "reset-failed", unit]);
+        await (await this.selected).unregister();
     }
     async start() {
-        if (!existsSync(this.file))
-            throw new Error("The PhreshOS System service is not registered");
-        await this.require(["--user", "start", unit]);
+        await (await this.selected).start();
     }
     async stop() {
-        const state = await this.run(command, ["--user", "is-active", "--quiet", unit]);
-        if (state.code === 0)
-            await this.require(["--user", "stop", unit]);
+        await (await this.selected).stop();
     }
     async enable() {
-        if (!existsSync(this.file))
-            throw new Error("The PhreshOS System service is not registered");
-        await this.require(["--user", "enable", unit]);
+        await (await this.selected).enable();
     }
     async disable() {
-        if (!existsSync(this.file))
-            throw new Error("The PhreshOS System service is not registered");
-        await this.require(["--user", "disable", unit]);
+        await (await this.selected).disable();
     }
-    async require(args) {
-        const result = await this.run(command, args);
-        if (result.code !== 0)
-            throw new Error(result.stderr.trim() || result.stdout.trim() || `${command} exited with code ${result.code}`);
-    }
-}
-function service(definition) {
-    return `[Unit]
-Description=PhreshOS System
-
-[Service]
-Type=simple
-ExecStart=${quote(definition.executable)} ${quote(definition.entry)}
-WorkingDirectory=${quote(definition.directory)}
-Restart=on-failure
-RestartSec=2
-StandardOutput=append:${quote(definition.output)}
-StandardError=append:${quote(definition.output)}
-
-[Install]
-WantedBy=default.target
-`;
 }
-function quote(value) {
-    return JSON.stringify(value);
+async function select(userHome, run) {
+    const result = await run(command, ["--user", "show-environment"]).catch(() => undefined);
+    const lines = result?.stdout.trim().split("\n").filter(Boolean) ?? [];
+    const systemd = result?.code === 0 && lines.length > 0 && lines.every(line => /^[a-zA-Z_][a-zA-Z0-9_]*=/.test(line));
+    return systemd ? new SystemdSystemService(userHome, run) : new BackgroundSystemService(userHome);
 }

package/dist/system/service/macos.js

@@ -29,6 +29,7 @@ export default class MacOSSystemService {
         const pid = /\bpid\s*=\s*(\d+)/.exec(service.stdout)?.[1];
         return {
             registered,
+            automaticStartup: true,
             enabled: registered && !explicitlyDisabled,
             running: service.code === 0 && /\bstate\s*=\s*running\b/.test(service.stdout),
             ...(pid ? { pid: Number(pid) } : {})

package/dist/system/service/systemd.js

@@ -0,0 +1,101 @@
+import { execute } from "../process.js";
+import { existsSync } from "node:fs";
+import { mkdir, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { randomUUID } from "node:crypto";
+const command = "systemctl";
+const unit = "phreshos.service";
+/** A real systemd user manager, after Linux selection has proved it exists. */
+export default class SystemdSystemService {
+    run;
+    file;
+    constructor(userHome, run = execute) {
+        this.run = run;
+        this.file = join(userHome, ".config", "systemd", "user", unit);
+    }
+    async inspect() {
+        const registered = existsSync(this.file);
+        const active = await this.run(command, ["--user", "is-active", "--quiet", unit]);
+        const enabled = await this.run(command, ["--user", "is-enabled", "--quiet", unit]);
+        const pid = active.code === 0 ? await this.run(command, ["--user", "show", unit, "--property", "MainPID", "--value"]) : undefined;
+        const value = pid && /^[0-9]+$/.test(pid.stdout.trim()) ? Number(pid.stdout.trim()) : undefined;
+        return {
+            registered,
+            automaticStartup: true,
+            enabled: registered && enabled.code === 0,
+            running: registered && active.code === 0,
+            ...(value ? { pid: value } : {})
+        };
+    }
+    async register(definition) {
+        await this.stop();
+        await mkdir(dirname(this.file), { recursive: true });
+        await mkdir(dirname(definition.output), { recursive: true });
+        const temporary = `${this.file}.${randomUUID()}.tmp`;
+        try {
+            await writeFile(temporary, service(definition), { mode: 0o600 });
+            await rename(temporary, this.file);
+        }
+        finally {
+            await rm(temporary, { force: true });
+        }
+        await this.require(["--user", "daemon-reload"]);
+    }
+    async unregister() {
+        await this.stop();
+        await this.run(command, ["--user", "disable", unit]);
+        await rm(this.file, { force: true });
+        await this.require(["--user", "daemon-reload"]);
+        await this.run(command, ["--user", "reset-failed", unit]);
+    }
+    async start() {
+        if (!existsSync(this.file))
+            throw new Error("The PhreshOS System service is not registered");
+        await this.require(["--user", "start", unit]);
+    }
+    async stop() {
+        const state = await this.run(command, ["--user", "is-active", "--quiet", unit]);
+        if (state.code === 0)
+            await this.require(["--user", "stop", unit]);
+    }
+    async enable() {
+        if (!existsSync(this.file))
+            throw new Error("The PhreshOS System service is not registered");
+        await this.require(["--user", "enable", unit]);
+    }
+    async disable() {
+        if (!existsSync(this.file))
+            throw new Error("The PhreshOS System service is not registered");
+        await this.require(["--user", "disable", unit]);
+    }
+    async require(args) {
+        const result = await this.run(command, args);
+        if (result.code !== 0)
+            throw new Error(result.stderr.trim() || result.stdout.trim() || `${command} exited with code ${result.code}`);
+    }
+}
+function service(definition) {
+    return `[Unit]
+Description=PhreshOS System
+
+[Service]
+Type=simple
+ExecStart=${quote(definition.executable)} ${quote(definition.entry)}
+WorkingDirectory=${setting(definition.directory)}
+Restart=on-failure
+RestartSec=2
+StandardOutput=append:${setting(definition.output)}
+StandardError=append:${setting(definition.output)}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function quote(value) {
+    return JSON.stringify(value);
+}
+function setting(value) {
+    if (value.includes("\n") || value.includes("\r"))
+        throw new Error("A systemd service path cannot contain a line break");
+    return value.replaceAll("%", "%%");
+}

package/dist/template/package.json

@@ -16,7 +16,7 @@
         "react-dom": "^19.2.8"
     },
     "devDependencies": {
-        "@phreshos/cli": "^0.1.6",
+        "@phreshos/cli": "^0.1.8",
         "@types/node": "^26.2.0",
         "@types/react": "^19.2.18",
         "@types/react-dom": "^19.2.4",

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@phreshos/cli",
     "type": "module",
-    "version": "0.1.6",
+    "version": "0.1.8",
     "description": "The Phresh command-line interface for Program projects and system management.",
     "engines": {
         "node": ">=20.10"
@@ -13,6 +13,7 @@
         "test": "node --run compile && node --test tests/*.test.mjs",
         "verify": "node --run build && node --run test && node scripts/verify-package.mjs",
         "verify:system-release": "node --run compile && node scripts/verify-system-release.mjs",
+        "verify:linux-service": "node --run compile && node scripts/verify-linux-service.mjs",
         "verify:macos-service": "node --run compile && node scripts/verify-macos-service.mjs",
         "prepack": "node --run build"
     },