@rynx-ai/cli 0.1.11-beta.40 → 0.1.11-beta.42

package/dist/commands/lifecycle.js

@@ -1,6 +1,6 @@
 import { startStandaloneDaemon, statusStandaloneDaemon, stopStandaloneDaemon, streamStandaloneDaemonLogs, } from "../standalone.js";
 import { refreshAutostart } from "../autostart.js";
-import { assertLinuxSystemdInvocation } from "../systemd-service.js";
+import { assertLinuxSystemdInvocation, stopLinuxServiceIfActive, } from "../systemd-service.js";
 import { fail } from "./errors.js";
 const SYSTEMD_SERVICE_FLAG = "--systemd-service";
 export async function runLifecycleCommand(command, args, options = {}) {
@@ -24,6 +24,8 @@ export async function runLifecycleCommand(command, args, options = {}) {
             return startStandaloneDaemon({ restart: true, quiet: options.quiet });
         }
         case "stop":
+            if (stopLinuxServiceIfActive())
+                return 0;
             return stopStandaloneDaemon();
         case "status":
             return statusStandaloneDaemon();

package/dist/systemd-service.d.ts

@@ -7,14 +7,13 @@ export interface LinuxSystemdServiceState {
     activeState: string;
     subState: string;
     type: string;
-    mainPid: number;
+    remainAfterExit: string;
     killMode: string;
     killSignal: string;
     restartKillSignal: string;
     finalKillSignal: string;
     sendSigkill: string;
     workingDirectory: string;
-    pidFile: string;
     environment: string;
     execStart: string;
     execStop: string;
@@ -24,10 +23,10 @@ export interface LinuxPm2GodProcess {
     cgroup: string;
     startIdentity: string;
 }
-export type LinuxPm2GodOwnership = {
+export type LinuxPm2GodInspection = {
     kind: "absent";
 } | {
-    kind: "owned";
+    kind: "service-cgroup";
     processes: LinuxPm2GodProcess[];
 } | {
     kind: "external";
@@ -47,7 +46,13 @@ export declare function disableLinuxAutostart(): void;
 /** Refresh an existing autostart unit without changing enablement. */
 export declare function refreshLinuxServiceIfPresent(): boolean;
 export declare function assertLinuxSystemdInvocation(): void;
+/**
+ * Stop through systemd while the oneshot unit owns the lifecycle state. PM2
+ * owns its own process tree; systemd only records whether its start hook has
+ * completed and provides the matching synchronous ExecStop boundary.
+ */
+export declare function stopLinuxServiceIfActive(): boolean;
 export declare function parseLinuxSystemdShow(output: string): LinuxSystemdServiceState;
-export declare function inspectLinuxPm2GodOwnership(home: string, deps?: LinuxPm2InspectionDeps): LinuxPm2GodOwnership;
+export declare function inspectLinuxPm2GodProcesses(home: string, deps?: LinuxPm2InspectionDeps): LinuxPm2GodInspection;
 export declare function scanLinuxPm2GodPids(home: string, deps?: LinuxPm2InspectionDeps): number[];
 export declare function linuxSystemdCgroupForPid(pid: number, readText?: (file: string) => string): string;

package/dist/systemd-service.js

@@ -8,6 +8,7 @@ export const RYNX_SYSTEMD_SERVICE = "rynx.service";
 export const RYNX_SYSTEMD_SERVICE_ENV = "RYNX_SYSTEMD_SERVICE";
 export const RYNX_SERVICE_ENV_KEYS = "RYNX_SERVICE_ENV_KEYS";
 const COMMAND_TIMEOUT_MS = 5_000;
+const STOP_COMMAND_TIMEOUT_MS = 50_000;
 const AUTOMATIC_SERVICE_ENVIRONMENT = new Set([
     "ALL_PROXY",
     "AWS_CA_BUNDLE",
@@ -76,7 +77,6 @@ const TRANSIENT_SERVICE_ENVIRONMENT = new Set([
     "TMUX_PANE",
 ]);
 export function renderSystemdUnit(input) {
-    const pidFile = path.join(input.dataDir, "pm2", "pm2.pid");
     const inheritedEnvironment = renderInheritedEnvironment(input.environment);
     return `[Unit]
 Description=Rynx local control plane
@@ -84,8 +84,8 @@ After=network-online.target
 Wants=network-online.target
 
 [Service]
-Type=forking
-PIDFile=${systemdPath(pidFile)}
+Type=oneshot
+RemainAfterExit=yes
 KillMode=process
 KillSignal=SIGCONT
 RestartKillSignal=SIGCONT
@@ -125,7 +125,7 @@ export function inspectLinuxAutostart() {
     let detail;
     if (active) {
         try {
-            assertRunningServiceOwnership(context);
+            assertActiveServiceLifecycle(context);
         }
         catch (error) {
             detail = errorMessage(error);
@@ -185,6 +185,62 @@ export function assertLinuxSystemdInvocation() {
         throw new Error(`--systemd-service requires the ${RYNX_SYSTEMD_SERVICE} cgroup`);
     }
 }
+/**
+ * Stop through systemd while the oneshot unit owns the lifecycle state. PM2
+ * owns its own process tree; systemd only records whether its start hook has
+ * completed and provides the matching synchronous ExecStop boundary.
+ */
+export function stopLinuxServiceIfActive() {
+    if (process.platform !== "linux")
+        return false;
+    const context = currentContext();
+    const inspection = inspectLinuxPm2GodProcesses(context.pm2Home);
+    assertSingleGod(inspection);
+    if (!linuxUserSystemdAvailable()) {
+        const unitMode = installedLinuxUnitMode(context);
+        if (unitMode === "legacy-or-unknown" ||
+            (unitMode === "absent" && (inspection.kind === "service-cgroup" ||
+                currentProcessHasLinuxServiceEvidence()))) {
+            throw new Error(`cannot safely stop a legacy or still-loaded ${RYNX_SYSTEMD_SERVICE} without user systemd; ` +
+                "retry from a login session where systemctl --user is available");
+        }
+        return false;
+    }
+    const state = inspectLinuxSystemdService();
+    if (linuxSystemdServiceIsSettledInactive(state))
+        return false;
+    stopLinuxSystemdServiceAndVerify(context);
+    return true;
+}
+function stopLinuxSystemdServiceAndVerify(context) {
+    requireSuccess(run("systemctl", ["--user", "stop", RYNX_SYSTEMD_SERVICE], STOP_COMMAND_TIMEOUT_MS), `systemctl --user stop ${RYNX_SYSTEMD_SERVICE}`);
+    const remaining = inspectLinuxPm2GodProcesses(context.pm2Home);
+    if (remaining.kind !== "absent") {
+        throw new Error(`${RYNX_SYSTEMD_SERVICE} stop completed but the PM2 supervisor is still running: ` +
+            describeInspection(remaining));
+    }
+}
+function linuxSystemdServiceIsSettledInactive(state) {
+    return state.activeState === "inactive" || state.activeState === "failed";
+}
+function installedLinuxUnitMode(context) {
+    if (!existsSync(context.unitPath))
+        return "absent";
+    const content = readFileSync(context.unitPath, "utf8");
+    const type = /^\s*Type\s*=\s*([^\s#]+)\s*$/mi.exec(content)?.[1]?.toLowerCase();
+    const remains = /^\s*RemainAfterExit\s*=\s*yes\s*$/mi.test(content);
+    return type === "oneshot" && remains ? "oneshot" : "legacy-or-unknown";
+}
+function currentProcessHasLinuxServiceEvidence() {
+    if (process.env[RYNX_SYSTEMD_SERVICE_ENV] === RYNX_SYSTEMD_SERVICE)
+        return true;
+    try {
+        return cgroupHasService(linuxSystemdCgroupForPid(process.pid));
+    }
+    catch {
+        return false;
+    }
+}
 export function parseLinuxSystemdShow(output) {
     const values = new Map();
     for (const line of output.split(/\r?\n/)) {
@@ -193,28 +249,24 @@ export function parseLinuxSystemdShow(output) {
             continue;
         values.set(line.slice(0, separator), line.slice(separator + 1));
     }
-    const parsedMainPid = Number.parseInt(values.get("MainPID") ?? "0", 10);
     return {
         loadState: values.get("LoadState") ?? "",
         activeState: values.get("ActiveState") ?? "",
         subState: values.get("SubState") ?? "",
         type: values.get("Type") ?? "",
-        mainPid: Number.isSafeInteger(parsedMainPid) && parsedMainPid > 1
-            ? parsedMainPid
-            : 0,
+        remainAfterExit: values.get("RemainAfterExit") ?? "",
         killMode: values.get("KillMode") ?? "",
         killSignal: values.get("KillSignal") ?? "",
         restartKillSignal: values.get("RestartKillSignal") ?? "",
         finalKillSignal: values.get("FinalKillSignal") ?? "",
         sendSigkill: values.get("SendSIGKILL") ?? "",
         workingDirectory: values.get("WorkingDirectory") ?? "",
-        pidFile: values.get("PIDFile") ?? "",
         environment: values.get("Environment") ?? "",
         execStart: values.get("ExecStart") ?? "",
         execStop: values.get("ExecStop") ?? "",
     };
 }
-export function inspectLinuxPm2GodOwnership(home, deps = {}) {
+export function inspectLinuxPm2GodProcesses(home, deps = {}) {
     const readText = deps.readText ?? ((file) => readFileSync(file, "utf8"));
     const entries = scanLinuxPm2GodPids(home, deps);
     const processes = [];
@@ -240,7 +292,7 @@ export function inspectLinuxPm2GodOwnership(home, deps = {}) {
         return { kind: "absent" };
     const external = processes.filter((entry) => !cgroupHasService(entry.cgroup));
     return external.length === 0
-        ? { kind: "owned", processes }
+        ? { kind: "service-cgroup", processes }
         : { kind: "external", processes };
 }
 export function scanLinuxPm2GodPids(home, deps = {}) {
@@ -302,7 +354,6 @@ function currentContext() {
         nodePath: process.execPath,
         pathEnv: process.env.PATH || defaultLinuxPath(),
         pm2Home,
-        pidFile: path.join(pm2Home, "pm2.pid"),
         unitPath: path.join(homeDir, ".config", "systemd", "user", RYNX_SYSTEMD_SERVICE),
     };
 }
@@ -343,14 +394,13 @@ function inspectLinuxSystemdService() {
         "--property=ActiveState",
         "--property=SubState",
         "--property=Type",
-        "--property=MainPID",
+        "--property=RemainAfterExit",
         "--property=KillMode",
         "--property=KillSignal",
         "--property=RestartKillSignal",
         "--property=FinalKillSignal",
         "--property=SendSIGKILL",
         "--property=WorkingDirectory",
-        "--property=PIDFile",
         "--property=Environment",
         "--property=ExecStart",
         "--property=ExecStop",
@@ -361,10 +411,11 @@ function assertStaticServiceDefinition(context, state) {
     const errors = [];
     if (state.loadState !== "loaded")
         errors.push(`LoadState=${state.loadState || "(empty)"}`);
-    if (state.type !== "forking")
+    if (state.type !== "oneshot")
         errors.push(`Type=${state.type || "(empty)"}`);
-    if (state.pidFile !== context.pidFile)
-        errors.push(`PIDFile=${state.pidFile || "(empty)"}`);
+    if (state.remainAfterExit !== "yes") {
+        errors.push(`RemainAfterExit=${state.remainAfterExit || "(empty)"}`);
+    }
     if (state.workingDirectory !== context.dataDir) {
         errors.push(`WorkingDirectory=${state.workingDirectory || "(empty)"}`);
     }
@@ -404,35 +455,31 @@ function assertStaticServiceDefinition(context, state) {
         throw new Error(`${RYNX_SYSTEMD_SERVICE} effective configuration is invalid: ${errors.join("; ")}`);
     }
 }
-function assertRunningServiceOwnership(context) {
-    const ownership = inspectLinuxPm2GodOwnership(context.pm2Home);
-    assertSingleGod(ownership);
-    if (ownership.kind !== "owned") {
-        throw new Error(ownership.kind === "absent"
-            ? "systemd started without a PM2 supervisor"
-            : `PM2 supervisor is outside ${RYNX_SYSTEMD_SERVICE}: ${describeOwnership(ownership)}`);
+function assertActiveServiceLifecycle(context) {
+    const inspection = inspectLinuxPm2GodProcesses(context.pm2Home);
+    assertSingleGod(inspection);
+    if (inspection.kind === "absent") {
+        throw new Error("systemd started without a PM2 supervisor");
     }
-    const process = ownership.processes[0];
+    const process = inspection.processes[0];
     const state = inspectLinuxSystemdService();
     assertStaticServiceDefinition(context, state);
     if (state.activeState !== "active" ||
-        state.subState !== "running" ||
-        state.mainPid !== process.pid) {
-        throw new Error(`${RYNX_SYSTEMD_SERVICE} does not own the PM2 supervisor: ` +
-            `ActiveState=${state.activeState}, SubState=${state.subState}, ` +
-            `MainPID=${state.mainPid}, PM2=${process.pid}`);
+        state.subState !== "exited") {
+        throw new Error(`${RYNX_SYSTEMD_SERVICE} lifecycle is not active: ` +
+            `ActiveState=${state.activeState}, SubState=${state.subState}`);
     }
     return process;
 }
-function assertSingleGod(ownership) {
-    if (ownership.kind !== "absent" && ownership.processes.length !== 1) {
-        throw new Error(`multiple PM2 supervisors use this RYNX_HOME: ${describeOwnership(ownership)}`);
+function assertSingleGod(inspection) {
+    if (inspection.kind !== "absent" && inspection.processes.length !== 1) {
+        throw new Error(`multiple PM2 supervisors use this RYNX_HOME: ${describeInspection(inspection)}`);
     }
 }
-function describeOwnership(ownership) {
-    if (ownership.kind === "absent")
+function describeInspection(inspection) {
+    if (inspection.kind === "absent")
         return "absent";
-    return ownership.processes
+    return inspection.processes
         .map((entry) => `${entry.pid}@${entry.cgroup}`)
         .join(", ");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/cli",
-  "version": "0.1.11-beta.40",
+  "version": "0.1.11-beta.42",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -51,12 +51,12 @@
   "dependencies": {
     "@clack/prompts": "^1.6.0",
     "ws": "^8.21.0",
-    "@rynx-ai/browser-cdp": "0.1.11-beta.40",
-    "@rynx-ai/core": "0.1.11-beta.40",
-    "@rynx-ai/emulator": "0.1.11-beta.40",
-    "@rynx-ai/protocol": "0.1.11-beta.40",
-    "@rynx-ai/tmux": "0.1.11-beta.40",
-    "@rynx-ai/daemon": "0.1.11-beta.40"
+    "@rynx-ai/daemon": "0.1.11-beta.42",
+    "@rynx-ai/emulator": "0.1.11-beta.42",
+    "@rynx-ai/core": "0.1.11-beta.42",
+    "@rynx-ai/browser-cdp": "0.1.11-beta.42",
+    "@rynx-ai/protocol": "0.1.11-beta.42",
+    "@rynx-ai/tmux": "0.1.11-beta.42"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"