@rynx-ai/cli 0.1.11-beta.49 → 0.1.11-beta.50

package/dist/autostart-environment.d.ts

@@ -0,0 +1,5 @@
+import type { AutostartRenderInput } from "./autostart.js";
+export declare function renderAutostartEnvironmentFile(input: AutostartRenderInput): string;
+export declare function serviceEnvironmentPath(input: AutostartRenderInput): string;
+export declare function currentShell(): string;
+export declare function autostartLauncherArguments(input: AutostartRenderInput, serviceFlag: string): string[];

package/dist/autostart-environment.js

@@ -0,0 +1,64 @@
+import { readlinkSync } from "node:fs";
+import { userInfo } from "node:os";
+import path from "node:path";
+// These describe a particular service invocation or IPC connection. The new
+// service/Node process supplies its own values; all other variables are captured.
+const BLOCKED_SERVICE_ENVIRONMENT = new Set([
+    "INVOCATION_ID",
+    "JOURNAL_STREAM",
+    "LISTEN_FDS",
+    "LISTEN_FDNAMES",
+    "LISTEN_PID",
+    "MAINPID",
+    "MANAGERPID",
+    "NOTIFY_SOCKET",
+    "ELECTRON_RUN_AS_NODE",
+    "NODE_CHANNEL_FD",
+    "NODE_UNIQUE_ID",
+    "PM2_HOME",
+    "RYNX_DAEMON_LIFECYCLE",
+    "RYNX_HOME",
+    "RYNX_REFRESH_LOGIN_SHELL_PATH",
+    "RYNX_SYSTEMD_SERVICE",
+    "RYNX_LAUNCHD_SERVICE",
+    "XPC_SERVICE_NAME",
+    "SYSTEMD_EXEC_PID",
+    "SYSTEMD_INVOCATION_ID",
+    "WATCHDOG_PID",
+    "WATCHDOG_USEC",
+]);
+export function renderAutostartEnvironmentFile(input) {
+    const env = { ...input.environment, PATH: input.pathEnv };
+    return Object.entries(env)
+        .filter(([name, value]) => value !== undefined &&
+        /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) &&
+        !BLOCKED_SERVICE_ENVIRONMENT.has(name))
+        .sort(([left], [right]) => left.localeCompare(right))
+        // Preserve literal newlines and quote metacharacters. The launcher parses
+        // this as data; it must not execute the assignments in a shell.
+        .map(([name, value]) => `${name}="${value.replace(/[\\"$`]/g, "\\$&")}"`)
+        .join("\n") + "\n";
+}
+export function serviceEnvironmentPath(input) {
+    return path.join(input.dataDir, "autostart.env");
+}
+export function currentShell() {
+    try {
+        const parent = readlinkSync(`/proc/${process.ppid}/exe`);
+        if (/^(?:ba|z|fi|da|k|mk|c|tc)?sh$/.test(path.basename(parent)))
+            return parent;
+    }
+    catch {
+        // The caller may be a launcher, or /proc may be unavailable.
+    }
+    return process.env.SHELL || userInfo().shell || "/bin/sh";
+}
+export function autostartLauncherArguments(input, serviceFlag) {
+    return [
+        path.join(path.dirname(input.cliPath), "autostart-launcher.js"),
+        input.shellPath ?? "/bin/sh",
+        input.cliPath,
+        input.dataDir,
+        serviceFlag,
+    ];
+}

package/dist/autostart-launcher.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/autostart-launcher.js

@@ -0,0 +1,48 @@
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+// Keep this entry independent of CLI initialization: restore the environment
+// and initialize the user's shell before loading any Rynx runtime code.
+const [shellPath, cliPath, dataDir, serviceFlag] = process.argv.slice(2);
+if (!shellPath || !cliPath || !dataDir ||
+    (serviceFlag !== "--systemd-service" && serviceFlag !== "--launchd-service")) {
+    throw new Error("invalid autostart launcher arguments");
+}
+const contents = readFileSync(path.join(dataDir, "autostart.env"), "utf8");
+// Parse only the quoted format emitted by renderAutostartEnvironmentFile.
+// Never source assignments: a saved SHELLOPTS/UID may be readonly in a shell.
+const assignments = [...contents.matchAll(/([A-Za-z_][A-Za-z0-9_]*)="((?:\\[\\"$`]|[^"\\])*)"\n/g)];
+if (assignments.map(([assignment]) => assignment).join("") !== contents) {
+    throw new Error("invalid autostart environment snapshot");
+}
+const snapshot = Object.fromEntries(assignments.map(([, name = "", value = ""]) => [
+    name,
+    value.replace(/\\([\\"$`])/g, "$1"),
+]));
+const isCShell = /^(?:t?csh)$/.test(path.basename(shellPath));
+const command = "exec " + [
+    "/usr/bin/env",
+    `RYNX_HOME=${dataDir}`,
+    serviceFlag === "--systemd-service"
+        ? "RYNX_SYSTEMD_SERVICE=rynx.service"
+        : "RYNX_LAUNCHD_SERVICE=ai.rynx.daemon",
+    process.execPath,
+    cliPath,
+    "start",
+    serviceFlag,
+].map((value) => {
+    const quoted = `'${value.replaceAll("'", "'\\''")}'`;
+    return isCShell ? quoted.replaceAll("!", "\\!").replaceAll("\n", "\\\n") : quoted;
+}).join(" ");
+// csh/tcsh require -l on its own. Reading the command from stdin preserves
+// their login AND interactive startup, including configuration guarded by prompt.
+const result = spawnSync(shellPath, isCShell ? ["-l"] : ["-lic", command], {
+    env: { ...process.env, ...snapshot },
+    stdio: [isCShell ? "pipe" : "inherit", "inherit", "inherit"],
+    ...(isCShell ? { input: `${command}\n` } : {}),
+});
+// The shell passes its final environment directly to Rynx. Do not merge the
+// snapshot again: that would undo configuration overrides and unset operations.
+if (result.error)
+    throw result.error;
+process.exitCode = result.status ?? 1;

package/dist/autostart.d.ts

@@ -17,11 +17,13 @@ export interface AutostartRenderInput {
     logDir: string;
     nodePath: string;
     pathEnv: string;
+    shellPath?: string;
 }
 export declare function autostartPlatformLabel(platform?: NodeJS.Platform): string | undefined;
 export declare function inspectAutostart(): AutostartState;
 export declare function enableAutostart(): AutostartState;
 export declare function disableAutostart(): AutostartState;
-/** Refresh paths in an existing registration without enabling a new one. */
+/** Refresh an existing registration and its environment without enabling a new one. */
 export declare function refreshAutostart(): boolean;
 export declare function renderLaunchAgent(input: AutostartRenderInput): string;
+export declare function assertMacLaunchdInvocation(): void;

package/dist/autostart.js

@@ -4,9 +4,11 @@ import { homedir, userInfo } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { rynxHome } from "@rynx-ai/core";
+import { autostartLauncherArguments, currentShell, renderAutostartEnvironmentFile, serviceEnvironmentPath, } from "./autostart-environment.js";
 import { disableLinuxAutostart, enableLinuxAutostart, inspectLinuxAutostart, refreshLinuxServiceIfPresent, } from "./systemd-service.js";
 export { renderSystemdUnit } from "./systemd-service.js";
 const LAUNCHD_LABEL = "ai.rynx.daemon";
+const LAUNCHD_SERVICE_ENV = "RYNX_LAUNCHD_SERVICE";
 const COMMAND_TIMEOUT_MS = 5_000;
 export function autostartPlatformLabel(platform = process.platform) {
     if (platform === "darwin")
@@ -44,7 +46,7 @@ export function disableAutostart() {
         disableLinuxAutostart();
     return inspectAutostart();
 }
-/** Refresh paths in an existing registration without enabling a new one. */
+/** Refresh an existing registration and its environment without enabling a new one. */
 export function refreshAutostart() {
     if (process.platform === "darwin") {
         const context = currentContext();
@@ -68,6 +70,7 @@ function unsupportedState() {
 export function renderLaunchAgent(input) {
     const outLog = path.join(input.logDir, "autostart-out.log");
     const errLog = path.join(input.logDir, "autostart-err.log");
+    const argv = [input.nodePath, ...autostartLauncherArguments(input, "--launchd-service")];
     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">
@@ -76,9 +79,7 @@ export function renderLaunchAgent(input) {
   <string>${escapeXml(LAUNCHD_LABEL)}</string>
   <key>ProgramArguments</key>
   <array>
-    <string>${escapeXml(input.nodePath)}</string>
-    <string>${escapeXml(input.cliPath)}</string>
-    <string>start</string>
+${argv.map((value) => `    <string>${escapeXml(value)}</string>`).join("\n")}
   </array>
   <key>RunAtLoad</key>
   <true/>
@@ -92,6 +93,8 @@ export function renderLaunchAgent(input) {
     <string>${escapeXml(input.pathEnv)}</string>
     <key>RYNX_HOME</key>
     <string>${escapeXml(input.dataDir)}</string>
+    <key>${LAUNCHD_SERVICE_ENV}</key>
+    <string>${LAUNCHD_LABEL}</string>
   </dict>
   <key>StandardOutPath</key>
   <string>${escapeXml(outLog)}</string>
@@ -101,6 +104,14 @@ export function renderLaunchAgent(input) {
 </plist>
 `;
 }
+export function assertMacLaunchdInvocation() {
+    if (process.platform !== "darwin") {
+        throw new Error("--launchd-service is only valid on macOS");
+    }
+    if (process.env[LAUNCHD_SERVICE_ENV] !== LAUNCHD_LABEL) {
+        throw new Error("--launchd-service requires the Rynx launchd environment");
+    }
+}
 function currentContext() {
     const dataDir = rynxHome();
     const homeDir = homedir();
@@ -109,8 +120,10 @@ function currentContext() {
         dataDir,
         logDir: path.join(dataDir, "logs"),
         cliPath: fileURLToPath(new URL("./cli.js", import.meta.url)),
+        environment: process.env,
         nodePath: process.execPath,
         pathEnv: process.env.PATH || defaultPath(),
+        shellPath: currentShell(),
     };
 }
 function defaultPath() {
@@ -142,19 +155,42 @@ function syncMacRegistration(context) {
         ? readFileSync(registrationPath, "utf8")
         : undefined;
     const content = renderLaunchAgent(context);
-    if (previous === content)
+    const changed = previous !== content;
+    const environmentPath = serviceEnvironmentPath(context);
+    const environment = renderAutostartEnvironmentFile(context);
+    const previousEnvironment = existsSync(environmentPath)
+        ? readFileSync(environmentPath, "utf8")
+        : undefined;
+    const environmentChanged = previousEnvironment !== environment;
+    if (!changed && !environmentChanged)
         return false;
-    const wasLoaded = launchctlLoaded();
-    replaceFileAtomically(registrationPath, content);
+    const wasLoaded = changed && launchctlLoaded();
+    const restore = () => {
+        if (environmentChanged)
+            restoreRegistrationFile(environmentPath, previousEnvironment, 0o600);
+        if (changed)
+            restoreRegistrationFile(registrationPath, previous);
+    };
+    try {
+        if (environmentChanged)
+            replaceFileAtomically(environmentPath, environment, 0o600);
+        if (changed)
+            replaceFileAtomically(registrationPath, content);
+    }
+    catch (error) {
+        restore();
+        throw error;
+    }
+    // An environment-only refresh needs no reload: the job reads it on every run.
     if (!wasLoaded)
         return true;
     if (!launchctlBootout(registrationPath)) {
-        restoreRegistrationFile(registrationPath, previous);
+        restore();
         throw new Error(`launchctl could not unload ${LAUNCHD_LABEL}; the previous file was restored`);
     }
     if (launchctlBootstrap(registrationPath))
         return true;
-    restoreRegistrationFile(registrationPath, previous);
+    restore();
     if (previous !== undefined && launchctlBootstrap(registrationPath)) {
         throw new Error(`launchctl could not load the updated registration; the previous job was restored`);
     }
@@ -166,6 +202,7 @@ function disableMac(context) {
         throw new Error(`launchctl could not unload ${LAUNCHD_LABEL}`);
     }
     rmSync(registrationPath, { force: true });
+    rmSync(serviceEnvironmentPath(context), { force: true });
 }
 function launchctlLoaded() {
     const uid = userInfo().uid;
@@ -206,14 +243,14 @@ function escapeXml(value) {
         .replaceAll("<", "&lt;")
         .replaceAll(">", "&gt;");
 }
-function replaceFileAtomically(file, content) {
+function replaceFileAtomically(file, content, mode = 0o644) {
     mkdirSync(path.dirname(file), { recursive: true });
     const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
     try {
         writeFileSync(temporary, content, {
             encoding: "utf8",
             flag: "wx",
-            mode: 0o644,
+            mode,
         });
         renameSync(temporary, file);
     }
@@ -221,9 +258,9 @@ function replaceFileAtomically(file, content) {
         rmSync(temporary, { force: true });
     }
 }
-function restoreRegistrationFile(file, previous) {
+function restoreRegistrationFile(file, previous, mode = 0o644) {
     if (previous === undefined)
         rmSync(file, { force: true });
     else
-        replaceFileAtomically(file, previous);
+        replaceFileAtomically(file, previous, mode);
 }

package/dist/commands/lifecycle.js

@@ -1,11 +1,12 @@
 import { startStandaloneDaemon, statusStandaloneDaemon, stopStandaloneDaemon, streamStandaloneDaemonLogs, } from "../standalone.js";
 import { shutdownResidentDaemonIfIdle, waitForResidentDaemonExit, } from "../control-client.js";
 import { resolveDaemonControlEndpoint } from "../control-endpoint.js";
-import { refreshAutostart } from "../autostart.js";
+import { assertMacLaunchdInvocation, refreshAutostart } from "../autostart.js";
 import { assertLinuxSystemdInvocation } from "../systemd-service.js";
 import { clearLegacyMaintenanceState } from "../legacy-maintenance.js";
 import { fail } from "./errors.js";
 const SYSTEMD_SERVICE_FLAG = "--systemd-service";
+const LAUNCHD_SERVICE_FLAG = "--launchd-service";
 const IF_IDLE_FLAG = "--if-idle";
 export async function runLifecycleCommand(command, args, options = {}) {
     if (args.length === 1 && args[0] === SYSTEMD_SERVICE_FLAG) {
@@ -16,6 +17,12 @@ export async function runLifecycleCommand(command, args, options = {}) {
             return stopStandaloneDaemon();
         fail(`${SYSTEMD_SERVICE_FLAG} is only valid for start and stop`);
     }
+    if (args.length === 1 && args[0] === LAUNCHD_SERVICE_FLAG) {
+        assertMacLaunchdInvocation();
+        if (command === "start")
+            return startStandaloneDaemon();
+        fail(`${LAUNCHD_SERVICE_FLAG} is only valid for start`);
+    }
     const stopIfIdle = command === "stop" && args.length === 1 && args[0] === IF_IDLE_FLAG;
     const statusJson = command === "status" && args.length === 1 && args[0] === "--json";
     if (args.length > 0 && !stopIfIdle && !statusJson) {

package/dist/systemd-service.d.ts

@@ -1,7 +1,8 @@
 import type { AutostartRenderInput, AutostartState } from "./autostart.js";
+import { renderAutostartEnvironmentFile as renderSystemdEnvironmentFile } from "./autostart-environment.js";
+export { renderSystemdEnvironmentFile };
 export declare const RYNX_SYSTEMD_SERVICE = "rynx.service";
 export declare const RYNX_SYSTEMD_SERVICE_ENV = "RYNX_SYSTEMD_SERVICE";
-export declare const RYNX_SERVICE_ENV_KEYS = "RYNX_SERVICE_ENV_KEYS";
 export interface LinuxSystemdServiceState {
     loadState: string;
     activeState: string;

package/dist/systemd-service.js

@@ -4,79 +4,13 @@ import { homedir, userInfo } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { rynxHome } from "@rynx-ai/core";
+import { autostartLauncherArguments, currentShell, renderAutostartEnvironmentFile as renderSystemdEnvironmentFile, serviceEnvironmentPath, } from "./autostart-environment.js";
+export { renderSystemdEnvironmentFile };
 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 AUTOMATIC_SERVICE_ENVIRONMENT = new Set([
-    "ALL_PROXY",
-    "AWS_CA_BUNDLE",
-    "CURL_CA_BUNDLE",
-    "GIT_SSL_CAINFO",
-    "HTTPS_PROXY",
-    "HTTP_PROXY",
-    "NODE_EXTRA_CA_CERTS",
-    "NO_PROXY",
-    "REQUESTS_CA_BUNDLE",
-    "SSL_CERT_DIR",
-    "SSL_CERT_FILE",
-    "all_proxy",
-    "https_proxy",
-    "http_proxy",
-    "no_proxy",
-]);
-const BLOCKED_SERVICE_ENVIRONMENT = new Set([
-    "PATH",
-    "INVOCATION_ID",
-    "JOURNAL_STREAM",
-    "LISTEN_FDS",
-    "LISTEN_FDNAMES",
-    "LISTEN_PID",
-    "MAINPID",
-    "MANAGERPID",
-    "NOTIFY_SOCKET",
-    "ELECTRON_RUN_AS_NODE",
-    "NODE_CHANNEL_FD",
-    "NODE_UNIQUE_ID",
-    "PM2_HOME",
-    "RYNX_DAEMON_LIFECYCLE",
-    "RYNX_HOME",
-    "RYNX_REFRESH_LOGIN_SHELL_PATH",
-    RYNX_SERVICE_ENV_KEYS,
-    RYNX_SYSTEMD_SERVICE_ENV,
-    "SYSTEMD_EXEC_PID",
-    "SYSTEMD_INVOCATION_ID",
-    "WATCHDOG_PID",
-    "WATCHDOG_USEC",
-]);
-const TRANSIENT_SERVICE_ENVIRONMENT = new Set([
-    "_",
-    "CI",
-    "CLICOLOR",
-    "CLICOLOR_FORCE",
-    "CODEX_CI",
-    "COLORTERM",
-    "FORCE_COLOR",
-    "GH_PAGER",
-    "GIT_PAGER",
-    "NO_COLOR",
-    "OLDPWD",
-    "PAGER",
-    "PWD",
-    "SHLVL",
-    "SSH_CLIENT",
-    "SSH_CONNECTION",
-    "SSH_TTY",
-    "TERM",
-    "TERM_PROGRAM",
-    "TERM_PROGRAM_VERSION",
-    "TERM_SESSION_ID",
-    "TERMINFO",
-    "TMUX",
-    "TMUX_PANE",
-]);
 export function renderSystemdUnit(input) {
-    const inheritedEnvironment = renderInheritedEnvironment(input.environment);
+    const argv = [input.nodePath, ...autostartLauncherArguments(input, "--systemd-service")];
     return `[Unit]
 Description=Rynx local control plane
 After=network-online.target
@@ -93,12 +27,11 @@ SendSIGKILL=no
 TimeoutStartSec=60
 TimeoutStopSec=45
 WorkingDirectory=${systemdPath(input.dataDir)}
-${inheritedEnvironment}
 Environment=${systemdQuote(`PATH=${input.pathEnv}`)}
 Environment=${systemdQuote(`RYNX_HOME=${input.dataDir}`)}
 Environment=${systemdQuote(`${RYNX_SYSTEMD_SERVICE_ENV}=${RYNX_SYSTEMD_SERVICE}`)}
-ExecStart=${systemdQuote(input.nodePath)} ${systemdQuote(input.cliPath)} start --systemd-service
-ExecStop=${systemdQuote(input.nodePath)} ${systemdQuote(input.cliPath)} stop --systemd-service
+ExecStart=:${argv.map(systemdQuote).join(" ")}
+ExecStop=:${systemdQuote(input.nodePath)} ${systemdQuote(input.cliPath)} stop --systemd-service
 
 [Install]
 WantedBy=default.target
@@ -161,16 +94,17 @@ export function disableLinuxAutostart() {
         requireSuccess(disabled, "systemctl --user disable");
     }
     rmSync(context.unitPath, { force: true });
+    rmSync(serviceEnvironmentPath(context), { force: true });
     requireSuccess(run("systemctl", ["--user", "daemon-reload"]), "systemctl --user daemon-reload");
 }
 /** Refresh an existing autostart unit without changing enablement. */
 export function refreshLinuxServiceIfPresent() {
-    if (process.platform !== "linux" || !linuxUserSystemdAvailable())
+    if (process.platform !== "linux")
         return false;
     const context = currentContext();
     if (!existsSync(context.unitPath))
         return false;
-    return syncLinuxService(context);
+    return syncLinuxService(context, linuxUserSystemdAvailable());
 }
 export function assertLinuxSystemdInvocation() {
     if (process.platform !== "linux") {
@@ -296,11 +230,12 @@ function currentContext() {
         environment: process.env,
         nodePath: process.execPath,
         pathEnv: process.env.PATH || defaultLinuxPath(),
+        shellPath: currentShell(),
         pm2Home,
         unitPath: path.join(homeDir, ".config", "systemd", "user", RYNX_SYSTEMD_SERVICE),
     };
 }
-function syncLinuxService(context) {
+function syncLinuxService(context, reload = true) {
     mkdirSync(context.dataDir, { recursive: true, mode: 0o700 });
     mkdirSync(context.logDir, { recursive: true, mode: 0o700 });
     const content = renderSystemdUnit(context);
@@ -308,14 +243,30 @@ function syncLinuxService(context) {
         ? readFileSync(context.unitPath, "utf8")
         : undefined;
     const changed = previous !== content;
-    if (changed)
-        replaceFileAtomically(context.unitPath, content);
+    const environmentPath = serviceEnvironmentPath(context);
+    const environment = renderSystemdEnvironmentFile(context);
+    const previousEnvironment = existsSync(environmentPath)
+        ? readFileSync(environmentPath, "utf8")
+        : undefined;
+    const environmentChanged = previousEnvironment !== environment;
     try {
+        if (environmentChanged)
+            replaceFileAtomically(environmentPath, environment);
+        if (changed)
+            replaceFileAtomically(context.unitPath, content);
+        if (!reload)
+            return changed || environmentChanged;
         requireSuccess(run("systemctl", ["--user", "daemon-reload"]), "systemctl --user daemon-reload");
         assertStaticServiceDefinition(context, inspectLinuxSystemdService());
-        return changed;
+        return changed || environmentChanged;
     }
     catch (error) {
+        if (environmentChanged) {
+            if (previousEnvironment === undefined)
+                rmSync(environmentPath, { force: true });
+            else
+                replaceFileAtomically(environmentPath, previousEnvironment);
+        }
         if (changed) {
             if (previous === undefined)
                 rmSync(context.unitPath, { force: true });
@@ -389,6 +340,7 @@ function assertStaticServiceDefinition(context, state) {
     ]) {
         if (!value.includes(context.nodePath) ||
             !value.includes(context.cliPath) ||
+            (action === "start" && !value.includes(autostartLauncherArguments(context, "--systemd-service")[0])) ||
             !value.includes(action) ||
             !value.includes("--systemd-service")) {
             errors.push(`${name}=${value || "(empty)"}`);
@@ -501,8 +453,7 @@ function replaceFileAtomically(file, content) {
         writeFileSync(temporary, content, {
             encoding: "utf8",
             flag: "wx",
-            // The generated unit contains the caller's environment and may include
-            // runtime credentials. Keep the snapshot private to the owning user.
+            // Environment snapshots may include runtime credentials.
             mode: 0o600,
         });
         renameSync(temporary, file);
@@ -539,24 +490,6 @@ function signalMatches(value, number, name) {
 function defaultLinuxPath() {
     return "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
 }
-function renderInheritedEnvironment(env) {
-    if (!env)
-        return "";
-    const requested = new Set((env[RYNX_SERVICE_ENV_KEYS] ?? "")
-        .split(/[\s,]+/)
-        .filter((name) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(name)));
-    return Object.entries(env)
-        .filter(([name, value]) => value !== undefined &&
-        /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) &&
-        (AUTOMATIC_SERVICE_ENVIRONMENT.has(name) || requested.has(name)) &&
-        !name.startsWith("npm_") &&
-        !name.startsWith("RYNX_RUNNER_") &&
-        !BLOCKED_SERVICE_ENVIRONMENT.has(name) &&
-        !TRANSIENT_SERVICE_ENVIRONMENT.has(name))
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([name, value]) => `Environment=${systemdQuote(`${name}=${value}`)}`)
-        .join("\n");
-}
 function systemdQuote(value) {
     return `"${value
         .replaceAll("\\", "\\\\")
@@ -567,13 +500,10 @@ function systemdQuote(value) {
         .replaceAll("\r", "\\r")}"`;
 }
 function systemdPath(value) {
-    return value
-        .replaceAll("%", "%%")
-        .replaceAll("\\", "\\x5c")
-        .replaceAll(" ", "\\x20")
-        .replaceAll("\t", "\\t")
-        .replaceAll("\n", "\\n")
-        .replaceAll("\r", "\\r")
-        .replaceAll('"', "\\x22")
-        .replaceAll("'", "\\x27");
+    // These scalar path directives expand specifiers, but do not unquote words
+    // or decode the C-style escapes accepted by ExecStart/Environment.
+    if (/[\r\n]/.test(value)) {
+        throw new Error("systemd autostart paths cannot contain line breaks");
+    }
+    return value.replaceAll("%", "%%");
 }

package/package.json

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