@oneuptime/common 8.0.5466 → 8.0.5479

package/Server/Utils/Execute.ts

@@ -1,26 +1,86 @@
 import { PromiseRejectErrorFunction } from "../../Types/FunctionTypes";
-import { ExecException, exec } from "node:child_process";
+import {
+  ExecException,
+  ExecOptions,
+  exec,
+  execFile,
+} from "node:child_process";
 import logger from "./Logger";
 import CaptureSpan from "./Telemetry/CaptureSpan";
 
 export default class Execute {
   @CaptureSpan()
-  public static executeCommand(command: string): Promise<string> {
+  public static executeCommand(
+    command: string,
+    options?: ExecOptions,
+  ): Promise<string> {
     return new Promise(
       (
         resolve: (output: string) => void,
         reject: PromiseRejectErrorFunction,
       ) => {
-        exec(`${command}`, (err: ExecException | null, stdout: string) => {
+        exec(
+          `${command}`,
+          {
+            ...options,
+          },
+          (err: ExecException | null, stdout: string, stderr: string) => {
           if (err) {
             logger.error(`Error executing command: ${command}`);
             logger.error(err);
             logger.error(stdout);
+              if (stderr) {
+                logger.error(stderr);
+              }
             return reject(err);
           }
 
+            if (stderr) {
+              logger.debug(stderr);
+            }
+
           return resolve(stdout);
-        });
+          },
+        );
+      },
+    );
+  }
+
+  @CaptureSpan()
+  public static executeCommandFile(data: {
+    command: string;
+    args: Array<string>;
+    cwd: string;
+  }): Promise<string> {
+    return new Promise(
+      (
+        resolve: (output: string) => void,
+        reject: PromiseRejectErrorFunction,
+      ) => {
+        execFile(
+          data.command,
+          data.args,
+          {
+            cwd: data.cwd,
+          },
+          (err: ExecException | null, stdout: string, stderr: string) => {
+            if (err) {
+              logger.error(
+                `Error executing command: ${data.command} ${data.args.join(" ")}`,
+              );
+              logger.error(err);
+              logger.error(stdout);
+              logger.error(stderr);
+              return reject(err);
+            }
+
+            if (stderr) {
+              logger.debug(stderr);
+            }
+
+            return resolve(stdout);
+          },
+        );
       },
     );
   }

package/Server/Utils/LocalFile.ts

@@ -71,6 +71,46 @@ export default class LocalFile {
     );
   }
 
+  @CaptureSpan()
+  public static async deleteDirectory(path: string): Promise<void> {
+    if ((await this.doesDirectoryExist(path)) === false) {
+      return;
+    }
+
+    return new Promise(
+      (resolve: VoidFunction, reject: PromiseRejectErrorFunction) => {
+        fs.rm(path, { recursive: true, force: true }, (err: Error | null) => {
+          if (err) {
+            return reject(err);
+          }
+          resolve();
+        });
+      },
+    );
+  }
+
+  @CaptureSpan()
+  public static async readDirectory(path: string): Promise<Array<fs.Dirent>> {
+    return new Promise(
+      (
+        resolve: (entries: Array<fs.Dirent>) => void,
+        reject: PromiseRejectErrorFunction,
+      ) => {
+        fs.readdir(
+          path,
+          { withFileTypes: true },
+          (err: Error | null, entries: Array<fs.Dirent>) => {
+            if (err) {
+              return reject(err);
+            }
+
+            resolve(entries);
+          },
+        );
+      },
+    );
+  }
+
   @CaptureSpan()
   public static async getListOfDirectories(path: string): Promise<string[]> {
     return new Promise(