@bytetrue/byspace 0.14.5 → 0.15.0

package/node_modules/@bytetrue/server/dist/server/server/session/daemon/daemon-service-manager.js

@@ -0,0 +1,154 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { BYSPACE_CLI_PACKAGE } from "./npm-global-cli.js";
+import path from "node:path";
+import { validateDaemonInstallOrigin, daemonInstallOriginRuntime } from "./install-origin.js";
+/**
+ * Daemon-side OS service management (issue 043). The daemon manages its own service
+ * registration because install requires the daemon's install-origin context — the
+ * npm-global verification and the runner entry resolution live in this process.
+ *
+ * KeepAlive/Restart is deliberately not "always": `byspace daemon stop` must stay a
+ * real stop. The supervisor's own crash-restart handles worker failures.
+ */
+export const DAEMON_SERVICE_LABEL = "cc.cd.byspace.daemon";
+function launchdProbe(home) {
+    const plistPath = path.join(home, "Library", "LaunchAgents", `${DAEMON_SERVICE_LABEL}.plist`);
+    return {
+        definitionExists: () => existsSync(plistPath),
+        servicePid: () => {
+            try {
+                const uid = process.getuid?.();
+                if (uid === undefined)
+                    return null;
+                const output = execFileSync("launchctl", ["print", `gui/${uid}/${DAEMON_SERVICE_LABEL}`], {
+                    encoding: "utf8",
+                    timeout: 10000,
+                });
+                const match = output.match(/^\s*pid\s*=\s*(\d+)/m);
+                return match ? Number(match[1]) : null;
+            }
+            catch {
+                return null;
+            }
+        },
+        viewFlags: () => ({}),
+    };
+}
+function systemdProbe() {
+    const configHome = process.env.XDG_CONFIG_HOME ?? path.join(process.env.HOME ?? "", ".config");
+    const unitPath = path.join(configHome, "systemd", "user", `${DAEMON_SERVICE_LABEL}.service`);
+    return {
+        definitionExists: () => existsSync(unitPath),
+        servicePid: () => {
+            try {
+                const output = execFileSync("systemctl", ["--user", "show", `${DAEMON_SERVICE_LABEL}.service`, "--property", "MainPID"], { encoding: "utf8", timeout: 10000 });
+                const match = output.match(/^MainPID=(\d+)$/m);
+                const pid = match ? Number(match[1]) : 0;
+                return pid > 0 ? pid : null;
+            }
+            catch {
+                return null;
+            }
+        },
+        viewFlags: () => {
+            try {
+                const output = execFileSync("loginctl", ["show-user", process.env.USER ?? "", "--property", "Linger"], { encoding: "utf8", timeout: 10000 });
+                return { linger: /Linger=yes/.test(output) };
+            }
+            catch {
+                return {};
+            }
+        },
+    };
+}
+function windowsProbe() {
+    return {
+        definitionExists: () => {
+            try {
+                const output = execFileSync("powershell.exe", [
+                    "-NoProfile",
+                    "-NonInteractive",
+                    "-Command",
+                    `(Get-ScheduledTask -TaskPath '\\BySpace\\' -TaskName '${DAEMON_SERVICE_LABEL}' -ErrorAction SilentlyContinue) -ne $null`,
+                ], { encoding: "utf8", timeout: 15000 });
+                return output.trim() === "True";
+            }
+            catch {
+                return false;
+            }
+        },
+        servicePid: () => null,
+        viewFlags: () => ({}),
+    };
+}
+function probeForPlatform() {
+    switch (process.platform) {
+        case "darwin":
+            return launchdProbe(resolveBySpaceHomeForService());
+        case "linux":
+            return systemdProbe();
+        case "win32":
+            return windowsProbe();
+        default:
+            return null;
+    }
+}
+function resolveBySpaceHomeForService() {
+    return process.env.BYSPACE_HOME ?? path.join(process.env.HOME ?? "", ".byspace");
+}
+/** Guard: only a daemon from the published npm global install may self-register. */
+export function validateServiceOriginSync() {
+    if (existsSync("/.dockerenv") || existsSync("/run/.containerenv")) {
+        return "Registering a service is not supported inside Docker. Use the container runtime's restart policy instead.";
+    }
+    // The npm -g listing is the authoritative origin: it proves the published install
+    // exists on this host. validateDaemonInstallOrigin then checks that THIS daemon
+    // process actually runs from it — a dev checkout parses fine but fails the
+    // package-root containment check, which is exactly the guard that matters here.
+    try {
+        const npmPrefix = execFileSync("npm", ["prefix", "-g"], {
+            encoding: "utf8",
+            timeout: 15000,
+        }).trim();
+        const packagePath = path.join(npmPrefix, "lib", "node_modules", "@bytetrue", "byspace");
+        const pkgJsonPath = path.join(packagePath, "package.json");
+        if (!existsSync(pkgJsonPath)) {
+            return `${BYSPACE_CLI_PACKAGE} is not installed with npm -g on this host`;
+        }
+        const version = JSON.parse(readFileSync(pkgJsonPath, "utf8")).version ?? "";
+        const install = {
+            version,
+            packagePath,
+            globalRootPath: npmPrefix,
+            isLinked: false,
+        };
+        return validateDaemonInstallOrigin(install, process.env.npm_package_version ?? version, daemonInstallOriginRuntime);
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+/** Query the current service view. Never caches: each call re-probes the manager. */
+export function queryDaemonServiceView() {
+    const probe = probeForPlatform();
+    if (!probe) {
+        return { state: "unknown", label: DAEMON_SERVICE_LABEL };
+    }
+    if (!probe.definitionExists()) {
+        return { state: "not-installed", label: DAEMON_SERVICE_LABEL, ...probe.viewFlags() };
+    }
+    const servicePid = probe.servicePid();
+    if (servicePid === null) {
+        return { state: "installed-stopped", label: DAEMON_SERVICE_LABEL, ...probe.viewFlags() };
+    }
+    if (servicePid === process.pid) {
+        return { state: "managed-by-service", label: DAEMON_SERVICE_LABEL, ...probe.viewFlags() };
+    }
+    return {
+        state: "installed-running-not-this-process",
+        label: DAEMON_SERVICE_LABEL,
+        ...probe.viewFlags(),
+    };
+}
+//# sourceMappingURL=daemon-service-manager.js.map

package/node_modules/@bytetrue/server/dist/server/server/websocket-server.js

@@ -1170,6 +1170,8 @@ export class DaemonWebSocketServer {
                 agentConfigApply: true,
                 // COMPAT(daemonNetworkConfig): added in v0.14.3, remove gate after 2027-07-14.
                 daemonNetworkConfig: true,
+                // COMPAT(daemonServiceInstall): added in v0.14.7, remove gate after 2027-09-20.
+                daemonServiceInstall: true,
             },
         };
     }