@push.rocks/smartdaemon 2.22.0 → 3.1.0

package/ts/smartdaemon.classes.systemdmanager.ts

@@ -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 {
   type ISmartDaemonServiceConstructorOptions,
   SmartDaemonService,
@@ -31,8 +32,10 @@ export class SmartDaemonSystemdManager {
   public smartFs: plugins.smartfs.SmartFs;
 
   public shouldExecute: boolean = false;
+  /** Whether this process runs as root; set by the first privileged operation's check. */
   public isRoot: boolean = false;
   public sudoPassword?: string;
+  private rootStatus?: Promise<void>;
 
   constructor(smartdaemonRefArg: SmartDaemon, sudoPasswordArg?: string) {
     this.smartdaemonRef = smartdaemonRefArg;
@@ -41,14 +44,6 @@ 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.');
-      }
-    });
   }
 
   private async checkIsRoot(): Promise<boolean> {
@@ -56,6 +51,23 @@ export class SmartDaemonSystemdManager {
     return result.stdout.trim() === '0';
   }
 
+  /** Checks once whether this process runs as root and sets `isRoot`; later calls reuse that check. */
+  private ensureRootStatus(): Promise<void> {
+    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;
+  }
+
   public async checkElegibility() {
     if (plugins.os.platform() === 'linux') {
       this.shouldExecute = true;
@@ -66,31 +78,61 @@ export class SmartDaemonSystemdManager {
     return this.shouldExecute;
   }
 
-  public async execute(commandArg: string) {
-    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;
-      }
+  /**
+   * 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.
+   */
+  public async execute(commandArg: string): Promise<plugins.smartshell.IExecResult | undefined> {
+    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: unknown;
+    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;
+  }
+
+  private async runChecked(commandArg: string): Promise<plugins.smartshell.IExecResult> {
+    const result = await this.smartshellInstance.exec(commandArg);
+    this.assertSucceeded(commandArg, result);
+    return result;
+  }
+
+  private assertSucceeded(
+    commandArg: string,
+    resultArg: plugins.smartshell.IExecResult,
+    causeArg?: unknown,
+  ): void {
+    if (resultArg.exitCode === 0 && !resultArg.signal) {
+      return;
     }
+    throw new SmartDaemonCommandError(
+      commandArg,
+      resultArg.exitCode,
+      resultArg.signal,
+      resultArg.stderr,
+      causeArg === undefined ? undefined : { cause: causeArg },
+    );
   }
 
   /**
@@ -136,7 +178,8 @@ 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);
@@ -153,7 +196,8 @@ export class SmartDaemonSystemdManager {
   public async deleteService(serviceArg: SmartDaemonService) {
     if (await this.checkElegibility()) {
       const filePath = SmartDaemonSystemdManager.createFilePathFromServiceName(serviceArg.name);
-      
+
+      await this.ensureRootStatus();
       if (this.isRoot) {
         await this.smartFs.file(filePath).delete();
       } else {

package/ts/smartdaemon.plugins.ts

@@ -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';
+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 };
 
 // @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';
@@ -22,8 +21,6 @@ import * as smartshell from '@push.rocks/smartshell';
 export {
   lik,
   smartfs,
-  smartlog,
-  smartlogDestinationLocal,
   smartmarkdown,
   smartpath,
   smartshell,

package/ts/systemd.managerversion.ts

@@ -19,6 +19,9 @@ 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.

package/dist_ts/smartdamon.logging.d.ts

@@ -1,2 +0,0 @@
-import * as plugins from './smartdaemon.plugins.js';
-export declare const logger: plugins.smartlog.Smartlog;

package/dist_ts/smartdamon.logging.js

@@ -1,14 +0,0 @@
-import * as plugins from './smartdaemon.plugins.js';
-export const logger = new plugins.smartlog.Smartlog({
-    logContext: {
-        company: 'Some Company',
-        companyunit: 'Some CompanyUnit',
-        containerName: 'Some Containername',
-        environment: 'local',
-        runtime: 'node',
-        zone: 'gitzone',
-    },
-    minimumLogLevel: 'silly',
-});
-logger.addLogDestination(new plugins.smartlogDestinationLocal.DestinationLocal());
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRkYW1vbi5sb2dnaW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRkYW1vbi5sb2dnaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sMEJBQTBCLENBQUM7QUFFcEQsTUFBTSxDQUFDLE1BQU0sTUFBTSxHQUFHLElBQUksT0FBTyxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUM7SUFDbEQsVUFBVSxFQUFFO1FBQ1YsT0FBTyxFQUFFLGNBQWM7UUFDdkIsV0FBVyxFQUFFLGtCQUFrQjtRQUMvQixhQUFhLEVBQUUsb0JBQW9CO1FBQ25DLFdBQVcsRUFBRSxPQUFPO1FBQ3BCLE9BQU8sRUFBRSxNQUFNO1FBQ2YsSUFBSSxFQUFFLFNBQVM7S0FDaEI7SUFDRCxlQUFlLEVBQUUsT0FBTztDQUN6QixDQUFDLENBQUM7QUFFSCxNQUFNLENBQUMsaUJBQWlCLENBQUMsSUFBSSxPQUFPLENBQUMsd0JBQXdCLENBQUMsZ0JBQWdCLEVBQUUsQ0FBQyxDQUFDIn0=

package/ts/smartdamon.logging.ts

@@ -1,15 +0,0 @@
-import * as plugins from './smartdaemon.plugins.js';
-
-export const logger = new plugins.smartlog.Smartlog({
-  logContext: {
-    company: 'Some Company',
-    companyunit: 'Some CompanyUnit',
-    containerName: 'Some Containername',
-    environment: 'local',
-    runtime: 'node',
-    zone: 'gitzone',
-  },
-  minimumLogLevel: 'silly',
-});
-
-logger.addLogDestination(new plugins.smartlogDestinationLocal.DestinationLocal());