@push.rocks/smartdaemon 2.22.0 → 3.1.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRkYWVtb24uY2xhc3Nlcy5zeXN0ZW1kbWFuYWdlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0ZGFlbW9uLmNsYXNzZXMuc3lzdGVtZG1hbmFnZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSwwQkFBMEIsQ0FBQztBQUNwRCxPQUFPLEtBQUssS0FBSyxNQUFNLHdCQUF3QixDQUFDO0FBQ2hELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUNuRSxPQUFPLEVBRUwsa0JBQWtCLEdBQ25CLE1BQU0sa0NBQWtDLENBQUM7QUFFMUMsTUFBTSxPQUFPLHlCQUF5QjtJQUNwQyxTQUFTO2FBQ00seUJBQW9CLEdBQUcsYUFBYSxBQUFoQixDQUFpQjtJQUU3QyxNQUFNLENBQUMsZ0NBQWdDLENBQUMsY0FBc0I7UUFDbkUsT0FBTyxHQUFHLHlCQUF5QixDQUFDLG9CQUFvQixJQUFJLGNBQWMsRUFBRSxDQUFDO0lBQy9FLENBQUM7SUFFTSxNQUFNLENBQUMsNkJBQTZCLENBQUMsY0FBc0I7UUFDaEUsT0FBTyxHQUFHLHlCQUF5QixDQUFDLGdDQUFnQyxDQUFDLGNBQWMsQ0FBQyxVQUFVLENBQUM7SUFDakcsQ0FBQztJQUVNLE1BQU0sQ0FBQyw2QkFBNkIsQ0FBQyxjQUFzQjtRQUNoRSxPQUFPLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUN0QixLQUFLLENBQUMsVUFBVSxFQUNoQix5QkFBeUIsQ0FBQyw2QkFBNkIsQ0FBQyxjQUFjLENBQUMsQ0FDeEUsQ0FBQztJQUNKLENBQUM7SUFXRCxZQUFZLGlCQUE4QixFQUFFLGVBQXdCO1FBSjdELGtCQUFhLEdBQVksS0FBSyxDQUFDO1FBQy9CLFdBQU0sR0FBWSxLQUFLLENBQUM7UUFJN0IsSUFBSSxDQUFDLGNBQWMsR0FBRyxpQkFBaUIsQ0FBQztRQUN4QyxJQUFJLENBQUMsa0JBQWtCLEdBQUcsSUFBSSxPQUFPLENBQUMsVUFBVSxDQUFDLFVBQVUsQ0FBQztZQUMxRCxRQUFRLEVBQUUsTUFBTTtTQUNqQixDQUFDLENBQUM7UUFDSCxJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksT0FBTyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsSUFBSSxPQUFPLENBQUMsT0FBTyxDQUFDLG1CQUFtQixFQUFFLENBQUMsQ0FBQztRQUN0RixJQUFJLENBQUMsWUFBWSxHQUFHLGVBQWUsQ0FBQztRQUVwQyxpQ0FBaUM7UUFDakMsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRTtZQUMvQixJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQztZQUNyQixJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7Z0JBQ1osT0FBTyxDQUFDLEdBQUcsQ0FBQyxtRUFBbUUsQ0FBQyxDQUFDO1lBQ25GLENBQUM7UUFDSCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFTyxLQUFLLENBQUMsV0FBVztRQUN2QixNQUFNLE1BQU0sR0FBRyxNQUFNLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDM0QsT0FBTyxNQUFNLENBQUMsTUFBTSxDQUFDLElBQUksRUFBRSxLQUFLLEdBQUcsQ0FBQztJQUN0QyxDQUFDO0lBRU0sS0FBSyxDQUFDLGdCQUFnQjtRQUMzQixJQUFJLE9BQU8sQ0FBQyxFQUFFLENBQUMsUUFBUSxFQUFFLEtBQUssT0FBTyxFQUFFLENBQUM7WUFDdEMsSUFBSSxDQUFDLGFBQWEsR0FBRyxJQUFJLENBQUM7UUFDNUIsQ0FBQzthQUFNLENBQUM7WUFDTixPQUFPLENBQUMsR0FBRyxDQUFDLDhFQUE4RSxDQUFDLENBQUM7WUFDNUYsSUFBSSxDQUFDLGFBQWEsR0FBRyxLQUFLLENBQUM7UUFDN0IsQ0FBQztRQUNELE9BQU8sSUFBSSxDQUFDLGFBQWEsQ0FBQztJQUM1QixDQUFDO0lBRU0sS0FBSyxDQUFDLE9BQU8sQ0FBQyxVQUFrQjtRQUNyQyxJQUFJLE1BQU0sSUFBSSxDQUFDLGdCQUFnQixFQUFFLEVBQUUsQ0FBQztZQUNsQyx3RUFBd0U7WUFDeEUsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLElBQUksQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUM7Z0JBQ25ELFVBQVUsR0FBRyxRQUFRLFVBQVUsRUFBRSxDQUFDO2dCQUVsQyxJQUFJLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztvQkFDdEIsOENBQThDO29CQUM5QyxNQUFNLGVBQWUsR0FBRyxNQUFNLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyx5QkFBeUIsQ0FBQyxVQUFVLENBQUMsQ0FBQztvQkFDNUYsTUFBTSxlQUFlLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQztvQkFDbEQsTUFBTSxNQUFNLEdBQUcsTUFBTSxlQUFlLENBQUMsWUFBWSxDQUFDO29CQUNsRCxPQUFPLE1BQU0sQ0FBQztnQkFDaEIsQ0FBQztZQUNILENBQUM7WUFFRCx5Q0FBeUM7WUFDekMsSUFBSSxDQUFDO2dCQUNILE1BQU0sSUFBSSxDQUFDLGtCQUFrQixDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQztZQUNqRCxDQUFDO1lBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQztnQkFDZixJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sSUFBSSxLQUFLLFlBQVksS0FBSyxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLGdCQUFnQixDQUFDLEVBQUUsQ0FBQztvQkFDdkYsTUFBTSxJQUFJLEtBQUssQ0FBQyw0RkFBNEYsQ0FBQyxDQUFDO2dCQUNoSCxDQUFDO2dCQUNELE1BQU0sS0FBSyxDQUFDO1lBQ2QsQ0FBQztRQUNILENBQUM7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxLQUFLLENBQUMsV0FBVztRQUN0QixNQUFNLGdCQUFnQixHQUF5QixFQUFFLENBQUM7UUFDbEQsSUFBSSxNQUFNLElBQUksQ0FBQyxnQkFBZ0IsRUFBRSxFQUFFLENBQUM7WUFDbEMsTUFBTSxpQkFBaUIsR0FBRyxNQUFNLElBQUksQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsQ0FBQyxNQUFNLENBQUMsdUJBQXVCLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUNoSCxLQUFLLE1BQU0sV0FBVyxJQUFJLGlCQUFpQixFQUFFLENBQUM7Z0JBQzVDLE1BQU0sa0JBQWtCLEdBQUcsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDO2dCQUM3RixNQUFNLElBQUksR0FBRyxDQUNYLE1BQU0sT0FBTyxDQUFDLGFBQWEsQ0FBQyx1QkFBdUIsQ0FBQyxrQkFBa0IsQ0FBQyxRQUFRLEVBQUUsRUFBRSxJQUFJLENBQUMsQ0FDekYsQ0FBQyxJQUF3RCxDQUFDO2dCQUMzRCxNQUFNLE9BQU8sR0FBRyxNQUFNLGtCQUFrQixDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxjQUFjLEVBQUUsSUFBSSxDQUFDLENBQUM7Z0JBQ3RGLE9BQU8sQ0FBQyxhQUFhLEdBQUcsSUFBSSxDQUFDO2dCQUM3QixnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDakMsQ0FBQztRQUNILENBQUM7UUFDRCxPQUFPLGdCQUFnQixDQUFDO0lBQzFCLENBQUM7SUFFTSxLQUFLLENBQUMsWUFBWSxDQUFDLFVBQThCO1FBQ3RELElBQUksTUFBTSxJQUFJLENBQUMsZ0JBQWdCLEVBQUUsRUFBRSxDQUFDO1lBQ2xDLE1BQU0sSUFBSSxDQUFDLE9BQU8sQ0FDaEIsbUJBQW1CLHlCQUF5QixDQUFDLGdDQUFnQyxDQUMzRSxVQUFVLENBQUMsSUFBSSxDQUNoQixFQUFFLENBQ0osQ0FBQztRQUNKLENBQUM7SUFDSCxDQUFDO0lBQ00sS0FBSyxDQUFDLFdBQVcsQ0FBQyxVQUE4QjtRQUNyRCxJQUFJLE1BQU0sSUFBSSxDQUFDLGdCQUFnQixFQUFFLEVBQUUsQ0FBQztZQUNsQyxNQUFNLElBQUksQ0FBQyxPQUFPLENBQ2hCLGtCQUFrQix5QkFBeUIsQ0FBQyxnQ0FBZ0MsQ0FDMUUsVUFBVSxDQUFDLElBQUksQ0FDaEIsRUFBRSxDQUNKLENBQUM7UUFDSixDQUFDO0lBQ0gsQ0FBQztJQUVNLEtBQUssQ0FBQyxXQUFXLENBQUMsVUFBOEI7UUFDckQsSUFBSSxNQUFNLElBQUksQ0FBQyxnQkFBZ0IsRUFBRSxFQUFFLENBQUM7WUFDbEMsTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLGNBQWMsQ0FBQyxlQUFlLENBQUMsMEJBQTBCLENBQUMsVUFBVSxDQUFDLENBQUM7WUFDM0YsTUFBTSxVQUFVLEdBQUcseUJBQXlCLENBQUMsNkJBQTZCLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDO1lBRTVGLElBQUksSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO2dCQUNoQixvQ0FBb0M7Z0JBQ3BDLE1BQU0sSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDbEYsQ0FBQztpQkFBTSxDQUFDO2dCQUNOLGtDQUFrQztnQkFDbEMsTUFBTSxRQUFRLEdBQUcsb0JBQW9CLFVBQVUsQ0FBQyxJQUFJLFVBQVUsQ0FBQztnQkFDL0QsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztnQkFDOUUsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sUUFBUSxJQUFJLFVBQVUsRUFBRSxDQUFDLENBQUMsQ0FBQywwQkFBMEI7Z0JBQzlFLE1BQU0sSUFBSSxDQUFDLE9BQU8sQ0FBQyxhQUFhLFVBQVUsRUFBRSxDQUFDLENBQUMsQ0FBQywwQkFBMEI7WUFDM0UsQ0FBQztRQUNILENBQUM7SUFDSCxDQUFDO0lBRU0sS0FBSyxDQUFDLGFBQWEsQ0FBQyxVQUE4QjtRQUN2RCxJQUFJLE1BQU0sSUFBSSxDQUFDLGdCQUFnQixFQUFFLEVBQUUsQ0FBQztZQUNsQyxNQUFNLFFBQVEsR0FBRyx5QkFBeUIsQ0FBQyw2QkFBNkIsQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLENBQUM7WUFFMUYsSUFBSSxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7Z0JBQ2hCLE1BQU0sSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUMsTUFBTSxFQUFFLENBQUM7WUFDN0MsQ0FBQztpQkFBTSxDQUFDO2dCQUNOLE1BQU0sSUFBSSxDQUFDLE9BQU8sQ0FBQyxNQUFNLFFBQVEsRUFBRSxDQUFDLENBQUMsQ0FBQywwQkFBMEI7WUFDbEUsQ0FBQztRQUNILENBQUM7SUFDSCxDQUFDO0lBRU0sS0FBSyxDQUFDLGFBQWEsQ0FBQyxVQUE4QjtRQUN2RCxJQUFJLE1BQU0sSUFBSSxDQUFDLGdCQUFnQixFQUFFLEVBQUUsQ0FBQztZQUNsQyxNQUFNLElBQUksQ0FBQyxXQUFXLENBQUMsVUFBVSxDQUFDLENBQUM7WUFDbkMsSUFBSSxVQUFVLENBQUMsYUFBYSxFQUFFLENBQUM7Z0JBQzdCLE1BQU0sSUFBSSxDQUFDLE9BQU8sQ0FBQyx5QkFBeUIsQ0FBQyxDQUFDO1lBQ2hELENBQUM7WUFDRCxNQUFNLElBQUksQ0FBQyxPQUFPLENBQ2hCLG9CQUFvQix5QkFBeUIsQ0FBQyxnQ0FBZ0MsQ0FDNUUsVUFBVSxDQUFDLElBQUksQ0FDaEIsRUFBRSxDQUNKLENBQUM7UUFDSixDQUFDO0lBQ0gsQ0FBQztJQUNNLEtBQUssQ0FBQyxjQUFjLENBQUMsVUFBOEI7UUFDeEQsSUFBSSxNQUFNLElBQUksQ0FBQyxnQkFBZ0IsRUFBRSxFQUFFLENBQUM7WUFDbEMsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUNoQixxQkFBcUIseUJBQXlCLENBQUMsZ0NBQWdDLENBQzdFLFVBQVUsQ0FBQyxJQUFJLENBQ2hCLEVBQUUsQ0FDSixDQUFDO1FBQ0osQ0FBQztJQUNILENBQUM7SUFFTSxLQUFLLENBQUMsTUFBTTtRQUNqQixJQUFJLE1BQU0sSUFBSSxDQUFDLGdCQUFnQixFQUFFLEVBQUUsQ0FBQztZQUNsQyxNQUFNLElBQUksQ0FBQyxPQUFPLENBQUMseUJBQXlCLENBQUMsQ0FBQztRQUNoRCxDQUFDO0lBQ0gsQ0FBQztDQUNGIn0=
+//# 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.plugins.d.ts

@@ -5,13 +5,12 @@ import { constants as fsConstants } from 'node:fs';
 import * as crypto from 'node:crypto';
 import * as util from 'node:util';
 import * as os from 'node:os';
+import * as timers from 'node:timers/promises';
 export type { Stats } from 'node:fs';
-export { path, childProcess, fs, fsConstants, crypto, util, os };
+export { path, childProcess, fs, fsConstants, crypto, util, os, timers };
 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

@@ -6,15 +6,14 @@ import { constants as fsConstants } from 'node:fs';
 import * as crypto from 'node:crypto';
 import * as util from 'node:util';
 import * as os from 'node:os';
-export { path, childProcess, fs, fsConstants, crypto, util, os };
+import * as timers from 'node:timers/promises';
+export { path, childProcess, fs, fsConstants, crypto, util, os, timers };
 // @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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRkYWVtb24ucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0ZGFlbW9uLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sS0FBSyxZQUFZLE1BQU0sb0JBQW9CLENBQUM7QUFDbkQsT0FBTyxLQUFLLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUN2QyxPQUFPLEVBQUUsU0FBUyxJQUFJLFdBQVcsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUNuRCxPQUFPLEtBQUssTUFBTSxNQUFNLGFBQWEsQ0FBQztBQUN0QyxPQUFPLEtBQUssSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUNsQyxPQUFPLEtBQUssRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUM5QixPQUFPLEtBQUssTUFBTSxNQUFNLHNCQUFzQixDQUFDO0FBRy9DLE9BQU8sRUFBRSxJQUFJLEVBQUUsWUFBWSxFQUFFLEVBQUUsRUFBRSxXQUFXLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBRSxFQUFFLEVBQUUsTUFBTSxFQUFFLENBQUM7QUFFekUsbUJBQW1CO0FBQ25CLE9BQU8sS0FBSyxHQUFHLE1BQU0saUJBQWlCLENBQUM7QUFDdkMsT0FBTyxLQUFLLE9BQU8sTUFBTSxxQkFBcUIsQ0FBQztBQUMvQyxPQUFPLEtBQUssYUFBYSxNQUFNLCtCQUErQixDQUFDO0FBQy9ELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFDbkQsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUVyRCxPQUFPLEVBQ0wsR0FBRyxFQUNILE9BQU8sRUFDUCxhQUFhLEVBQ2IsU0FBUyxFQUNULFVBQVUsR0FDWCxDQUFDO0FBRUYsY0FBYyJ9

package/dist_ts/systemd.managerversion.d.ts

@@ -15,6 +15,8 @@ export declare const fileDescriptorStorePreserveMajor = 254;
 export declare const outputAppendMajor = 240;
 /** Internal: the systemd major whose `systemctl clean` first releases a file descriptor store (`--what=fdstore`). */
 export declare const fileDescriptorStoreCleanMajor = 254;
+/** Internal: the systemd major whose `systemctl kill` first takes `--kill-whom=` (formerly `--kill-who=`). */
+export declare const killWhomMajor = 252;
 /**
  * Internal: the systemd major whose `systemd-run` first takes `--expand-environment` and reports a
  * started scope as `runInTransientScope()` reads it.

package/dist_ts/systemd.managerversion.js

@@ -4,6 +4,8 @@ export const fileDescriptorStorePreserveMajor = 254;
 export const outputAppendMajor = 240;
 /** Internal: the systemd major whose `systemctl clean` first releases a file descriptor store (`--what=fdstore`). */
 export const fileDescriptorStoreCleanMajor = 254;
+/** Internal: the systemd major whose `systemctl kill` first takes `--kill-whom=` (formerly `--kill-who=`). */
+export const killWhomMajor = 252;
 /**
  * Internal: the systemd major whose `systemd-run` first takes `--expand-environment` and reports a
  * started scope as `runInTransientScope()` reads it.
@@ -22,4 +24,4 @@ export const parseManagerVersion = (stdout) => {
     const match = /^Version=(([1-9][0-9]{0,3})(?:[.~+^_-][\x21-\x7e]{0,251})?)\n$/.exec(stdout);
     return match ? Object.freeze({ major: Number(match[2]), version: match[1] }) : undefined;
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3lzdGVtZC5tYW5hZ2VydmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3N5c3RlbWQubWFuYWdlcnZlcnNpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBWUEsa0dBQWtHO0FBQ2xHLE1BQU0sQ0FBQyxNQUFNLGdDQUFnQyxHQUFHLEdBQUcsQ0FBQztBQUVwRCx3R0FBd0c7QUFDeEcsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQUcsR0FBRyxDQUFDO0FBRXJDLHFIQUFxSDtBQUNySCxNQUFNLENBQUMsTUFBTSw2QkFBNkIsR0FBRyxHQUFHLENBQUM7QUFFakQ7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsR0FBRyxDQUFDO0FBRXZDLCtGQUErRjtBQUMvRixNQUFNLENBQUMsTUFBTSx1QkFBdUIsR0FBc0IsQ0FBQyxNQUFNLEVBQUUsb0JBQW9CLENBQUMsQ0FBQztBQUV6Rjs7Ozs7O0dBTUc7QUFDSCxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxDQUFDLE1BQWMsRUFBc0MsRUFBRTtJQUN4RixNQUFNLEtBQUssR0FBRyxnRUFBZ0UsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDNUYsT0FBTyxLQUFLLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsRUFBRSxLQUFLLEVBQUUsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLE9BQU8sRUFBRSxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUM7QUFDM0YsQ0FBQyxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3lzdGVtZC5tYW5hZ2VydmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3N5c3RlbWQubWFuYWdlcnZlcnNpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBWUEsa0dBQWtHO0FBQ2xHLE1BQU0sQ0FBQyxNQUFNLGdDQUFnQyxHQUFHLEdBQUcsQ0FBQztBQUVwRCx3R0FBd0c7QUFDeEcsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQUcsR0FBRyxDQUFDO0FBRXJDLHFIQUFxSDtBQUNySCxNQUFNLENBQUMsTUFBTSw2QkFBNkIsR0FBRyxHQUFHLENBQUM7QUFFakQsOEdBQThHO0FBQzlHLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBRyxHQUFHLENBQUM7QUFFakM7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsR0FBRyxDQUFDO0FBRXZDLCtGQUErRjtBQUMvRixNQUFNLENBQUMsTUFBTSx1QkFBdUIsR0FBc0IsQ0FBQyxNQUFNLEVBQUUsb0JBQW9CLENBQUMsQ0FBQztBQUV6Rjs7Ozs7O0dBTUc7QUFDSCxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxDQUFDLE1BQWMsRUFBc0MsRUFBRTtJQUN4RixNQUFNLEtBQUssR0FBRyxnRUFBZ0UsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDNUYsT0FBTyxLQUFLLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsRUFBRSxLQUFLLEVBQUUsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLE9BQU8sRUFBRSxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUM7QUFDM0YsQ0FBQyxDQUFDIn0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartdaemon",
-  "version": "2.22.0",
+  "version": "3.1.0",
   "private": false,
   "description": "Start scripts as long running daemons and manage them.",
   "main": "dist_ts/index.js",
@@ -37,18 +37,15 @@
   },
   "homepage": "https://code.foss.global/push.rocks/smartdaemon",
   "devDependencies": {
-    "@git.zone/tsbuild": "^6.0.2",
-    "@git.zone/tsrun": "^3.0.3",
-    "@git.zone/tstest": "^7.2.1",
-    "@types/node": "^26.6.4"
+    "@git.zone/tsrepo": "^1.1.1",
+    "@types/node": "^26.6.5"
   },
   "dependencies": {
     "@push.rocks/lik": "^6.4.4",
     "@push.rocks/smartfs": "^1.5.1",
-    "@push.rocks/smartlog": "^4.0.4",
     "@push.rocks/smartmarkdown": "^3.3.0",
     "@push.rocks/smartpath": "^6.0.0",
-    "@push.rocks/smartshell": "^4.2.1"
+    "@push.rocks/smartshell": "^5.0.0"
   },
   "files": [
     "ts/**/*",
@@ -69,9 +66,9 @@
     "last 1 chrome versions"
   ],
   "scripts": {
-    "test": "tstest test/ --verbose --timeout 60",
-    "build": "tsbuild tsfolders --web",
+    "test": "tsrepo test test/ --verbose --timeout 60",
+    "build": "tsrepo build tsfolders --web",
     "format": "gitzone format",
-    "buildDocs": "tsdoc"
+    "buildDocs": "tsrepo docs"
   }
 }

package/readme.md

@@ -21,7 +21,7 @@ For reporting bugs, issues, or security vulnerabilities, please visit [community
 - 🔄 **Systemd Integration**: Full Linux systemd support for production-grade service management
 - 🛡️ **Auto-Recovery**: Built-in service restart on failure
 - 📝 **Declarative Service Definitions**: Simple, clear service configuration
-- 🔌 **Interactive & Non-Interactive Modes**: Support for both passwordless sudo and interactive authentication
+- 🔌 **Passwordless or Password-Based Sudo**: Works with passwordless sudo, or hands a configured sudo password to sudo on standard input (no terminal or PTY needed)
 - 🎛️ **Complete Lifecycle Management**: Start, stop, enable, disable, and reload services with ease
 
 ## 📦 Installation
@@ -115,6 +115,20 @@ const service = await daemon.addService({
 await service.enable(); // Automatically uses sudo with password
 ```
 
+Each privileged command runs as `sudo -k -S -p '' -- <command>`: sudo reads the password from
+standard input, which is closed right after the password line, so a rejected password fails at
+once instead of waiting for a retry. The password is never placed in argv, the environment or the
+output, and no PTY (`node-pty`) is involved. `-k` makes sudo ask for the password every time and
+leaves no cached credentials behind. If a sudoers rule lets the command run without a password
+(`NOPASSWD`), sudo does not read standard input and the password line reaches the command's
+standard input instead (`systemctl`, `mv`, `chmod` and `rm` never read it); leave `sudoPassword`
+unset when sudo is passwordless.
+
+A command that does not exit 0 rejects with `SmartDaemonCommandError` (`command`, `exitCode`,
+`signal`, `stderr`), with or without a sudo password: a rejected password, a missing `sudo`
+(exit code 127) or a failing `systemctl` call all surface this way. Besides `systemctl`, saving
+and deleting a unit file as a non-root user runs `mv`, `chmod` and `rm` through sudo.
+
 ### Passwordless Sudo (Recommended for Production)
 
 For production environments, configure passwordless sudo for specific systemctl commands:
@@ -279,6 +293,49 @@ store needs systemd 254 or later: the call reads the manager's version first and
 manager with `SystemdUnitManagerTooOldError` (`manager_too_old`), an unreadable version with
 `version_unknown` and an unanswered read with `command_failed`, each without running the clean.
 
+`kill(signal?, options?)` ends a unit's processes without a stop job: it sends `SIGKILL` (the
+default) or `SIGTERM` to every process of the unit at once, its main and control process and every
+other process in its control group (`systemctl kill --signal=<signal> --kill-whom=all`), then reads
+the unit every 100 ms until it is at rest or about to restart, for at most `timeoutMs` (integer
+milliseconds from 1 to 600000, default 30000). Use it where a `stop()` would wait out the unit's
+`TimeoutStopSec=`, such as a unit whose stop already failed or overran; it does not run `ExecStop=`,
+does not cancel or await a pending job, and never starts, enables, unmasks or resets the unit. It
+resolves a frozen `{ outcome, state }`, where `state` is the snapshot that decided the outcome (for
+`timeout`, the last one read):
+
+| `outcome` | Meaning |
+| --- | --- |
+| `'stopped'`, `'failed'` | `systemdUnitQuiescence()`'s `rest`: no main or control process and no control group. A unit whose main process is gone while its control group still holds processes resolves only once the group is gone. A unit already at rest is signalled all the same (nothing receives it) and resolves at the first read |
+| `'auto-restart'` | SubState `auto-restart`, or `auto-restart-queued` (systemd 254), without a main or control process: the unit waits for its `Restart=` timer or its queued restart. Its control group is not read here: with `RestartMode=direct` the manager keeps the emptied group |
+| `'restarted'` | the manager began a new invocation (`InvocationID`) before a read saw the unit at rest: a restart delay shorter than the poll interval, or another client's start |
+| `'timeout'` | none of these within `timeoutMs`; a read begun before the deadline is still awaited, each bounded by `commandTimeoutMs` |
+
+A unit whose `LoadState` is not `loaded` in the read before the signal (`not-found`, `masked`,
+`bad-setting`, `error`, ...) is refused with `command_failed` before any signal: that read makes the
+manager load the unit object, and the manager may signal an improperly loaded unit, so such a unit
+would otherwise resolve `stopped`. A refused signal and a `systemctl kill` that exceeded
+`commandTimeoutMs` reject with `command_failed` too; after a timed-out call the signal may have been
+sent, so inspect the unit. Once the manager accepted the signal, a failed read rejects with
+`signalled_uninspected` and that read's error as `cause`. `signalled_uninspected` is a new member of
+`SystemdUnitError['code']`: a consumer with an exhaustive `never` switch over the code must add a
+case for it. `kill()` needs systemd 252 or later, the first whose `systemctl` takes
+`--kill-whom=`: it reads the manager's version first and refuses an older manager with
+`SystemdUnitManagerTooOldError`, an unreadable version with `version_unknown` and an unanswered read
+with `command_failed`, each before any signal. A signal other than `'SIGKILL'` or `'SIGTERM'` and an
+option other than `timeoutMs` reject with `invalid_options` before any command runs.
+
+```typescript
+const killed = await unit.kill('SIGKILL', { timeoutMs: 30_000 });
+if (killed.outcome === 'timeout') {
+  console.log('still running', killed.state.activeState, killed.state.controlGroup);
+} else if (killed.outcome !== 'restarted') {
+  await unit.start();
+}
+```
+
+After an `auto-restart` outcome the start job stays queued until the unit's `RestartSec=` elapses,
+so `start()` waits for it; a long `RestartSec=` can exceed `commandTimeoutMs`.
+
 `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
@@ -1398,7 +1455,8 @@ WantedBy=multi-user.target
 
 ### Permission Denied Errors
 
-If you encounter "Interactive authentication required" errors:
+If an operation rejects with a `SmartDaemonCommandError` whose `stderr` reports that sudo needs a
+password or a terminal (for example "a terminal is required to read the password"):
 
 1. **Option 1**: Run your application with sudo
    ```bash

package/ts/00_commitinfo_data.ts

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

package/ts/classes.systemdunit.ts

@@ -12,6 +12,7 @@ import {
   type ISystemdManagerVersion,
   fileDescriptorStoreCleanMajor,
   fileDescriptorStorePreserveMajor,
+  killWhomMajor,
   managerVersionArguments,
   parseManagerVersion,
 } from './systemd.managerversion.js';
@@ -127,6 +128,49 @@ export interface ISystemdUnitJobOptions {
   wait?: boolean;
 }
 
+/** The signals `SystemdUnit.kill()` sends. */
+export type TSystemdUnitKillSignal = 'SIGKILL' | 'SIGTERM';
+
+/** `SystemdUnit.kill()` options. */
+export interface ISystemdUnitKillOptions {
+  /**
+   * How long to wait, after the manager accepted the signal, for the unit to come to rest: integer
+   * milliseconds from 1 to 600000. Defaults to 30000. A read begun before the deadline is still
+   * awaited; each read is bounded by `commandTimeoutMs`.
+   */
+  timeoutMs?: number;
+}
+
+/**
+ * How the unit stood when `SystemdUnit.kill()` stopped waiting. `stopped` and `failed` are
+ * `systemdUnitQuiescence()`'s `rest`: no main or control process and no control group.
+ * `auto-restart`: SubState `auto-restart` or `auto-restart-queued` (systemd 254) without a main or
+ * control process, waiting for its `Restart=` timer or its queued restart job. `restarted`: the
+ * manager started a new invocation of the unit (a restart delay shorter than the poll interval, or
+ * another client's start) before a read saw it at rest. `timeout`: none of these within `timeoutMs`.
+ */
+export type TSystemdUnitKillOutcome = 'stopped' | 'failed' | 'auto-restart' | 'restarted' | 'timeout';
+
+export interface ISystemdUnitKillResult {
+  readonly outcome: TSystemdUnitKillOutcome;
+  /** The snapshot that decided `outcome`; for `timeout`, the last one read before the deadline. */
+  readonly state: ISystemdUnitState;
+}
+
+/** Interval between the snapshots `kill()` reads while it waits. */
+const killPollIntervalMs = 100;
+
+/** Reads the outcome a kill has reached from one snapshot, or null while it has reached none. */
+const killOutcome = (state: ISystemdUnitState, newInvocation: boolean): TSystemdUnitKillOutcome | null => {
+  const { rest } = systemdUnitQuiescence(state);
+  if (rest !== null) return rest;
+  // In auto-restart the manager may keep the unit's (empty) control group: with RestartMode=direct
+  // the unit never passes the inactive state that releases it, so ControlGroup is not read here.
+  if (state.mainPid === 0 && state.controlPid === 0 &&
+    (state.subState === 'auto-restart' || state.subState === 'auto-restart-queued')) return 'auto-restart';
+  return newInvocation ? 'restarted' : null;
+};
+
 export interface ISystemdUnitConfigurationState {
   readonly unitName: string;
   readonly fragmentPath: string;
@@ -232,12 +276,15 @@ export class SystemdUnitError extends Error {
      * `version_unknown`: the manager answered, but its `Version` property is not one this package
      * reads, so a call that needs a minimum manager version refuses.
      * `manager_too_old`: always a `SystemdUnitManagerTooOldError`, naming both versions.
+     * `signalled_uninspected`: only `kill()`. The manager accepted the signal, and a snapshot read
+     * while waiting failed; `cause` is that inspection's error.
      */
     public readonly code:
       | 'invalid_options'
       | 'command_failed'
       | 'invalid_state'
       | 'released_uninspected'
+      | 'signalled_uninspected'
       | 'version_unknown'
       | 'manager_too_old',
     options?: ErrorOptions,
@@ -480,10 +527,18 @@ export class SystemdUnit {
 
   /** Snapshot only. Callers own application-specific admission and restart policy. */
   public async inspect(): Promise<ISystemdUnitState> {
+    return (await this.readState(properties)).state;
+  }
+
+  /**
+   * Reads one snapshot with `keys`: the snapshot properties, optionally followed by `InvocationID`,
+   * which is empty for a unit never started and otherwise 32 lowercase hex digits.
+   */
+  private async readState(keys: readonly string[]): Promise<{ state: ISystemdUnitState; invocationId: string }> {
     const stdout = await this.command([
       'show',
       this.unitName,
-      `--property=${properties.join(',')}`,
+      `--property=${keys.join(',')}`,
       '--all',
     ]);
     const fields = new Map<string, string>();
@@ -491,13 +546,14 @@ export class SystemdUnit {
     for (const line of (stdout.endsWith('\n') ? stdout.slice(0, -1) : stdout).split('\n')) {
       const separator = line.indexOf('=');
       const key = line.slice(0, separator);
-      if (separator < 1 || !(properties as readonly string[]).includes(key) || fields.has(key)) {
+      if (separator < 1 || !keys.includes(key) || fields.has(key)) {
         throw new SystemdUnitError('invalid_state');
       }
       fields.set(key, line.slice(separator + 1));
     }
     if (
-      fields.size !== properties.length || fields.get('Id') !== this.unitName ||
+      fields.size !== keys.length || fields.get('Id') !== this.unitName ||
+      (keys.includes('InvocationID') && !/^(?:[0-9a-f]{32})?$/.test(fields.get('InvocationID') ?? '')) ||
       ['LoadState', 'ActiveState', 'SubState'].some((key) => !fields.get(key)) ||
       !/^[a-z][a-z-]{0,31}$/.test(fields.get('Result')!) ||
       ['MainPID', 'ControlPID', 'NFileDescriptorStore'].some((key) =>
@@ -506,7 +562,7 @@ export class SystemdUnit {
       // systemd prints the store's unsigned 32-bit count in decimal.
       Number(fields.get('NFileDescriptorStore')) > 4294967295
     ) throw new SystemdUnitError('invalid_state');
-    return Object.freeze({
+    const state: ISystemdUnitState = Object.freeze({
       unitName: this.unitName,
       loadState: fields.get('LoadState')!,
       activeState: fields.get('ActiveState')!,
@@ -521,6 +577,7 @@ export class SystemdUnit {
       result: fields.get('Result')!,
       fileDescriptorStoreCount: Number(fields.get('NFileDescriptorStore')),
     });
+    return { state, invocationId: fields.get('InvocationID') ?? '' };
   }
 
   /**
@@ -585,6 +642,65 @@ export class SystemdUnit {
     return this.inspect();
   }
 
+  /**
+   * Sends `signal` (default `SIGKILL`) to every process of the unit at once, its main and control
+   * process and every other process in its control group (`systemctl kill --signal=<signal>
+   * --kill-whom=all`), then waits, bounded by `timeoutMs`, until the unit is at rest or about to
+   * restart, and resolves with the outcome and the snapshot that decided it. It does not queue a
+   * stop job and does not wait out `TimeoutStopSec=`; a pending job is neither cancelled nor
+   * awaited. It never starts, enables, unmasks or resets the unit.
+   *
+   * A unit already at rest is signalled all the same (nothing receives it) and resolves at the first
+   * read. A unit whose main process is gone while its control group still holds processes resolves
+   * only once the group is gone. A unit whose `LoadState` in the read before the signal is not
+   * `loaded` (`not-found`, `masked`, `bad-setting`, `error`, ...) is refused with `command_failed`
+   * before any signal, as are a refused signal and a `systemctl` call that exceeded
+   * `commandTimeoutMs`; after a timed-out call the signal may have been sent, so inspect the unit. Once the manager accepted the signal, a failed read
+   * rejects with `signalled_uninspected` and that read's error as `cause`.
+   *
+   * Needs systemd 252 or later, the first whose `systemctl` takes `--kill-whom=`: the manager's
+   * version is read first, and an older manager is refused with `SystemdUnitManagerTooOldError`, an
+   * unreadable version with `version_unknown` and an unanswered read with `command_failed`, each
+   * before any signal. A malformed signal or option rejects with `invalid_options` before any command.
+   */
+  public async kill(
+    signalArg: TSystemdUnitKillSignal = 'SIGKILL',
+    optionsArg?: ISystemdUnitKillOptions,
+  ): Promise<ISystemdUnitKillResult> {
+    if (
+      (signalArg !== 'SIGKILL' && signalArg !== 'SIGTERM') ||
+      (optionsArg !== undefined && (
+        typeof optionsArg !== 'object' || optionsArg === null ||
+        Object.keys(optionsArg).some((key) => key !== 'timeoutMs') ||
+        (optionsArg.timeoutMs !== undefined && (!Number.isSafeInteger(optionsArg.timeoutMs) ||
+          optionsArg.timeoutMs < 1 || optionsArg.timeoutMs > 600000))
+      ))
+    ) throw new SystemdUnitError('invalid_options');
+    const timeoutMs = optionsArg?.timeoutMs ?? 30000;
+    await this.requireManagerVersion(killWhomMajor);
+    const killKeys = [...properties, 'InvocationID'];
+    // The invocation before the signal, so a restart the wait could not observe at rest is reported.
+    const { state: before, invocationId } = await this.readState(killKeys);
+    // That read makes the manager load the unit object, and the manager may signal a unit it could
+    // not load properly; such a unit has no processes of its own to end, so it is refused here.
+    if (before.loadState !== 'loaded') throw new SystemdUnitError('command_failed');
+    await this.command(['kill', `--signal=${signalArg}`, '--kill-whom=all', this.unitName]);
+    const deadline = performance.now() + timeoutMs;
+    for (;;) {
+      let read: { state: ISystemdUnitState; invocationId: string };
+      try {
+        read = await this.readState(killKeys);
+      } catch (error) {
+        throw new SystemdUnitError('signalled_uninspected', { cause: error });
+      }
+      const outcome = killOutcome(read.state, read.invocationId !== invocationId);
+      if (outcome !== null) return Object.freeze({ outcome, state: read.state });
+      const remaining = deadline - performance.now();
+      if (remaining <= 0) return Object.freeze({ outcome: 'timeout', state: read.state });
+      await plugins.timers.setTimeout(Math.min(killPollIntervalMs, remaining));
+    }
+  }
+
   /** Reports the manager's selected definition without reading or changing its contents. */
   public async inspectConfiguration(): Promise<ISystemdUnitConfigurationState> {
     const keys = ['Id', 'FragmentPath', 'DropInPaths', 'NeedDaemonReload'];

package/ts/index.ts

@@ -4,3 +4,4 @@ export * from './classes.systemdunit.js';
 export * from './classes.systemdservicedefinition.js';
 export * from './classes.systemdunitfile.js';
 export * from './classes.systemdtransientscope.js';
+export * from './smartdaemon.classes.commanderror.js';

package/ts/smartdaemon.classes.commanderror.ts

@@ -0,0 +1,23 @@
+/**
+ * A privileged command run by `SmartDaemon` (through `systemdManager.execute()`) did not exit 0.
+ * The exit status alone decides failure; `stderr` carries what the command or sudo reported.
+ */
+export class SmartDaemonCommandError extends Error {
+  constructor(
+    /** The command as run, including any `sudo` prefix. It never contains the sudo password. */
+    public readonly command: string,
+    /** The exit code; `1` when a signal ended the command. */
+    public readonly exitCode: number,
+    /** The signal that ended the command, if one did. */
+    public readonly signal: NodeJS.Signals | undefined,
+    /** The command's standard error, as captured. */
+    public readonly stderr: string,
+    /** `cause`: the stdin write error when sudo exited before reading the password. */
+    options?: ErrorOptions,
+  ) {
+    const reason = signal ? `was terminated by signal ${signal}` : `exited with code ${exitCode}`;
+    const detail = stderr.trim();
+    super(`Command "${command}" ${reason}${detail ? `: ${detail}` : '.'}`, options);
+    this.name = 'SmartDaemonCommandError';
+  }
+}