@push.rocks/smartdaemon 2.21.0 → 3.0.0

package/dist_ts/smartdaemon.classes.systemdmanager.js

@@ -1,6 +1,7 @@
 import * as plugins from './smartdaemon.plugins.js';
 import * as paths from './smartdaemon.paths.js';
 import { SmartDaemon } from './smartdaemon.classes.smartdaemon.js';
+import { SmartDaemonCommandError } from './smartdaemon.classes.commanderror.js';
 import { SmartDaemonService, } from './smartdaemon.classes.service.js';
 export class SmartDaemonSystemdManager {
     // STATIC
@@ -16,6 +17,7 @@ export class SmartDaemonSystemdManager {
     }
     constructor(smartdaemonRefArg, sudoPasswordArg) {
         this.shouldExecute = false;
+        /** Whether this process runs as root; set by the first privileged operation's check. */
         this.isRoot = false;
         this.smartdaemonRef = smartdaemonRefArg;
         this.smartshellInstance = new plugins.smartshell.Smartshell({
@@ -23,18 +25,27 @@ export class SmartDaemonSystemdManager {
         });
         this.smartFs = new plugins.smartfs.SmartFs(new plugins.smartfs.SmartFsProviderNode());
         this.sudoPassword = sudoPasswordArg;
-        // Check if we're running as root
-        this.checkIsRoot().then(isRoot => {
-            this.isRoot = isRoot;
-            if (!isRoot) {
-                console.log('Not running as root. Sudo will be used for privileged operations.');
-            }
-        });
     }
     async checkIsRoot() {
         const result = await this.smartshellInstance.exec('id -u');
         return result.stdout.trim() === '0';
     }
+    /** Checks once whether this process runs as root and sets `isRoot`; later calls reuse that check. */
+    ensureRootStatus() {
+        if (!this.rootStatus) {
+            this.rootStatus = this.checkIsRoot().then((isRoot) => {
+                this.isRoot = isRoot;
+                if (!isRoot) {
+                    console.log('Not running as root. Sudo will be used for privileged operations.');
+                }
+            });
+            // A failed check is not memoized, so the next privileged operation asks again.
+            this.rootStatus.catch(() => {
+                this.rootStatus = undefined;
+            });
+        }
+        return this.rootStatus;
+    }
     async checkElegibility() {
         if (plugins.os.platform() === 'linux') {
             this.shouldExecute = true;
@@ -45,30 +56,50 @@ export class SmartDaemonSystemdManager {
         }
         return this.shouldExecute;
     }
+    /**
+     * Runs a command, through sudo when this process is not root and the command does not start with
+     * `sudo` already. With a `sudoPassword`, sudo reads it from standard input (`sudo -k -S -p ''`):
+     * it never reaches argv, the environment or a terminal. Rejects with `SmartDaemonCommandError`
+     * when the command does not exit 0.
+     */
     async execute(commandArg) {
-        if (await this.checkElegibility()) {
-            // Only use sudo if we're not root and command doesn't already have sudo
-            if (!this.isRoot && !commandArg.startsWith('sudo')) {
-                commandArg = `sudo ${commandArg}`;
-                if (this.sudoPassword) {
-                    // Use interactive PTY mode for password input
-                    const interactiveExec = await this.smartshellInstance.execInteractiveControlPty(commandArg);
-                    await interactiveExec.sendLine(this.sudoPassword);
-                    const result = await interactiveExec.finalPromise;
-                    return result;
-                }
-            }
-            // Execute command (with or without sudo)
-            try {
-                await this.smartshellInstance.exec(commandArg);
-            }
-            catch (error) {
-                if (!this.isRoot && error instanceof Error && error.message.includes('authentication')) {
-                    throw new Error('Sudo authentication failed. Please configure passwordless sudo or provide a sudo password.');
-                }
-                throw error;
-            }
+        if (!(await this.checkElegibility())) {
+            return undefined;
+        }
+        await this.ensureRootStatus();
+        if (this.isRoot || commandArg.startsWith('sudo')) {
+            return await this.runChecked(commandArg);
+        }
+        if (!this.sudoPassword) {
+            return await this.runChecked(`sudo ${commandArg}`);
+        }
+        // -k ignores cached credentials, so sudo reads the password line whenever its policy asks for
+        // one; ending stdin right after it makes a rejected password fail instead of waiting for a retry.
+        const sudoCommand = `sudo -k -S -p '' -- ${commandArg}`;
+        const interactiveExec = await this.smartshellInstance.execInteractiveControl(sudoCommand);
+        let writeError;
+        try {
+            await interactiveExec.sendLine(this.sudoPassword);
+        }
+        catch (error) {
+            // sudo can exit before reading stdin (EPIPE); its exit status below decides the outcome.
+            writeError = error;
+        }
+        interactiveExec.endInput();
+        const result = await interactiveExec.finalPromise;
+        this.assertSucceeded(sudoCommand, result, writeError);
+        return result;
+    }
+    async runChecked(commandArg) {
+        const result = await this.smartshellInstance.exec(commandArg);
+        this.assertSucceeded(commandArg, result);
+        return result;
+    }
+    assertSucceeded(commandArg, resultArg, causeArg) {
+        if (resultArg.exitCode === 0 && !resultArg.signal) {
+            return;
         }
+        throw new SmartDaemonCommandError(commandArg, resultArg.exitCode, resultArg.signal, resultArg.stderr, causeArg === undefined ? undefined : { cause: causeArg });
     }
     /**
      * gets all services that are already present
@@ -101,6 +132,7 @@ export class SmartDaemonSystemdManager {
         if (await this.checkElegibility()) {
             const content = this.smartdaemonRef.templateManager.generateUnitFileForService(serviceArg);
             const targetPath = SmartDaemonSystemdManager.createFilePathFromServiceName(serviceArg.name);
+            await this.ensureRootStatus();
             if (this.isRoot) {
                 // Direct write when running as root
                 await this.smartFs.file(targetPath).encoding('utf8').mode(0o644).write(content);
@@ -117,6 +149,7 @@ export class SmartDaemonSystemdManager {
     async deleteService(serviceArg) {
         if (await this.checkElegibility()) {
             const filePath = SmartDaemonSystemdManager.createFilePathFromServiceName(serviceArg.name);
+            await this.ensureRootStatus();
             if (this.isRoot) {
                 await this.smartFs.file(filePath).delete();
             }
@@ -145,4 +178,4 @@ export class SmartDaemonSystemdManager {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartdaemon.classes.systemdmanager.js","sourceRoot":"","sources":["../ts/smartdaemon.classes.systemdmanager.ts"],"names":[],"mappings":"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"}

package/dist_ts/smartdaemon.paths.js

@@ -1,4 +1,4 @@
 import * as plugins from './smartdaemon.plugins.js';
 export const packageDir = plugins.path.join(plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url), '../');
 export const systemdDir = plugins.path.join('/lib/systemd/system/');
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRkYWVtb24ucGF0aHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydGRhZW1vbi5wYXRocy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLDBCQUEwQixDQUFDO0FBRXBELE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FDekMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsd0JBQXdCLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsRUFDL0QsS0FBSyxDQUNOLENBQUM7QUFDRixNQUFNLENBQUMsTUFBTSxVQUFVLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsc0JBQXNCLENBQUMsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRkYWVtb24ucGF0aHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydGRhZW1vbi5wYXRocy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLDBCQUEwQixDQUFDO0FBRXBELE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FDekMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsd0JBQXdCLENBQUMsT0FBTyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQy9ELEtBQUssQ0FDTixDQUFDO0FBQ0YsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLHNCQUFzQixDQUFDLENBQUMifQ==

package/dist_ts/smartdaemon.plugins.d.ts

@@ -9,9 +9,7 @@ export type { Stats } from 'node:fs';
 export { path, childProcess, fs, fsConstants, crypto, util, os };
 import * as lik from '@push.rocks/lik';
 import * as smartfs from '@push.rocks/smartfs';
-import * as smartlog from '@push.rocks/smartlog';
-import * as smartlogDestinationLocal from '@push.rocks/smartlog/destination-local';
 import * as smartmarkdown from '@push.rocks/smartmarkdown/iso';
 import * as smartpath from '@push.rocks/smartpath';
 import * as smartshell from '@push.rocks/smartshell';
-export { lik, smartfs, smartlog, smartlogDestinationLocal, smartmarkdown, smartpath, smartshell, };
+export { lik, smartfs, smartmarkdown, smartpath, smartshell, };

package/dist_ts/smartdaemon.plugins.js

@@ -10,11 +10,9 @@ export { path, childProcess, fs, fsConstants, crypto, util, os };
 // @pushrocks scope
 import * as lik from '@push.rocks/lik';
 import * as smartfs from '@push.rocks/smartfs';
-import * as smartlog from '@push.rocks/smartlog';
-import * as smartlogDestinationLocal from '@push.rocks/smartlog/destination-local';
 import * as smartmarkdown from '@push.rocks/smartmarkdown/iso';
 import * as smartpath from '@push.rocks/smartpath';
 import * as smartshell from '@push.rocks/smartshell';
-export { lik, smartfs, smartlog, smartlogDestinationLocal, smartmarkdown, smartpath, smartshell, };
+export { lik, smartfs, smartmarkdown, smartpath, smartshell, };
 // third party
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRkYWVtb24ucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0ZGFlbW9uLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sS0FBSyxZQUFZLE1BQU0sb0JBQW9CLENBQUM7QUFDbkQsT0FBTyxLQUFLLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUN2QyxPQUFPLEVBQUUsU0FBUyxJQUFJLFdBQVcsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUNuRCxPQUFPLEtBQUssTUFBTSxNQUFNLGFBQWEsQ0FBQztBQUN0QyxPQUFPLEtBQUssSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUNsQyxPQUFPLEtBQUssRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUc5QixPQUFPLEVBQUUsSUFBSSxFQUFFLFlBQVksRUFBRSxFQUFFLEVBQUUsV0FBVyxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFLENBQUM7QUFFakUsbUJBQW1CO0FBQ25CLE9BQU8sS0FBSyxHQUFHLE1BQU0saUJBQWlCLENBQUM7QUFDdkMsT0FBTyxLQUFLLE9BQU8sTUFBTSxxQkFBcUIsQ0FBQztBQUMvQyxPQUFPLEtBQUssUUFBUSxNQUFNLHNCQUFzQixDQUFDO0FBQ2pELE9BQU8sS0FBSyx3QkFBd0IsTUFBTSx3Q0FBd0MsQ0FBQztBQUNuRixPQUFPLEtBQUssYUFBYSxNQUFNLCtCQUErQixDQUFDO0FBQy9ELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFDbkQsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUVyRCxPQUFPLEVBQ0wsR0FBRyxFQUNILE9BQU8sRUFDUCxRQUFRLEVBQ1Isd0JBQXdCLEVBQ3hCLGFBQWEsRUFDYixTQUFTLEVBQ1QsVUFBVSxHQUNYLENBQUM7QUFFRixjQUFjIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRkYWVtb24ucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0ZGFlbW9uLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sS0FBSyxZQUFZLE1BQU0sb0JBQW9CLENBQUM7QUFDbkQsT0FBTyxLQUFLLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUN2QyxPQUFPLEVBQUUsU0FBUyxJQUFJLFdBQVcsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUNuRCxPQUFPLEtBQUssTUFBTSxNQUFNLGFBQWEsQ0FBQztBQUN0QyxPQUFPLEtBQUssSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUNsQyxPQUFPLEtBQUssRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUc5QixPQUFPLEVBQUUsSUFBSSxFQUFFLFlBQVksRUFBRSxFQUFFLEVBQUUsV0FBVyxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFLENBQUM7QUFFakUsbUJBQW1CO0FBQ25CLE9BQU8sS0FBSyxHQUFHLE1BQU0saUJBQWlCLENBQUM7QUFDdkMsT0FBTyxLQUFLLE9BQU8sTUFBTSxxQkFBcUIsQ0FBQztBQUMvQyxPQUFPLEtBQUssYUFBYSxNQUFNLCtCQUErQixDQUFDO0FBQy9ELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFDbkQsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUVyRCxPQUFPLEVBQ0wsR0FBRyxFQUNILE9BQU8sRUFDUCxhQUFhLEVBQ2IsU0FBUyxFQUNULFVBQVUsR0FDWCxDQUFDO0FBRUYsY0FBYyJ9

package/dist_ts/systemd.definition.d.ts

@@ -58,10 +58,10 @@ export interface ISystemdServiceCredential {
     source?: string;
 }
 /** Linux capabilities systemd 255 knows by name, for `capabilityBoundingSet` and `ambientCapabilities`. */
-export declare const systemdCapabilities: readonly ["CAP_AUDIT_CONTROL", "CAP_AUDIT_READ", "CAP_AUDIT_WRITE", "CAP_BLOCK_SUSPEND", "CAP_BPF", "CAP_CHECKPOINT_RESTORE", "CAP_CHOWN", "CAP_DAC_OVERRIDE", "CAP_DAC_READ_SEARCH", "CAP_FOWNER", "CAP_FSETID", "CAP_IPC_LOCK", "CAP_IPC_OWNER", "CAP_KILL", "CAP_LEASE", "CAP_LINUX_IMMUTABLE", "CAP_MAC_ADMIN", "CAP_MAC_OVERRIDE", "CAP_MKNOD", "CAP_NET_ADMIN", "CAP_NET_BIND_SERVICE", "CAP_NET_BROADCAST", "CAP_NET_RAW", "CAP_PERFMON", "CAP_SETFCAP", "CAP_SETGID", "CAP_SETPCAP", "CAP_SETUID", "CAP_SYSLOG", "CAP_SYS_ADMIN", "CAP_SYS_BOOT", "CAP_SYS_CHROOT", "CAP_SYS_MODULE", "CAP_SYS_NICE", "CAP_SYS_PACCT", "CAP_SYS_PTRACE", "CAP_SYS_RAWIO", "CAP_SYS_RESOURCE", "CAP_SYS_TIME", "CAP_SYS_TTY_CONFIG", "CAP_WAKE_ALARM"];
+export declare const systemdCapabilities: readonly ['CAP_AUDIT_CONTROL', 'CAP_AUDIT_READ', 'CAP_AUDIT_WRITE', 'CAP_BLOCK_SUSPEND', 'CAP_BPF', 'CAP_CHECKPOINT_RESTORE', 'CAP_CHOWN', 'CAP_DAC_OVERRIDE', 'CAP_DAC_READ_SEARCH', 'CAP_FOWNER', 'CAP_FSETID', 'CAP_IPC_LOCK', 'CAP_IPC_OWNER', 'CAP_KILL', 'CAP_LEASE', 'CAP_LINUX_IMMUTABLE', 'CAP_MAC_ADMIN', 'CAP_MAC_OVERRIDE', 'CAP_MKNOD', 'CAP_NET_ADMIN', 'CAP_NET_BIND_SERVICE', 'CAP_NET_BROADCAST', 'CAP_NET_RAW', 'CAP_PERFMON', 'CAP_SETFCAP', 'CAP_SETGID', 'CAP_SETPCAP', 'CAP_SETUID', 'CAP_SYSLOG', 'CAP_SYS_ADMIN', 'CAP_SYS_BOOT', 'CAP_SYS_CHROOT', 'CAP_SYS_MODULE', 'CAP_SYS_NICE', 'CAP_SYS_PACCT', 'CAP_SYS_PTRACE', 'CAP_SYS_RAWIO', 'CAP_SYS_RESOURCE', 'CAP_SYS_TIME', 'CAP_SYS_TTY_CONFIG', 'CAP_WAKE_ALARM'];
 export type TSystemdCapability = typeof systemdCapabilities[number];
 /** Socket address families a definition may allow with `restrictAddressFamilies`. */
-export declare const systemdAddressFamilies: readonly ["AF_INET", "AF_INET6", "AF_NETLINK", "AF_PACKET", "AF_UNIX", "AF_VSOCK"];
+export declare const systemdAddressFamilies: readonly ['AF_INET', 'AF_INET6', 'AF_NETLINK', 'AF_PACKET', 'AF_UNIX', 'AF_VSOCK'];
 export type TSystemdAddressFamily = typeof systemdAddressFamilies[number];
 /**
  * Internal bounds of a definition's `environment`: variables, and UTF-8 bytes of `NAME=value` in
@@ -82,7 +82,7 @@ export declare const renderServiceRelations: (options: {
     startup?: TSystemdServiceStartup;
     dependencies?: ISystemdServiceDependencies;
     install?: ISystemdServiceInstallTargets;
-}, unitName: string, restart: string, scope: "system" | "user", fail: (option: "startup" | "dependencies" | "install") => never) => {
+}, unitName: string, restart: string, scope: 'system' | 'user', fail: (option: 'startup' | 'dependencies' | 'install') => never) => {
     unit: string[];
     service: string[];
     install: string[];

package/dist_ts/systemd.userenvironment.d.ts

@@ -36,4 +36,4 @@ export declare const isUserManagerEnvironment: (environment: ISystemdUserEnviron
  * the path must be its own real path and a directory owned by that uid without group or other
  * permissions. `absent` is a directory that does not exist; every other refusal is `unsafe`.
  */
-export declare const inspectRuntimeDirectory: (runtimeDirectory: string) => Promise<"private" | "absent" | "unsafe">;
+export declare const inspectRuntimeDirectory: (runtimeDirectory: string) => Promise<'private' | 'absent' | 'unsafe'>;

package/dist_ts_systemdruntime/classes.systemdnotifier.d.ts

@@ -0,0 +1,82 @@
+/** `NOTIFY_BUFFER_MAX` (`PIPE_BUF`): systemd ignores a longer notification message. */
+export declare const notifyMessageMaximumBytes = 4096;
+export interface ISystemdEnvironmentOptions {
+    /** The environment to read; `process.env` by default. */
+    readonly env?: NodeJS.ProcessEnv;
+}
+export interface ISystemdNotifierEnvironmentOptions extends ISystemdEnvironmentOptions {
+    /** Remove `NOTIFY_SOCKET` from the environment, so no child inherits it. Default `false`. */
+    readonly take?: boolean;
+}
+export interface ISystemdStoreDescriptorsOptions {
+    /**
+     * Whether the manager watches the stored descriptors and drops one that reports `POLLHUP` or
+     * `POLLERR` (`FDPOLL=`). Default `true`, as in systemd; `false` sends `FDPOLL=0`, for descriptors
+     * that are not pollable or always report hang-up, such as namespace descriptors.
+     */
+    readonly poll?: boolean;
+}
+/**
+ * Takes `NOTIFY_SOCKET` out of the environment: the validated address, or null when it is unset or
+ * empty. An address that is set but invalid is removed as well and then refused
+ * (`notify_socket_invalid`).
+ */
+export declare const takeSystemdNotifySocket: (optionsArg?: ISystemdEnvironmentOptions) => string | null;
+/**
+ * Sends `sd_notify(3)` messages to a service manager's notification socket: one `AF_UNIX`
+ * `SOCK_DGRAM` datagram per message, descriptors attached as `SCM_RIGHTS`. Every call is synchronous
+ * and either delivers the whole message to the socket or throws a `SystemdRuntimeError`; whether
+ * the manager acts on it depends on the unit's `NotifyAccess=`. Fields and descriptor names are
+ * validated before sending, because systemd ignores a message it cannot parse without telling the
+ * sender.
+ */
+export declare class SystemdNotifier {
+    /**
+     * The notifier for the unit that started this process, or null when `NOTIFY_SOCKET` is unset or
+     * empty — the process was not started by a service manager that listens. The caller decides what
+     * that means; nothing is sent silently nowhere. An invalid `NOTIFY_SOCKET` throws
+     * `notify_socket_invalid`.
+     */
+    static fromEnvironment(optionsArg?: ISystemdNotifierEnvironmentOptions): SystemdNotifier | null;
+    /** The notification socket: an absolute path, or an abstract name written `@name`. */
+    readonly socketAddress: string;
+    constructor(socketAddressArg: string);
+    /** `READY=1`, with an optional `STATUS=`. */
+    ready(statusArg?: string): void;
+    /** `STATUS=`: free-form text the manager shows as the unit's status. */
+    status(textArg: string): void;
+    /** `STOPPING=1`, with an optional `STATUS=`. */
+    stopping(statusArg?: string): void;
+    /**
+     * `RELOADING=1` with `MONOTONIC_USEC=` (`CLOCK_MONOTONIC` now), with an optional `STATUS=`. The
+     * service sends `ready()` once the reload finished.
+     */
+    reloading(statusArg?: string): void;
+    /** `WATCHDOG=1`: keeps a `WatchdogSec=` unit alive. */
+    watchdog(): void;
+    /**
+     * `EXTEND_TIMEOUT_USEC=`: asks the manager to wait `microsecondsArg` longer for the current start,
+     * runtime-start, stop or watchdog deadline, with an optional `STATUS=`.
+     */
+    extendTimeout(microsecondsArg: number, statusArg?: string): void;
+    /**
+     * `FDSTORE=1` with `FDNAME=`: the manager keeps duplicates of `descriptorsArg` (1–253) under
+     * `nameArg` in the unit's descriptor store (`FileDescriptorStoreMax=`) and passes them to the
+     * next main process through `LISTEN_FDS`. Storing does not replace descriptors already stored
+     * under the name; `replaceDescriptors()` does.
+     */
+    storeDescriptors(nameArg: string, descriptorsArg: readonly number[], optionsArg?: ISystemdStoreDescriptorsOptions): void;
+    /** `FDSTOREREMOVE=1` with `FDNAME=`: the manager closes every descriptor stored under `nameArg`. */
+    removeDescriptors(nameArg: string): void;
+    /**
+     * Removes the descriptors stored under `nameArg`, then stores `descriptorsArg` under it: two
+     * messages, handled by the manager in order. Between them the store holds nothing under the name.
+     */
+    replaceDescriptors(nameArg: string, descriptorsArg: readonly number[], optionsArg?: ISystemdStoreDescriptorsOptions): void;
+    /**
+     * Sends one message: `NAME=value` fields in insertion order, joined by newlines, and up to 253
+     * descriptors. Names are upper-case (`A–Z`, digits, `_`); values carry no newline or NUL; the
+     * message is at most 4096 bytes.
+     */
+    send(fieldsArg: Readonly<Record<string, string>>, descriptorsArg?: readonly number[]): void;
+}

package/dist_ts_systemdruntime/classes.systemdnotifier.js

@@ -0,0 +1,217 @@
+import { SystemdRuntimeError } from './classes.systemdruntimeerror.js';
+import { controlSpace, descriptorsPerMessageMaximum, libcConstants, socketAddressLength, systemdLibc, writeSocketAddress, } from './systemdruntime.libc.js';
+import { assertSystemdDescriptor, assertSystemdNotifySocketAddress, isSystemdDescriptorName, } from './systemdruntime.validation.js';
+/** `NOTIFY_BUFFER_MAX` (`PIPE_BUF`): systemd ignores a longer notification message. */
+export const notifyMessageMaximumBytes = 4096;
+/**
+ * Takes `NOTIFY_SOCKET` out of the environment: the validated address, or null when it is unset or
+ * empty. An address that is set but invalid is removed as well and then refused
+ * (`notify_socket_invalid`).
+ */
+export const takeSystemdNotifySocket = (optionsArg = {}) => {
+    const env = optionsArg.env ?? process.env;
+    const address = env.NOTIFY_SOCKET;
+    delete env.NOTIFY_SOCKET;
+    if (address === undefined || address === '')
+        return null;
+    assertSystemdNotifySocketAddress(address);
+    return address;
+};
+const fieldNamePattern = /^[A-Z][A-Z0-9_]*$/;
+/**
+ * Sends `sd_notify(3)` messages to a service manager's notification socket: one `AF_UNIX`
+ * `SOCK_DGRAM` datagram per message, descriptors attached as `SCM_RIGHTS`. Every call is synchronous
+ * and either delivers the whole message to the socket or throws a `SystemdRuntimeError`; whether
+ * the manager acts on it depends on the unit's `NotifyAccess=`. Fields and descriptor names are
+ * validated before sending, because systemd ignores a message it cannot parse without telling the
+ * sender.
+ */
+export class SystemdNotifier {
+    /**
+     * The notifier for the unit that started this process, or null when `NOTIFY_SOCKET` is unset or
+     * empty — the process was not started by a service manager that listens. The caller decides what
+     * that means; nothing is sent silently nowhere. An invalid `NOTIFY_SOCKET` throws
+     * `notify_socket_invalid`.
+     */
+    static fromEnvironment(optionsArg = {}) {
+        const env = optionsArg.env ?? process.env;
+        const address = optionsArg.take === true ? takeSystemdNotifySocket({ env }) : env.NOTIFY_SOCKET;
+        if (address === undefined || address === null || address === '')
+            return null;
+        return new SystemdNotifier(address);
+    }
+    constructor(socketAddressArg) {
+        assertSystemdNotifySocketAddress(socketAddressArg);
+        this.socketAddress = socketAddressArg;
+    }
+    /** `READY=1`, with an optional `STATUS=`. */
+    ready(statusArg) {
+        this.send({ READY: '1', ...(statusArg === undefined ? {} : { STATUS: statusArg }) });
+    }
+    /** `STATUS=`: free-form text the manager shows as the unit's status. */
+    status(textArg) {
+        this.send({ STATUS: textArg });
+    }
+    /** `STOPPING=1`, with an optional `STATUS=`. */
+    stopping(statusArg) {
+        this.send({ STOPPING: '1', ...(statusArg === undefined ? {} : { STATUS: statusArg }) });
+    }
+    /**
+     * `RELOADING=1` with `MONOTONIC_USEC=` (`CLOCK_MONOTONIC` now), with an optional `STATUS=`. The
+     * service sends `ready()` once the reload finished.
+     */
+    reloading(statusArg) {
+        this.send({
+            RELOADING: '1',
+            MONOTONIC_USEC: String(monotonicMicroseconds()),
+            ...(statusArg === undefined ? {} : { STATUS: statusArg }),
+        });
+    }
+    /** `WATCHDOG=1`: keeps a `WatchdogSec=` unit alive. */
+    watchdog() {
+        this.send({ WATCHDOG: '1' });
+    }
+    /**
+     * `EXTEND_TIMEOUT_USEC=`: asks the manager to wait `microsecondsArg` longer for the current start,
+     * runtime-start, stop or watchdog deadline, with an optional `STATUS=`.
+     */
+    extendTimeout(microsecondsArg, statusArg) {
+        if (!Number.isSafeInteger(microsecondsArg) || microsecondsArg <= 0) {
+            throw new SystemdRuntimeError('notify_field_invalid', 'EXTEND_TIMEOUT_USEC must be a positive integer.');
+        }
+        this.send({
+            EXTEND_TIMEOUT_USEC: String(microsecondsArg),
+            ...(statusArg === undefined ? {} : { STATUS: statusArg }),
+        });
+    }
+    /**
+     * `FDSTORE=1` with `FDNAME=`: the manager keeps duplicates of `descriptorsArg` (1–253) under
+     * `nameArg` in the unit's descriptor store (`FileDescriptorStoreMax=`) and passes them to the
+     * next main process through `LISTEN_FDS`. Storing does not replace descriptors already stored
+     * under the name; `replaceDescriptors()` does.
+     */
+    storeDescriptors(nameArg, descriptorsArg, optionsArg = {}) {
+        assertDescriptorName(nameArg);
+        assertStoredDescriptors(descriptorsArg);
+        this.send({ FDSTORE: '1', FDNAME: nameArg, ...(optionsArg.poll === false ? { FDPOLL: '0' } : {}) }, descriptorsArg);
+    }
+    /** `FDSTOREREMOVE=1` with `FDNAME=`: the manager closes every descriptor stored under `nameArg`. */
+    removeDescriptors(nameArg) {
+        assertDescriptorName(nameArg);
+        this.send({ FDSTOREREMOVE: '1', FDNAME: nameArg });
+    }
+    /**
+     * Removes the descriptors stored under `nameArg`, then stores `descriptorsArg` under it: two
+     * messages, handled by the manager in order. Between them the store holds nothing under the name.
+     */
+    replaceDescriptors(nameArg, descriptorsArg, optionsArg = {}) {
+        assertDescriptorName(nameArg);
+        assertStoredDescriptors(descriptorsArg);
+        this.removeDescriptors(nameArg);
+        this.storeDescriptors(nameArg, descriptorsArg, optionsArg);
+    }
+    /**
+     * Sends one message: `NAME=value` fields in insertion order, joined by newlines, and up to 253
+     * descriptors. Names are upper-case (`A–Z`, digits, `_`); values carry no newline or NUL; the
+     * message is at most 4096 bytes.
+     */
+    send(fieldsArg, descriptorsArg = []) {
+        const entries = Object.entries(fieldsArg);
+        if (entries.length === 0) {
+            throw new SystemdRuntimeError('notify_field_invalid', 'A notification needs at least one field.');
+        }
+        for (const [name, value] of entries) {
+            if (!fieldNamePattern.test(name)) {
+                throw new SystemdRuntimeError('notify_field_invalid', `${JSON.stringify(name)} is not a notification field name.`);
+            }
+            if (typeof value !== 'string' || /[\n\0]/.test(value)) {
+                throw new SystemdRuntimeError('notify_field_invalid', `The ${name} value must be a string without newline or NUL.`);
+            }
+        }
+        assertDescriptorList(descriptorsArg);
+        const payload = Buffer.from(entries.map(([name, value]) => `${name}=${value}`).join('\n'), 'utf8');
+        if (payload.length > notifyMessageMaximumBytes) {
+            throw new SystemdRuntimeError('notify_field_invalid', `The message is ${payload.length} bytes; systemd reads at most ${notifyMessageMaximumBytes}.`);
+        }
+        sendDatagram(this.socketAddress, payload, descriptorsArg);
+    }
+}
+const assertDescriptorName = (nameArg) => {
+    if (!isSystemdDescriptorName(nameArg, true)) {
+        throw new SystemdRuntimeError('descriptor_name_invalid', 'A descriptor name is 1–255 printable ASCII characters without ":".');
+    }
+};
+/** At most 253 valid descriptor numbers. */
+const assertDescriptorList = (descriptorsArg) => {
+    if (descriptorsArg.length > descriptorsPerMessageMaximum) {
+        throw new SystemdRuntimeError('descriptor_invalid', `One message carries at most ${descriptorsPerMessageMaximum} descriptors.`);
+    }
+    descriptorsArg.forEach(assertSystemdDescriptor);
+};
+/** 1–253 valid descriptor numbers, as `FDSTORE=1` needs. */
+const assertStoredDescriptors = (descriptorsArg) => {
+    if (descriptorsArg.length === 0) {
+        throw new SystemdRuntimeError('descriptor_invalid', 'FDSTORE=1 needs at least one descriptor.');
+    }
+    assertDescriptorList(descriptorsArg);
+};
+/** `CLOCK_MONOTONIC` in microseconds, as `MONOTONIC_USEC=` expects. */
+const monotonicMicroseconds = () => {
+    const libc = systemdLibc();
+    const timespec = Buffer.alloc(16);
+    if (libc.functions.clock_gettime(libcConstants.CLOCK_MONOTONIC, timespec) !== 0) {
+        throw new SystemdRuntimeError('notify_failed', 'clock_gettime(CLOCK_MONOTONIC) failed.', { errno: libc.errno() });
+    }
+    return timespec.readBigInt64LE(0) * 1000000n + timespec.readBigInt64LE(8) / 1000n;
+};
+// One block holds the whole message, so every pointer inside it stays valid while the block is
+// borrowed by the call: msghdr, iovec, sockaddr_un, control data, payload.
+const iovecOffset = 56;
+const addressOffset = 72;
+const controlOffset = 184;
+const sendDatagram = (addressArg, payloadArg, descriptorsArg) => {
+    const libc = systemdLibc();
+    const space = descriptorsArg.length === 0 ? 0 : controlSpace(descriptorsArg.length);
+    const payloadOffset = controlOffset + space;
+    const block = Buffer.alloc(payloadOffset + payloadArg.length);
+    const base = libc.ffi.getRawPointer(block);
+    writeSocketAddress(block, addressOffset, addressArg);
+    payloadArg.copy(block, payloadOffset);
+    block.writeBigUInt64LE(base + BigInt(addressOffset), 0);
+    block.writeUInt32LE(socketAddressLength(addressArg), 8);
+    block.writeBigUInt64LE(base + BigInt(iovecOffset), 16);
+    block.writeBigUInt64LE(1n, 24);
+    block.writeBigUInt64LE(base + BigInt(payloadOffset), iovecOffset);
+    block.writeBigUInt64LE(BigInt(payloadArg.length), iovecOffset + 8);
+    if (space > 0) {
+        block.writeBigUInt64LE(base + BigInt(controlOffset), 32);
+        block.writeBigUInt64LE(BigInt(space), 40);
+        block.writeBigUInt64LE(BigInt(16 + 4 * descriptorsArg.length), controlOffset);
+        block.writeInt32LE(libcConstants.SOL_SOCKET, controlOffset + 8);
+        block.writeInt32LE(libcConstants.SCM_RIGHTS, controlOffset + 12);
+        descriptorsArg.forEach((descriptor, index) => block.writeInt32LE(descriptor, controlOffset + 16 + 4 * index));
+    }
+    const socket = libc.functions.socket(libcConstants.AF_UNIX, libcConstants.SOCK_DGRAM | libcConstants.SOCK_CLOEXEC, 0);
+    if (socket < 0) {
+        throw new SystemdRuntimeError('notify_failed', 'socket(AF_UNIX, SOCK_DGRAM) failed.', { errno: libc.errno() });
+    }
+    try {
+        let sent = libc.functions.sendmsg(socket, block, libcConstants.MSG_NOSIGNAL);
+        let errno = sent < 0n ? libc.errno() : 0;
+        while (sent < 0n && errno === libcConstants.EINTR) {
+            sent = libc.functions.sendmsg(socket, block, libcConstants.MSG_NOSIGNAL);
+            errno = sent < 0n ? libc.errno() : 0;
+        }
+        if (sent < 0n) {
+            throw new SystemdRuntimeError('notify_failed', `sendmsg to ${addressArg} failed.`, { errno });
+        }
+        if (sent !== BigInt(payloadArg.length)) {
+            throw new SystemdRuntimeError('notify_failed', `sendmsg to ${addressArg} sent ${sent} of ${payloadArg.length} bytes.`);
+        }
+    }
+    finally {
+        // Linux releases the descriptor whatever close(2) reports; the socket is this call's alone.
+        libc.functions.close(socket);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.systemdnotifier.js","sourceRoot":"","sources":["../ts_systemdruntime/classes.systemdnotifier.ts"],"names":[],"mappings":"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"}

package/dist_ts_systemdruntime/classes.systemdruntimeerror.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Why a systemd runtime operation refused or failed:
+ *
+ * - `runtime_unsupported`: the runtime cannot make the call: Node.js older than 26, a platform
+ *   other than Linux on x64 or arm64, a C library other than glibc (`libc.so.6`), `node:ffi`
+ *   disabled (`--no-experimental-ffi`) or denied by the permission model (no `--allow-ffi`).
+ * - `notify_socket_invalid`: `NOTIFY_SOCKET` is not an `AF_UNIX` path or abstract name this
+ *   module can address (`vsock:` addresses included).
+ * - `notify_field_invalid`: a notification field name or value systemd would not parse, or a
+ *   message larger than systemd reads (4096 bytes).
+ * - `notify_failed`: the message could not be sent (`errno` names why).
+ * - `descriptor_name_invalid`: an `FDNAME=` systemd would refuse.
+ * - `descriptor_invalid`: a descriptor number that cannot exist, or a count outside 1–253.
+ * - `listen_environment_invalid`: `LISTEN_PID`, `LISTEN_FDS` or `LISTEN_FDNAMES` is malformed,
+ *   `LISTEN_FDS` names a descriptor at or above the process's hard `RLIMIT_NOFILE`, or
+ *   `getrlimit(RLIMIT_NOFILE)` failed, so the count cannot be bounded (`errno` names why).
+ * - `watchdog_environment_invalid`: `WATCHDOG_USEC` or `WATCHDOG_PID` is malformed.
+ * - `close_on_exec_failed`: a descriptor could not be marked close-on-exec (`errno` names why).
+ */
+export type TSystemdRuntimeErrorCode = 'runtime_unsupported' | 'notify_socket_invalid' | 'notify_field_invalid' | 'notify_failed' | 'descriptor_name_invalid' | 'descriptor_invalid' | 'listen_environment_invalid' | 'watchdog_environment_invalid' | 'close_on_exec_failed';
+export interface ISystemdRuntimeErrorOptions {
+    /** The C library's `errno` after the failed call, when a call failed. */
+    readonly errno?: number;
+    readonly cause?: unknown;
+}
+export declare class SystemdRuntimeError extends Error {
+    readonly code: TSystemdRuntimeErrorCode;
+    /** The C library's `errno` after the failed call, or null when no call failed. */
+    readonly errno: number | null;
+    constructor(code: TSystemdRuntimeErrorCode, messageArg: string, optionsArg?: ISystemdRuntimeErrorOptions);
+}

package/dist_ts_systemdruntime/classes.systemdruntimeerror.js

@@ -0,0 +1,9 @@
+export class SystemdRuntimeError extends Error {
+    constructor(code, messageArg, optionsArg = {}) {
+        super(`${messageArg}${optionsArg.errno === undefined ? '' : ` (errno ${optionsArg.errno})`}`, optionsArg.cause === undefined ? undefined : { cause: optionsArg.cause });
+        this.code = code;
+        this.name = 'SystemdRuntimeError';
+        this.errno = optionsArg.errno ?? null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5zeXN0ZW1kcnVudGltZWVycm9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHNfc3lzdGVtZHJ1bnRpbWUvY2xhc3Nlcy5zeXN0ZW1kcnVudGltZWVycm9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQW9DQSxNQUFNLE9BQU8sbUJBQW9CLFNBQVEsS0FBSztJQUk1QyxZQUNrQixJQUE4QixFQUM5QyxVQUFrQixFQUNsQixVQUFVLEdBQWdDLEVBQUU7UUFFNUMsS0FBSyxDQUNILEdBQUcsVUFBVSxHQUFHLFVBQVUsQ0FBQyxLQUFLLEtBQUssU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLFdBQVcsVUFBVSxDQUFDLEtBQUssR0FBRyxFQUFFLEVBQ3RGLFVBQVUsQ0FBQyxLQUFLLEtBQUssU0FBUyxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxFQUFFLFVBQVUsQ0FBQyxLQUFLLEVBQUUsQ0FDekUsQ0FBQztvQkFQYyxJQUFJO1FBUXBCLElBQUksQ0FBQyxJQUFJLEdBQUcscUJBQXFCLENBQUM7UUFDbEMsSUFBSSxDQUFDLEtBQUssR0FBRyxVQUFVLENBQUMsS0FBSyxJQUFJLElBQUksQ0FBQztJQUN4QyxDQUFDO0NBQ0YifQ==

package/dist_ts_systemdruntime/index.d.ts

@@ -0,0 +1,5 @@
+export * from './classes.systemdruntimeerror.js';
+export * from './classes.systemdnotifier.js';
+export { type ISystemdListenDescriptor, type ISystemdProcessEnvironmentOptions, setCloseOnExec, systemdListenDescriptorsStart, takeSystemdListenDescriptors, watchdogIntervalUsec, } from './systemdruntime.listen.js';
+export { systemdRuntimeNodeMajor } from './systemdruntime.libc.js';
+export { isSystemdDescriptorName, isSystemdNotifySocketAddress } from './systemdruntime.validation.js';