@bytetrue/byspace 0.14.6 → 0.16.0

package/dist/commands/daemon/index.js

@@ -3,6 +3,9 @@ import { startCommand } from "./start.js";
 import { runStatusCommand } from "./status.js";
 import { runStopCommand } from "./stop.js";
 import { runRestartCommand } from "./restart.js";
+import { runInstallServiceCommand } from "./install-service.js";
+import { runUninstallServiceCommand } from "./uninstall-service.js";
+import { runServiceStatusCommand } from "./service-status.js";
 import { runSetPasswordCommand } from "./set-password.js";
 import { pairCommand } from "./pair.js";
 import { runDaemonReloadCommand } from "./reload.js";
@@ -55,6 +58,19 @@ export function createDaemonCommand() {
         .description("Prompt for and save a hashed daemon password to config.json"))
         .option("--home <path>", "BySpace home directory (default: ~/.byspace)")
         .action(withOutput(runSetPasswordCommand));
+    addJsonOption(daemon
+        .command("install-service")
+        .description("Register the daemon as a login service (macOS LaunchAgent)"))
+        .option("--home <path>", "BySpace home directory (default: ~/.byspace)")
+        .action(withOutput(runInstallServiceCommand));
+    addJsonOption(daemon.command("uninstall-service").description("Unregister the daemon login service"))
+        .option("--home <path>", "BySpace home directory (default: ~/.byspace)")
+        .action(withOutput(runUninstallServiceCommand));
+    addJsonOption(daemon
+        .command("service-status")
+        .description("Show whether the daemon is managed by the OS service manager"))
+        .option("--home <path>", "BySpace home directory (default: ~/.byspace)")
+        .action(withOutput(runServiceStatusCommand));
     return daemon;
 }
 //# sourceMappingURL=index.js.map

package/dist/commands/daemon/install-service.d.ts

@@ -0,0 +1,15 @@
+import type { Command } from "commander";
+import type { CommandOptions, SingleResult } from "../../output/index.js";
+interface InstallServiceResult {
+    action: "installed";
+    label: string;
+    plistPath: string;
+    runnerEntry: string;
+    nodePath: string;
+    logPath: string;
+    message: string;
+}
+export type InstallServiceCommandResult = SingleResult<InstallServiceResult>;
+export declare function runInstallServiceCommand(options: CommandOptions, _command: Command): Promise<InstallServiceCommandResult>;
+export {};
+//# sourceMappingURL=install-service.d.ts.map

package/dist/commands/daemon/install-service.js

@@ -0,0 +1,69 @@
+import { buildDaemonServiceSpec, launchdPlistPath } from "./service/service-spec.js";
+import { installLaunchdService } from "./service/launchd.js";
+import { isRunningInDocker, validateServiceInstallOrigin } from "./service/service-status.js";
+import { validateDaemonInstallOrigin, daemonInstallOriginRuntime, } from "@bytetrue/server/daemon-install-origin";
+import { npmGlobalBySpaceCli, BYSPACE_CLI_PACKAGE } from "@bytetrue/server/npm-global-cli";
+import { resolveLocalDaemonState, resolveDaemonRunnerEntry } from "./local-daemon.js";
+const installServiceResultSchema = {
+    idField: "action",
+    columns: [
+        {
+            header: "STATUS",
+            field: "action",
+            color: () => "green",
+        },
+        { header: "LABEL", field: "label" },
+        { header: "PLIST", field: "plistPath" },
+        { header: "RUNNER", field: "runnerEntry" },
+        { header: "MESSAGE", field: "message" },
+    ],
+};
+export async function runInstallServiceCommand(options, _command) {
+    const home = typeof options.home === "string" ? options.home : undefined;
+    const state = resolveLocalDaemonState({ home });
+    try {
+        const dockerError = validateServiceInstallOrigin({
+            installOriginError: null,
+            isDocker: isRunningInDocker(),
+        });
+        if (dockerError)
+            throw new Error(dockerError);
+        const install = await npmGlobalBySpaceCli.inspect();
+        const originError = validateServiceInstallOrigin({
+            installOriginError: validateDaemonInstallOrigin(install, install.version, daemonInstallOriginRuntime),
+            isDocker: false,
+        });
+        if (originError)
+            throw new Error(originError);
+        const spec = buildDaemonServiceSpec({
+            home: state.home,
+            logPath: state.logPath,
+            runnerEntry: resolveDaemonRunnerEntry(),
+            env: process.env,
+        });
+        installLaunchdService(spec, state.home);
+        return {
+            type: "single",
+            data: {
+                action: "installed",
+                label: spec.label,
+                plistPath: launchdPlistPath(spec.label, state.home),
+                runnerEntry: spec.runnerEntry,
+                nodePath: spec.nodePath,
+                logPath: spec.logPath,
+                message: `Registered ${spec.label}; the daemon starts at login and survives terminal exit.`,
+            },
+            schema: installServiceResultSchema,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "INSTALL_SERVICE_FAILED",
+            message: `Failed to install the daemon service: ${message}`,
+            details: `Only daemons running from the npm global ${BYSPACE_CLI_PACKAGE} install can be registered as a service.`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=install-service.js.map

package/dist/commands/daemon/local-daemon.d.ts

@@ -66,6 +66,7 @@ export interface DaemonLaunchRuntime {
 }
 export declare const DEFAULT_STOP_TIMEOUT_MS = 15000;
 export declare const DEFAULT_KILL_TIMEOUT_MS = 3000;
+export declare function resolveDaemonRunnerEntry(): string;
 export declare function resolveLocalBySpaceHome(home?: string): string;
 export declare function resolveTcpHostFromListen(listen: string): string | null;
 export declare function resolveLocalDaemonState(options?: {

package/dist/commands/daemon/local-daemon.js

@@ -98,7 +98,7 @@ function resolveServerRunnerFromDir(currentDir) {
         return null;
     }
 }
-function resolveDaemonRunnerEntry() {
+export function resolveDaemonRunnerEntry() {
     const serverExportPath = require.resolve("@bytetrue/server");
     let currentDir = path.dirname(serverExportPath);
     while (true) {

package/dist/commands/daemon/service/backend.d.ts

@@ -0,0 +1,16 @@
+import type { DaemonServiceSpec } from "./service-spec.js";
+/**
+ * Which service-manager backend applies on this host. The command layer dispatches
+ * on this instead of scattering `process.platform` branches.
+ */
+export type ServiceBackend = "launchd" | "systemd" | "windows-task" | "unsupported";
+export declare function resolveServiceBackend(platform?: NodeJS.Platform): ServiceBackend;
+export interface ServiceBackendApi {
+    install(spec: DaemonServiceSpec): void;
+    uninstall(label: string): void;
+    /** The pid the service manager reports, or null when not loaded/running. */
+    servicePid(label: string): number | null;
+}
+/** Backend dispatch. Each module is imported lazily so unused platform code never loads. */
+export declare function serviceBackend(backend: ServiceBackend): ServiceBackendApi;
+//# sourceMappingURL=backend.d.ts.map

package/dist/commands/daemon/service/backend.js

@@ -0,0 +1,50 @@
+export function resolveServiceBackend(platform = process.platform) {
+    switch (platform) {
+        case "darwin":
+            return "launchd";
+        case "linux":
+            return "systemd";
+        case "win32":
+            return "windows-task";
+        default:
+            return "unsupported";
+    }
+}
+/** Backend dispatch. Each module is imported lazily so unused platform code never loads. */
+export function serviceBackend(backend) {
+    switch (backend) {
+        case "launchd": {
+            const launchd = require("./launchd.js");
+            return {
+                install: (spec) => {
+                    const { resolveBySpaceHome } = require("@bytetrue/server");
+                    launchd.installLaunchdService(spec, resolveBySpaceHome());
+                },
+                uninstall: (label) => {
+                    const { resolveBySpaceHome } = require("@bytetrue/server");
+                    launchd.uninstallLaunchdService(label, resolveBySpaceHome());
+                },
+                servicePid: (label) => launchd.launchdServicePid(label),
+            };
+        }
+        case "systemd": {
+            const systemd = require("./systemd.js");
+            return {
+                install: (spec) => systemd.installSystemdService(spec),
+                uninstall: (label) => systemd.uninstallSystemdService(label),
+                servicePid: (label) => systemd.systemdServicePid(label),
+            };
+        }
+        case "windows-task": {
+            const win = require("./windows-task.js");
+            return {
+                install: (spec) => win.installWindowsTask(spec),
+                uninstall: (label) => win.uninstallWindowsTask(label),
+                servicePid: () => null,
+            };
+        }
+        default:
+            throw new Error("This platform has no supported service manager integration (expected macOS, Linux, or Windows).");
+    }
+}
+//# sourceMappingURL=backend.js.map

package/dist/commands/daemon/service/launchd.d.ts

@@ -0,0 +1,15 @@
+import type { DaemonServiceSpec } from "./service-spec.js";
+/**
+ * Render the launchd plist XML for the spec. KeepAlive is deliberately false: the
+ * supervisor already restarts crashed workers, and launchd KeepAlive would resurrect
+ * the daemon right after `byspace daemon stop`, breaking stop semantics. RunAtLoad
+ * provides the "start at login" behavior.
+ */
+export declare function renderLaunchdPlist(spec: DaemonServiceSpec): string;
+/** Write the plist and load it with `launchctl bootstrap gui/<uid>`. */
+export declare function installLaunchdService(spec: DaemonServiceSpec, home: string): void;
+/** Unload and delete the plist. Idempotent: succeeds when nothing is installed. */
+export declare function uninstallLaunchdService(label: string, home: string): void;
+/** Query the pid launchd reports for the label, or null when not loaded. */
+export declare function launchdServicePid(label: string): number | null;
+//# sourceMappingURL=launchd.d.ts.map

package/dist/commands/daemon/service/launchd.js

@@ -0,0 +1,101 @@
+import { spawnSync } from "node:child_process";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { launchdPlistPath } from "./service-spec.js";
+/**
+ * Render the launchd plist XML for the spec. KeepAlive is deliberately false: the
+ * supervisor already restarts crashed workers, and launchd KeepAlive would resurrect
+ * the daemon right after `byspace daemon stop`, breaking stop semantics. RunAtLoad
+ * provides the "start at login" behavior.
+ */
+export function renderLaunchdPlist(spec) {
+    const programArgs = [spec.nodePath, spec.runnerEntry, ...spec.runnerArgs];
+    const args = programArgs
+        .map((a) => `<string>${escapeXml(a)}</string>`)
+        .map((s) => `    ${s}`)
+        .join("\n");
+    const envEntries = Object.entries(spec.env)
+        .map(([key, value]) => `    <key>${escapeXml(key)}</key>\n    <string>${escapeXml(value)}</string>`)
+        .join("\n");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${escapeXml(spec.label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+${envEntries}
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(spec.logPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(spec.logPath)}</string>
+  <key>ProcessType</key>
+  <string>Background</string>
+</dict>
+</plist>
+`;
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+function launchctl(args, input) {
+    const result = spawnSync("launchctl", args, {
+        encoding: "utf8",
+        input,
+        timeout: 15000,
+    });
+    const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+    return { ok: result.status === 0, output };
+}
+/** Write the plist and load it with `launchctl bootstrap gui/<uid>`. */
+export function installLaunchdService(spec, home) {
+    const plistPath = launchdPlistPath(spec.label, home);
+    mkdirSync(path.dirname(plistPath), { recursive: true });
+    writeFileSync(plistPath, renderLaunchdPlist(spec), { mode: 0o644 });
+    const uid = process.getuid?.() ??
+        (() => {
+            throw new Error("cannot resolve uid");
+        })();
+    // bootout first so re-installing over a loaded service is idempotent.
+    launchctl(["bootout", `gui/${uid}/${spec.label}`]);
+    const boot = launchctl(["bootstrap", `gui/${String(uid)}`, plistPath]);
+    if (!boot.ok) {
+        throw new Error(`launchctl bootstrap failed: ${boot.output}`);
+    }
+}
+/** Unload and delete the plist. Idempotent: succeeds when nothing is installed. */
+export function uninstallLaunchdService(label, home) {
+    const uid = process.getuid?.() ??
+        (() => {
+            throw new Error("cannot resolve uid");
+        })();
+    launchctl(["bootout", `gui/${uid}/${label}`]);
+    const plistPath = launchdPlistPath(label, home);
+    rmSync(plistPath, { force: true });
+}
+/** Query the pid launchd reports for the label, or null when not loaded. */
+export function launchdServicePid(label) {
+    const uid = process.getuid?.();
+    if (uid === undefined)
+        return null;
+    const { ok, output } = launchctl(["print", `gui/${uid}/${label}`]);
+    if (!ok)
+        return null;
+    const match = output.match(/^\s*pid\s*=\s*(\d+)/m);
+    return match ? Number(match[1]) : null;
+}
+//# sourceMappingURL=launchd.js.map

package/dist/commands/daemon/service/service-spec.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Platform-agnostic description of the daemon service definition. Platform backends
+ * (launchd/systemd/Task Scheduler) translate this into their native format.
+ *
+ * Everything here must be an absolute path or an exact value: service managers do not
+ * read shell profiles, so nothing may depend on the login environment at run time.
+ */
+export interface DaemonServiceSpec {
+    /** Reverse-DNS service label, e.g. `cc.cd.byspace.daemon`. */
+    label: string;
+    /** Absolute path to the node executable that runs the daemon. */
+    nodePath: string;
+    /** Absolute path to the daemon runner entry (supervisor entrypoint). */
+    runnerEntry: string;
+    /** Extra arguments passed to the runner. */
+    runnerArgs: string[];
+    /** Absolute path to the daemon log file. */
+    logPath: string;
+    /** Environment variables snapshotted at install time. */
+    env: Record<string, string>;
+}
+/**
+ * Home directories that macOS `launchctl bootstrap gui/<uid>` reads LaunchAgents from,
+ * in check order. XDG overrides the legacy path when it exists.
+ */
+export declare function launchAgentDirs(home: string): string[];
+/** Absolute plist path for the label, resolved against the first existing dir. */
+export declare function launchdPlistPath(label: string, home: string): string;
+/**
+ * True when a plist for the label exists in any LaunchAgents dir. Presence alone does
+ * not mean the service is loaded — see `readLaunchdPlist`.
+ */
+export declare function launchdPlistExists(label: string, home: string): boolean;
+/** Read and parse the installed plist for the label, or null when absent/unparsable. */
+export declare function readLaunchdPlist(label: string, home: string): {
+    path: string;
+    program: string[];
+    env: Record<string, string>;
+} | null;
+/**
+ * Collect the env vars the daemon needs to survive in a bare launchd environment:
+ * BYSPACE_* overrides plus a PATH that can resolve agent binaries (pi/claude/...) and
+ * git. Snapshot from the *installing* shell — that is the environment that worked.
+ */
+export declare function snapshotServiceEnv(env: NodeJS.ProcessEnv): Record<string, string>;
+/** Build the ServiceSpec for the current process. Throws when prerequisites are missing. */
+export declare function buildDaemonServiceSpec(options: {
+    home: string;
+    logPath: string;
+    runnerEntry: string;
+    runnerArgs?: string[];
+    env?: NodeJS.ProcessEnv;
+}): DaemonServiceSpec;
+//# sourceMappingURL=service-spec.d.ts.map

package/dist/commands/daemon/service/service-spec.js

@@ -0,0 +1,95 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+/**
+ * Home directories that macOS `launchctl bootstrap gui/<uid>` reads LaunchAgents from,
+ * in check order. XDG overrides the legacy path when it exists.
+ */
+export function launchAgentDirs(home) {
+    const xdg = process.env.XDG_CONFIG_HOME;
+    const dirs = [];
+    if (xdg)
+        dirs.push(path.join(xdg, "LaunchAgents"));
+    dirs.push(path.join(home, "Library", "LaunchAgents"));
+    return dirs;
+}
+/** Absolute plist path for the label, resolved against the first existing dir. */
+export function launchdPlistPath(label, home) {
+    for (const dir of launchAgentDirs(home)) {
+        if (existsSync(dir))
+            return path.join(dir, `${label}.plist`);
+    }
+    return path.join(home, "Library", "LaunchAgents", `${label}.plist`);
+}
+/**
+ * True when a plist for the label exists in any LaunchAgents dir. Presence alone does
+ * not mean the service is loaded — see `readLaunchdPlist`.
+ */
+export function launchdPlistExists(label, home) {
+    return launchAgentDirs(home).some((dir) => existsSync(path.join(dir, `${label}.plist`)));
+}
+/** Read and parse the installed plist for the label, or null when absent/unparsable. */
+export function readLaunchdPlist(label, home) {
+    for (const dir of launchAgentDirs(home)) {
+        const plistPath = path.join(dir, `${label}.plist`);
+        if (!existsSync(plistPath))
+            continue;
+        try {
+            const doc = parsePlistJson(plistPath);
+            const program = doc.ProgramArguments ?? [];
+            const envDict = doc.EnvironmentVariables ?? {};
+            return { path: plistPath, program, env: envDict };
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+/** Parse a plist via the macOS-native `plutil -convert json` (no npm dependency). */
+function parsePlistJson(plistPath) {
+    const result = spawnSync("plutil", ["-convert", "json", "-o", "-", plistPath], {
+        encoding: "utf8",
+        timeout: 10000,
+    });
+    if (result.status !== 0)
+        throw new Error(`plutil failed: ${result.stderr ?? ""}`);
+    return JSON.parse(result.stdout);
+}
+/**
+ * Collect the env vars the daemon needs to survive in a bare launchd environment:
+ * BYSPACE_* overrides plus a PATH that can resolve agent binaries (pi/claude/...) and
+ * git. Snapshot from the *installing* shell — that is the environment that worked.
+ */
+export function snapshotServiceEnv(env) {
+    const snapshot = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (key.startsWith("BYSPACE_") && value !== undefined)
+            snapshot[key] = value;
+    }
+    snapshot.PATH = env.PATH ?? "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin";
+    return snapshot;
+}
+/** Build the ServiceSpec for the current process. Throws when prerequisites are missing. */
+export function buildDaemonServiceSpec(options) {
+    const env = options.env ?? process.env;
+    const nodePath = process.execPath;
+    if (!nodePath.startsWith("/")) {
+        throw new Error(`node executable is not an absolute path: ${nodePath}`);
+    }
+    if (!options.runnerEntry || !path.isAbsolute(options.runnerEntry)) {
+        throw new Error(`daemon runner entry must be an absolute path, got: ${options.runnerEntry || "(empty)"}`);
+    }
+    if (!existsSync(options.runnerEntry)) {
+        throw new Error(`daemon runner entry does not exist: ${options.runnerEntry}`);
+    }
+    return {
+        label: "cc.cd.byspace.daemon",
+        nodePath,
+        runnerEntry: options.runnerEntry,
+        runnerArgs: options.runnerArgs ?? [],
+        logPath: options.logPath,
+        env: snapshotServiceEnv(env),
+    };
+}
+//# sourceMappingURL=service-spec.js.map

package/dist/commands/daemon/service/service-status.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Service management state. Deliberately distinct from "is a daemon running": the
+ * service definition can exist while the daemon runs from a terminal instead, and a
+ * stale plist can exist with nothing behind it. Report what is verifiable; the UI must
+ * not claim "managed" without the pid matching.
+ */
+export type DaemonServiceState = "not-installed" | "installed-stopped" | "installed-running-not-this-process" | "managed-by-service" | "unknown";
+export interface DaemonServiceStatus {
+    state: DaemonServiceState;
+    label: string;
+    /** Pid launchd reports for the service, when loaded. */
+    servicePid: number | null;
+    /** Pid of the currently running process (the caller's own daemon pid). */
+    currentPid: number | null;
+}
+export declare function resolveLaunchdServiceStatus(label: string, home: string, currentPid: number | null): DaemonServiceStatus;
+/**
+ * Guard for install: only a daemon running from the published npm global install may
+ * register itself as a service, otherwise the service would point at a temporary
+ * checkout (dev) or a container filesystem (Docker) and break on the next reboot.
+ */
+export declare function validateServiceInstallOrigin(options: {
+    installOriginError: string | null;
+    isDocker: boolean;
+}): string | null;
+/** True when running inside a Docker container. */
+export declare function isRunningInDocker(): boolean;
+//# sourceMappingURL=service-status.d.ts.map

package/dist/commands/daemon/service/service-status.js

@@ -0,0 +1,32 @@
+import { existsSync } from "node:fs";
+import { launchdPlistExists } from "./service-spec.js";
+import { launchdServicePid } from "./launchd.js";
+export function resolveLaunchdServiceStatus(label, home, currentPid) {
+    if (!launchdPlistExists(label, home)) {
+        return { state: "not-installed", label, servicePid: null, currentPid };
+    }
+    const servicePid = launchdServicePid(label);
+    if (servicePid === null) {
+        return { state: "installed-stopped", label, servicePid: null, currentPid };
+    }
+    if (currentPid !== null && servicePid === currentPid) {
+        return { state: "managed-by-service", label, servicePid, currentPid };
+    }
+    return { state: "installed-running-not-this-process", label, servicePid, currentPid };
+}
+/**
+ * Guard for install: only a daemon running from the published npm global install may
+ * register itself as a service, otherwise the service would point at a temporary
+ * checkout (dev) or a container filesystem (Docker) and break on the next reboot.
+ */
+export function validateServiceInstallOrigin(options) {
+    if (options.isDocker) {
+        return "Registering a service is not supported inside Docker. Use the container runtime's restart policy instead.";
+    }
+    return options.installOriginError;
+}
+/** True when running inside a Docker container. */
+export function isRunningInDocker() {
+    return existsSync("/.dockerenv") || existsSync("/run/.containerenv");
+}
+//# sourceMappingURL=service-status.js.map

package/dist/commands/daemon/service/systemd.d.ts

@@ -0,0 +1,22 @@
+import type { DaemonServiceSpec } from "./service-spec.js";
+/** Absolute path of the user unit for the label. */
+export declare function systemdUnitPath(label: string): string;
+/**
+ * Render the systemd user unit. Restart=on-failure, never always: `always` would
+ * resurrect the daemon after `byspace daemon stop`, breaking stop semantics. The
+ * supervisor's own crash restart handles worker failures. WantedBy=default.target
+ * is the user-level equivalent of "start at login".
+ */
+export declare function renderSystemdUnit(spec: DaemonServiceSpec): string;
+/** Write the unit, reload the manager, and enable --now the service. */
+export declare function installSystemdService(spec: DaemonServiceSpec): void;
+/** Stop, disable, and delete the unit. Idempotent. */
+export declare function uninstallSystemdService(label: string): void;
+/** MainPID from `systemctl --user show`, or null when the unit is not loaded. */
+export declare function systemdServicePid(label: string): number | null;
+/**
+ * Whether the user lingers (user manager runs without an active login session).
+ * Without lingering the service stops at logout — report it, never silently degrade.
+ */
+export declare function isLingerEnabled(user: string): boolean;
+//# sourceMappingURL=systemd.d.ts.map

package/dist/commands/daemon/service/systemd.js

@@ -0,0 +1,90 @@
+import { spawnSync } from "node:child_process";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { homedir } from "node:os";
+/** Absolute path of the user unit for the label. */
+export function systemdUnitPath(label) {
+    const configHome = process.env.XDG_CONFIG_HOME ?? path.join(homedir(), ".config");
+    return path.join(configHome, "systemd", "user", `${label}.service`);
+}
+/**
+ * Render the systemd user unit. Restart=on-failure, never always: `always` would
+ * resurrect the daemon after `byspace daemon stop`, breaking stop semantics. The
+ * supervisor's own crash restart handles worker failures. WantedBy=default.target
+ * is the user-level equivalent of "start at login".
+ */
+export function renderSystemdUnit(spec) {
+    const execStart = [spec.nodePath, spec.runnerEntry, ...spec.runnerArgs]
+        .map((part) => part.replace(/([\\"])/g, "\\$1"))
+        .join(" ");
+    const envLines = Object.entries(spec.env)
+        .map(([key, value]) => `Environment="${key}=${value.replace(/([\\"])/g, "\\$1")}"`)
+        .join("\n");
+    return `# Generated by 'byspace daemon install-service'. Edits are overwritten on reinstall.
+[Unit]
+Description=BySpace daemon
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=exec
+ExecStart=${execStart}
+${envLines}
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=default.target
+`;
+}
+function systemctl(args) {
+    const result = spawnSync("systemctl", ["--user", ...args], {
+        encoding: "utf8",
+        timeout: 20000,
+    });
+    const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+    return { ok: result.status === 0, output };
+}
+/** Write the unit, reload the manager, and enable --now the service. */
+export function installSystemdService(spec) {
+    const unitPath = systemdUnitPath(spec.label);
+    mkdirSync(path.dirname(unitPath), { recursive: true });
+    writeFileSync(unitPath, renderSystemdUnit(spec), { mode: 0o644 });
+    const daemonReload = systemctl(["daemon-reload"]);
+    if (!daemonReload.ok) {
+        throw new Error(`systemctl --user daemon-reload failed: ${daemonReload.output}`);
+    }
+    const enable = systemctl(["enable", "--now", `${spec.label}.service`]);
+    if (!enable.ok) {
+        throw new Error(`systemctl --user enable --now failed: ${enable.output}`);
+    }
+}
+/** Stop, disable, and delete the unit. Idempotent. */
+export function uninstallSystemdService(label) {
+    systemctl(["disable", "--now", `${label}.service`]);
+    rmSync(systemdUnitPath(label), { force: true });
+    systemctl(["daemon-reload"]);
+}
+/** MainPID from `systemctl --user show`, or null when the unit is not loaded. */
+export function systemdServicePid(label) {
+    const { ok, output } = systemctl(["show", `${label}.service`, "--property", "MainPID"]);
+    if (!ok)
+        return null;
+    const match = output.match(/^MainPID=(\d+)$/m);
+    if (!match)
+        return null;
+    const pid = Number(match[1]);
+    return pid > 0 ? pid : null;
+}
+/**
+ * Whether the user lingers (user manager runs without an active login session).
+ * Without lingering the service stops at logout — report it, never silently degrade.
+ */
+export function isLingerEnabled(user) {
+    const result = spawnSync("loginctl", ["show-user", user, "--property", "Linger"], {
+        encoding: "utf8",
+        timeout: 10000,
+    });
+    return result.status === 0 && /Linger=yes/.test(result.stdout ?? "");
+}
+//# sourceMappingURL=systemd.js.map

package/dist/commands/daemon/service/windows-task.d.ts

@@ -0,0 +1,12 @@
+import type { DaemonServiceSpec } from "./service-spec.js";
+/** The scheduled task name for the daemon (folder-qualified for the API surface). */
+export declare function scheduledTaskName(label: string): string;
+/** Build the Register-ScheduledTask argument vector. Exposed for tests. */
+export declare function buildRegisterArgs(spec: DaemonServiceSpec): string[];
+/** Register the scheduled task. Env vars are snapshotted into the task definition. */
+export declare function installWindowsTask(spec: DaemonServiceSpec): void;
+/** Unregister the task. Idempotent: succeeds when nothing is registered. */
+export declare function uninstallWindowsTask(label: string): void;
+/** The pid of the daemon process the task last launched, via task state. */
+export declare function windowsTaskPid(label: string): number | null;
+//# sourceMappingURL=windows-task.d.ts.map