@push.rocks/smartdaemon 2.2.0 → 2.4.0

package/dist_ts/classes.systemdunitfile.js

@@ -0,0 +1,242 @@
+import * as plugins from './smartdaemon.plugins.js';
+import { SystemdServiceDefinition } from './classes.systemdservicedefinition.js';
+import { SystemdUnit, } from './classes.systemdunit.js';
+export class SystemdUnitFileError extends Error {
+    constructor(code) {
+        super(`Systemd unit definition installation failed: ${code}.`);
+        this.code = code;
+        this.name = 'SystemdUnitFileError';
+    }
+}
+const requireValue = (value, code) => {
+    if (!value)
+        throw new SystemdUnitFileError(code);
+};
+const digest = (bytes) => plugins.crypto.createHash('sha256').update(bytes).digest('hex');
+const quiet = (state) => state.mainPid === 0 && state.controlPid === 0 &&
+    state.controlGroup === '' && state.job === '' &&
+    (state.activeState === 'inactive' && state.subState === 'dead' ||
+        state.activeState === 'failed' && state.subState === 'failed');
+const masked = (state) => state.loadState === 'masked' &&
+    ['masked', 'masked-runtime'].includes(state.unitFileState);
+const sameFile = (left, right) => left.dev === right.dev && left.ino === right.ino;
+/**
+ * Protected code/config installation, inside the caller's cross-process installation ownership scope.
+ * Other privileged writers must be serialized by that owner. Never changes enablement or masks.
+ */
+export class SystemdUnitFile {
+    constructor(options) {
+        this.busy = false;
+        this.unit = new SystemdUnit(options);
+        this.name = options.unitName;
+        this.directory = options.unitDirectory ?? '/usr/local/lib/systemd/system';
+        this.uid = options.expectedUid ?? 0;
+        requireValue(typeof this.directory === 'string' && this.directory !== '/' &&
+            plugins.path.isAbsolute(this.directory) &&
+            plugins.path.normalize(this.directory) === this.directory &&
+            !this.directory.endsWith('/') && !/[\x00-\x1f\x7f]/.test(this.directory) &&
+            this.directory.length <= 4000 && Number.isSafeInteger(this.uid) && this.uid >= 0, 'invalid_options');
+        this.path = plugins.path.join(this.directory, this.name);
+    }
+    /** Reads only the exact protected definition; no systemd or filesystem mutation. */
+    async inspect() {
+        if (!await this.directories(false))
+            return null;
+        const file = await this.read(this.path);
+        return file ? Object.freeze({ path: this.path, sha256: digest(file.bytes) }) : null;
+    }
+    /**
+     * Expected previous digest is mandatory; null admits an absent file. Exact desired bytes are idempotent.
+     * Retains changed definitions beside the unit before replacement. A failed reload never rolls code back.
+     */
+    async install(definition, expectedSha256) {
+        requireValue(definition instanceof SystemdServiceDefinition && definition.unitName === this.name &&
+            (expectedSha256 === null ||
+                typeof expectedSha256 === 'string' && /^[a-f0-9]{64}$/.test(expectedSha256)), 'invalid_options');
+        requireValue(!this.busy, 'busy');
+        this.busy = true;
+        let temporary;
+        let temporaryInfo;
+        try {
+            const before = await this.unit.inspect();
+            await this.admit(before);
+            await this.directories(true);
+            const parent = await plugins.fs.lstat(this.directory);
+            const previous = await this.read(this.path);
+            const previousSha = previous ? digest(previous.bytes) : null;
+            const changed = previousSha !== definition.sha256;
+            requireValue(!changed || previousSha === expectedSha256, 'changed');
+            if (changed) {
+                if (previous) {
+                    const backup = `${this.path}.previous-${previousSha}`;
+                    try {
+                        await this.create(backup, previous.bytes);
+                    }
+                    catch (error) {
+                        if (error.code !== 'EEXIST')
+                            throw error;
+                        requireValue(digest((await this.read(backup)).bytes) === previousSha, 'changed');
+                    }
+                    await this.flushDirectory(parent);
+                }
+                temporary = plugins.path.join(this.directory, `.${this.name}.${plugins.crypto.randomUUID()}.tmp`);
+                await this.create(temporary, Buffer.from(definition.content));
+                temporaryInfo = await plugins.fs.lstat(temporary);
+                const current = await this.read(this.path);
+                requireValue((current ? digest(current.bytes) : null) === previousSha &&
+                    (!current || previous && sameFile(current.info, previous.info)), 'changed');
+                requireValue(sameFile(parent, await plugins.fs.lstat(this.directory)), 'unsafe_path');
+                const rechecked = await this.unit.inspect();
+                requireValue(JSON.stringify(rechecked) === JSON.stringify(before), 'changed');
+                await this.admit(rechecked);
+                await plugins.fs.rename(temporary, this.path);
+                temporary = undefined;
+                await this.flushDirectory(parent);
+            }
+            try {
+                await this.unit.reloadConfiguration();
+                const after = await this.unit.inspect();
+                requireValue(quiet(after) &&
+                    (before.loadState === 'not-found'
+                        ? after.loadState === 'loaded' && after.unitFileState === 'disabled'
+                        : after.loadState === before.loadState &&
+                            after.unitFileState === before.unitFileState), 'changed');
+                const configuration = await this.unit.inspectConfiguration();
+                requireValue(!configuration.needsReload && configuration.dropInPaths === '' &&
+                    configuration.fragmentPath === (masked(after) ? '/dev/null' : this.path), 'unsafe_unit');
+                const installed = await this.inspect();
+                requireValue(installed?.sha256 === definition.sha256, 'changed');
+                return Object.freeze({ changed, record: installed, masked: masked(after) });
+            }
+            catch {
+                throw new SystemdUnitFileError('reload_failed');
+            }
+        }
+        catch (error) {
+            if (error instanceof SystemdUnitFileError)
+                throw error;
+            throw new SystemdUnitFileError('write_failed');
+        }
+        finally {
+            try {
+                if (temporary && temporaryInfo) {
+                    const named = await plugins.fs.lstat(temporary);
+                    requireValue(sameFile(temporaryInfo, named), 'unsafe_path');
+                    await plugins.fs.unlink(temporary);
+                }
+            }
+            finally {
+                this.busy = false;
+            }
+        }
+    }
+    async admit(state) {
+        requireValue(quiet(state) && (masked(state) ||
+            state.loadState === 'loaded' &&
+                ['enabled', 'enabled-runtime', 'disabled'].includes(state.unitFileState) ||
+            state.loadState === 'not-found' && state.unitFileState === ''), 'unsafe_unit');
+        const configuration = await this.unit.inspectConfiguration();
+        requireValue(configuration.dropInPaths === '' && configuration.fragmentPath ===
+            (masked(state) ? '/dev/null' : state.loadState === 'not-found' ? '' : this.path), 'unsafe_unit');
+    }
+    async directories(create) {
+        requireValue(process.platform === 'linux' && process.getuid?.() === this.uid, 'unsafe_path');
+        let directory = '/';
+        for (const part of this.directory.split('/').filter(Boolean)) {
+            directory = plugins.path.join(directory, part);
+            let info;
+            try {
+                info = await plugins.fs.lstat(directory);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+                if (!create)
+                    return false;
+                await plugins.fs.mkdir(directory, { mode: 0o755 });
+                const parent = await plugins.fs.open(plugins.path.dirname(directory), plugins.fsConstants.O_RDONLY | plugins.fsConstants.O_DIRECTORY |
+                    plugins.fsConstants.O_NOFOLLOW);
+                try {
+                    await parent.sync();
+                }
+                finally {
+                    await parent.close();
+                }
+                info = await plugins.fs.lstat(directory);
+            }
+            requireValue(info.isDirectory() && !info.isSymbolicLink() && [0, this.uid].includes(info.uid) &&
+                ((info.mode & 0o022) === 0 || directory === '/tmp' && info.uid === 0 &&
+                    (info.mode & 0o7777) === 0o1777), 'unsafe_path');
+        }
+        return true;
+    }
+    async read(path) {
+        let file;
+        try {
+            file = await plugins.fs.open(path, plugins.fsConstants.O_RDONLY | plugins.fsConstants.O_NOFOLLOW |
+                plugins.fsConstants.O_NONBLOCK);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return null;
+            throw new SystemdUnitFileError('unsafe_path');
+        }
+        try {
+            const info = await file.stat();
+            requireValue(info.isFile() && info.uid === this.uid && info.nlink === 1 &&
+                (info.mode & 0o7777) === 0o644 && info.size <= 16384, 'unsafe_path');
+            const bytes = Buffer.alloc(16385);
+            let size = 0;
+            for (;;) {
+                const result = await file.read(bytes, size, bytes.length - size, size);
+                if (result.bytesRead === 0)
+                    break;
+                size += result.bytesRead;
+                requireValue(size <= 16384, 'unsafe_path');
+            }
+            const after = await file.stat(), named = await plugins.fs.lstat(path);
+            requireValue(sameFile(info, named) && !named.isSymbolicLink() && after.size === size &&
+                info.size === after.size && info.mtimeMs === after.mtimeMs &&
+                info.ctimeMs === after.ctimeMs, 'changed');
+            return { bytes: bytes.subarray(0, size), info };
+        }
+        finally {
+            await file.close();
+        }
+    }
+    async create(path, bytes) {
+        const file = await plugins.fs.open(path, plugins.fsConstants.O_CREAT | plugins.fsConstants.O_EXCL |
+            plugins.fsConstants.O_WRONLY | plugins.fsConstants.O_NOFOLLOW, 0o644);
+        let created;
+        try {
+            try {
+                created = await file.stat();
+                await file.chmod(0o644);
+                await file.writeFile(bytes);
+                await file.sync();
+            }
+            finally {
+                await file.close();
+            }
+        }
+        catch (error) {
+            if (created) {
+                requireValue(sameFile(created, await plugins.fs.lstat(path)), 'unsafe_path');
+                await plugins.fs.unlink(path);
+            }
+            throw error;
+        }
+    }
+    async flushDirectory(expected) {
+        const directory = await plugins.fs.open(this.directory, plugins.fsConstants.O_RDONLY |
+            plugins.fsConstants.O_DIRECTORY | plugins.fsConstants.O_NOFOLLOW);
+        try {
+            requireValue(sameFile(expected, await directory.stat()), 'unsafe_path');
+            await directory.sync();
+        }
+        finally {
+            await directory.close();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.systemdunitfile.js","sourceRoot":"","sources":["../ts/classes.systemdunitfile.ts"],"names":[],"mappings":"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"}

package/dist_ts/index.d.ts

@@ -1,2 +1,5 @@
 export * from './smartdaemon.classes.smartdaemon.js';
 export * from './smartdaemon.classes.service.js';
+export * from './classes.systemdunit.js';
+export * from './classes.systemdservicedefinition.js';
+export * from './classes.systemdunitfile.js';

package/dist_ts/index.js

@@ -1,3 +1,6 @@
 export * from './smartdaemon.classes.smartdaemon.js';
 export * from './smartdaemon.classes.service.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsa0NBQWtDLENBQUMifQ==
+export * from './classes.systemdunit.js';
+export * from './classes.systemdservicedefinition.js';
+export * from './classes.systemdunitfile.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLHVDQUF1QyxDQUFDO0FBQ3RELGNBQWMsOEJBQThCLENBQUMifQ==

package/dist_ts/smartdaemon.plugins.d.ts

@@ -1,5 +1,10 @@
 import * as path from 'path';
-export { path };
+import * as childProcess from 'node:child_process';
+import * as fs from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+import * as crypto from 'node:crypto';
+export type { Stats } from 'node:fs';
+export { path, childProcess, fs, fsConstants, crypto };
 import * as lik from '@push.rocks/lik';
 import * as smartfm from '@push.rocks/smartfm';
 import * as smartfs from '@push.rocks/smartfs';

package/dist_ts/smartdaemon.plugins.js

@@ -1,6 +1,10 @@
 // node native scope
 import * as path from 'path';
-export { path };
+import * as childProcess from 'node:child_process';
+import * as fs from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+import * as crypto from 'node:crypto';
+export { path, childProcess, fs, fsConstants, crypto };
 // @pushrocks scope
 import * as lik from '@push.rocks/lik';
 import * as smartfm from '@push.rocks/smartfm';
@@ -12,4 +16,4 @@ import * as smartshell from '@push.rocks/smartshell';
 import * as smartsystem from '@push.rocks/smartsystem';
 export { lik, smartfm, smartfs, smartlog, smartlogDestinationLocal, smartpath, smartshell, smartsystem, };
 // third party
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRkYWVtb24ucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0ZGFlbW9uLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sRUFBRSxJQUFJLEVBQUUsQ0FBQztBQUVoQixtQkFBbUI7QUFDbkIsT0FBTyxLQUFLLEdBQUcsTUFBTSxpQkFBaUIsQ0FBQztBQUN2QyxPQUFPLEtBQUssT0FBTyxNQUFNLHFCQUFxQixDQUFDO0FBQy9DLE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUFDL0MsT0FBTyxLQUFLLFFBQVEsTUFBTSxzQkFBc0IsQ0FBQztBQUNqRCxPQUFPLEtBQUssd0JBQXdCLE1BQU0sd0NBQXdDLENBQUM7QUFDbkYsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssVUFBVSxNQUFNLHdCQUF3QixDQUFDO0FBQ3JELE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFFdkQsT0FBTyxFQUNMLEdBQUcsRUFDSCxPQUFPLEVBQ1AsT0FBTyxFQUNQLFFBQVEsRUFDUix3QkFBd0IsRUFDeEIsU0FBUyxFQUNULFVBQVUsRUFDVixXQUFXLEdBQ1osQ0FBQztBQUVGLGNBQWMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRkYWVtb24ucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0ZGFlbW9uLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sS0FBSyxZQUFZLE1BQU0sb0JBQW9CLENBQUM7QUFDbkQsT0FBTyxLQUFLLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUN2QyxPQUFPLEVBQUUsU0FBUyxJQUFJLFdBQVcsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUNuRCxPQUFPLEtBQUssTUFBTSxNQUFNLGFBQWEsQ0FBQztBQUd0QyxPQUFPLEVBQUUsSUFBSSxFQUFFLFlBQVksRUFBRSxFQUFFLEVBQUUsV0FBVyxFQUFFLE1BQU0sRUFBRSxDQUFDO0FBRXZELG1CQUFtQjtBQUNuQixPQUFPLEtBQUssR0FBRyxNQUFNLGlCQUFpQixDQUFDO0FBQ3ZDLE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUFDL0MsT0FBTyxLQUFLLE9BQU8sTUFBTSxxQkFBcUIsQ0FBQztBQUMvQyxPQUFPLEtBQUssUUFBUSxNQUFNLHNCQUFzQixDQUFDO0FBQ2pELE9BQU8sS0FBSyx3QkFBd0IsTUFBTSx3Q0FBd0MsQ0FBQztBQUNuRixPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxVQUFVLE1BQU0sd0JBQXdCLENBQUM7QUFDckQsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUV2RCxPQUFPLEVBQ0wsR0FBRyxFQUNILE9BQU8sRUFDUCxPQUFPLEVBQ1AsUUFBUSxFQUNSLHdCQUF3QixFQUN4QixTQUFTLEVBQ1QsVUFBVSxFQUNWLFdBQVcsR0FDWixDQUFDO0FBRUYsY0FBYyJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartdaemon",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "private": false,
   "description": "Start scripts as long running daemons and manage them.",
   "main": "dist_ts/index.js",
@@ -27,9 +27,9 @@
   "homepage": "https://code.foss.global/push.rocks/smartdaemon",
   "devDependencies": {
     "@git.zone/tsbuild": "^4.4.2",
-    "@git.zone/tsrun": "^2.0.4",
-    "@git.zone/tstest": "^3.6.6",
-    "@types/node": "^25.9.1"
+    "@git.zone/tsrun": "^2.0.6",
+    "@git.zone/tstest": "^6.0.0",
+    "@types/node": "^26.4.1"
   },
   "dependencies": {
     "@push.rocks/lik": "^6.4.1",

package/readme.md

@@ -1,6 +1,10 @@
 # @push.rocks/smartdaemon 🚀
 **Turn your Node.js scripts into production-ready system daemons**
 
+## Issue Reporting and Security
+
+For reporting bugs, issues, or security vulnerabilities, please visit [community.foss.global/](https://community.foss.global/). This is the central community hub for all issue reporting. Developers who sign and comply with our contribution agreement and go through identification can also get a [code.foss.global/](https://code.foss.global/) account to submit Pull Requests directly.
+
 [![npm version](https://img.shields.io/npm/v/@push.rocks/smartdaemon.svg?style=flat-square)](https://www.npmjs.com/package/@push.rocks/smartdaemon)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
@@ -147,6 +151,104 @@ class SmartDaemon {
 }
 ```
 
+### Inspecting and controlling an existing systemd unit
+
+`SystemdUnit` works with an exact canonical `.service` name. Construction performs
+no I/O. It does not create or rewrite a unit, enable it, remove a mask, or invoke
+sudo. The caller must already have permission for lifecycle commands.
+
+```typescript
+import { SystemdUnit } from '@push.rocks/smartdaemon';
+
+const unit = new SystemdUnit({ unitName: 'smartdaemon_my-api-server.service' });
+const state = await unit.inspect();
+console.log(state.loadState, state.activeState, state.unitFileState);
+
+// Application code decides whether stopping or restarting is appropriate.
+// await unit.stop();
+// await unit.start();
+```
+
+Snapshots are immutable and also include `subState`, `mainPid`, `controlPid`,
+`controlGroup`, `killMode`, and `job`. An empty `job` means no systemd job was
+reported. Missing and masked units remain distinct from inactive or disabled
+units. Aliases resolving to a different canonical unit are rejected.
+
+`start()` and `stop()` await the systemctl command and return a fresh snapshot.
+They do not establish application readiness or prove database shutdown; callers
+must apply the owning application's lifecycle contract. A command failure or
+timeout rejects with `SystemdUnitError` and a local code, without returning raw
+command diagnostics. The systemd job can continue after a client timeout, so a
+failed command must not be treated as cancelled or successfully completed.
+
+Calls use an absolute `systemctlPath` (default `/usr/bin/systemctl`), a clean
+environment, no shell or password prompt, and bounded output. Trusted owning code
+can choose another absolute executable path and `commandTimeoutMs` (default
+120000, maximum 600000). This timeout bounds the client process only.
+
+`inspectConfiguration()` reports the selected `fragmentPath`, opaque `dropInPaths`
+list and `needsReload` flag. `reloadConfiguration()` explicitly reloads the manager's
+unit definitions globally and returns a fresh configuration snapshot. Neither
+operation changes enablement or masks.
+
+### Installing a direct systemd service definition
+
+`SystemdServiceDefinition` encodes a literal executable and argument list, with
+explicit user, group, restart policy, kill mode and stop timeout. It uses `Type=exec`,
+journal output and null stdin. It introduces no shell; percent specifiers and
+argument environment expansion are escaped. Paths must be absolute and normalized;
+control characters are rejected. Descriptions and working directories cannot have
+backslashes or surrounding whitespace; executable paths also reject quotes and
+backslashes. Arguments may contain spaces, quotes, backslashes and empty strings.
+
+```typescript
+import { SystemdServiceDefinition, SystemdUnitFile } from '@push.rocks/smartdaemon';
+
+const definition = new SystemdServiceDefinition({
+  unitName: 'smartdaemon_my-api-server.service',
+  description: 'My API server',
+  executable: '/opt/my-api/bin/server',
+  args: ['serve'],
+  workingDirectory: '/opt/my-api',
+  user: 'root',
+  group: 'root',
+  restart: 'no',
+  killMode: 'mixed',
+  timeoutStopSeconds: 360,
+});
+const file = new SystemdUnitFile({ unitName: definition.unitName });
+// Inside the privileged installer's existing cross-process ownership scope:
+const previous = await file.inspect();
+const installed = await file.install(definition, previous?.sha256 ?? null);
+console.log(installed.changed, installed.masked, installed.record.sha256);
+```
+
+Installation requires Linux, root and a quiescent exact unit with no process,
+cgroup or job. It rejects effective drop-ins and shadowing fragments. Definitions
+default to `/usr/local/lib/systemd/system`, below administrator configuration in
+the load path, so existing persistent/runtime masks remain intact. Existing
+enablement is preserved; an absent unit becomes disabled. It never enables,
+unmasks, starts or stops a service, or invokes sudo.
+
+The caller must already serialize privileged installation across processes;
+`SystemdUnitFile` only excludes simultaneous operations on the same instance.
+The expected previous SHA-256 is mandatory (`null` requires an absent file),
+while already matching bytes are idempotent. Installation checks protected
+directories and regular single-link mode-0644 files, retains changed definitions
+as `<unit>.previous-<sha256>`, flushes them before atomic replacement, reloads
+the manager and checks its selected fragment and final bytes. A reload failure
+leaves the new file and retained previous definition in place; recovery requires
+inspection, never an automatic rollback. Filesystem and definition errors use
+`SystemdUnitFileError` with a local code. Trusted qualification code can set
+`unitDirectory`, `expectedUid` and the inherited `SystemdUnit` command options.
+
+With `killMode: 'mixed'`, the main process owns graceful child shutdown and must
+remain alive until its children have joined. Systemd sends SIGTERM to the main
+process first and can send SIGKILL to the whole cgroup when the main process exits
+or the stop deadline expires. `control-group` sends the initial signal to the
+whole group. A successful systemd start still requires application readiness
+verification, and a completed stop alone does not prove database drain.
+
 ### SmartDaemonService Class
 
 ```typescript
@@ -424,4 +526,4 @@ Registered at District court Bremen HRB 35230 HB, Germany
 
 For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
 
-By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartdaemon',
-  version: '2.2.0',
+  version: '2.4.0',
   description: 'Start scripts as long running daemons and manage them.'
 }

package/ts/classes.systemdservicedefinition.ts

@@ -0,0 +1,134 @@
+import * as plugins from './smartdaemon.plugins.js';
+
+export interface ISystemdServiceDefinitionOptions {
+  unitName: string;
+  description: string;
+  executable: string;
+  args: readonly string[];
+  workingDirectory: string;
+  user: string;
+  group: string;
+  restart: 'no' | 'on-failure' | 'always';
+  killMode: 'mixed' | 'control-group';
+  timeoutStopSeconds: number;
+}
+
+export class SystemdServiceDefinitionError extends Error {
+  constructor() {
+    super('Invalid direct systemd service definition.');
+    this.name = 'SystemdServiceDefinitionError';
+  }
+}
+
+/** Literal direct-execution definition; never introduces a shell or environment expansion. */
+export class SystemdServiceDefinition {
+  public readonly unitName: string;
+  public readonly content: string;
+  public readonly sha256: string;
+
+  constructor(options: ISystemdServiceDefinitionOptions) {
+    const requireValue = (value: unknown): void => {
+      if (!value) throw new SystemdServiceDefinitionError();
+    };
+    const text = (value: unknown, maximum = 4096): value is string =>
+      typeof value === 'string' && value.length <= maximum && !/[\x00-\x1f\x7f]/.test(value) &&
+      !/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(value);
+    const absolute = (value: unknown) =>
+      text(value) && plugins.path.isAbsolute(value) &&
+      plugins.path.normalize(value) === value;
+    const keys = [
+      'unitName',
+      'description',
+      'executable',
+      'args',
+      'workingDirectory',
+      'user',
+      'group',
+      'restart',
+      'killMode',
+      'timeoutStopSeconds',
+    ];
+    requireValue(
+      options && Object.getPrototypeOf(options) === Object.prototype &&
+        Reflect.ownKeys(options).length === keys.length && keys.every((key) => {
+          const descriptor = Object.getOwnPropertyDescriptor(options, key);
+          return descriptor && 'value' in descriptor;
+        }),
+    );
+    requireValue(
+      typeof options.unitName === 'string' &&
+        /^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,230}\.service$/.test(options.unitName),
+    );
+    requireValue(
+      text(options.description, 1024) && options.description.length > 0 &&
+        options.description.trim() === options.description && !options.description.includes('\\'),
+    );
+    requireValue(
+      absolute(options.executable) && options.executable !== '/' &&
+        !/[\\"']/.test(options.executable) && !options.executable.endsWith('/') &&
+        absolute(options.workingDirectory) &&
+        options.workingDirectory.trim() === options.workingDirectory &&
+        !options.workingDirectory.includes('\\'),
+    );
+    requireValue(
+      Array.isArray(options.args) && Object.getPrototypeOf(options.args) === Array.prototype &&
+        options.args.length <= 128 &&
+        Reflect.ownKeys(options.args).length === options.args.length + 1 &&
+        Array.from(
+          { length: options.args.length },
+          (_, index) => Object.getOwnPropertyDescriptor(options.args, String(index)),
+        )
+          .every((descriptor) => descriptor && 'value' in descriptor && text(descriptor.value)),
+    );
+    requireValue(
+      [options.user, options.group].every((value) =>
+        typeof value === 'string' && /^[a-zA-Z_][a-zA-Z0-9_-]{0,63}$/.test(value)
+      ),
+    );
+    requireValue(
+      ['no', 'on-failure', 'always'].includes(options.restart) &&
+        ['mixed', 'control-group'].includes(options.killMode) &&
+        Number.isSafeInteger(options.timeoutStopSeconds) &&
+        options.timeoutStopSeconds >= 1 && options.timeoutStopSeconds <= 600,
+    );
+    // Quoting and percent/dollar escaping follow systemd.syntax and systemd.service.
+    const quote = (value: string, command = false) =>
+      '"' + value
+        .replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll('%', '%%')
+        .replaceAll('$', () => command ? '$$' : '$') +
+      '"';
+    this.unitName = options.unitName;
+    this.content = [
+      '[Unit]',
+      `Description=${options.description.replaceAll('%', '%%')}`,
+      'After=local-fs.target',
+      '',
+      '[Service]',
+      'Type=exec',
+      `User=${options.user}`,
+      `Group=${options.group}`,
+      `ExecStart=${
+        [quote(options.executable), ...options.args.map((value) => quote(value, true))].join(' ')
+      }`,
+      // WorkingDirectory is a raw path value, not an ExecStart word list.
+      `WorkingDirectory=${options.workingDirectory.replaceAll('%', '%%')}`,
+      `Restart=${options.restart}`,
+      `KillMode=${options.killMode}`,
+      'KillSignal=SIGTERM',
+      'FinalKillSignal=SIGKILL',
+      'SendSIGKILL=yes',
+      'SendSIGHUP=no',
+      `TimeoutStopSec=${options.timeoutStopSeconds}s`,
+      'StandardInput=null',
+      'StandardOutput=journal',
+      'StandardError=journal',
+      '',
+      '[Install]',
+      'WantedBy=multi-user.target',
+      '',
+    ].join('\n');
+    requireValue(Buffer.byteLength(this.content) <= 16384);
+    this.sha256 = plugins.crypto.createHash('sha256').update(this.content).digest('hex');
+    Object.freeze(this);
+  }
+}