manageos 2.3.2 → 2.3.5

package/packages/windows/src/microphone.ts

@@ -0,0 +1,132 @@
+import fs from "fs";
+import NodeMic from "node-mic";
+import deasync from "deasync";
+
+type MicrophoneOptions = {
+  rate?: number;
+  channels?: number;
+  threshold?: number;
+  endian?: "big" | "little";
+  bitwidth?: number;
+  encoding?: "signed-integer" | "unsigned-integer";
+  device?: string;
+  fileType?: "raw" | "wav";
+  debug?: boolean;
+};
+
+interface MicrophoneStatus {
+  recording: boolean;
+  paused: boolean;
+  stopped: boolean;
+}
+
+class Async {
+  private static micInstance: any = null;
+  private static micStream: any = null;
+  private static status: MicrophoneStatus = {
+    recording: false,
+    paused: false,
+    stopped: true,
+  };
+
+  static start(
+    options?: MicrophoneOptions,
+    outputFile: string = "output.raw"
+  ): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        this.micInstance = new NodeMic(options || {});
+        this.micStream = this.micInstance.getAudioStream();
+        const outputFileStream = fs.createWriteStream(outputFile);
+        this.micStream.pipe(outputFileStream);
+
+        this.micStream.on("data", (data: Buffer) => {
+          // console.log("Audio data length:", data.length);
+        });
+
+        this.micStream.on("error", (err: Error) => {
+          console.error("Error:", err.message);
+        });
+
+        this.micStream.on("started", () => {
+          this.status.recording = true;
+          this.status.paused = false;
+          this.status.stopped = false;
+        });
+
+        this.micStream.on("paused", () => {
+          this.status.paused = true;
+          this.status.recording = false;
+        });
+
+        this.micStream.on("unpaused", () => {
+          this.status.paused = false;
+          this.status.recording = true;
+        });
+
+        this.micStream.on("stopped", () => {
+          this.status.stopped = true;
+          this.status.recording = false;
+          this.status.paused = false;
+        });
+
+        this.micInstance.start();
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  static pause(): void {
+    if (this.micInstance) this.micInstance.pause();
+  }
+
+  static resume(): void {
+    if (this.micInstance) this.micInstance.resume();
+  }
+
+  static stop(): void {
+    if (this.micInstance) this.micInstance.stop();
+  }
+
+  static getStatus(): MicrophoneStatus {
+    return this.status;
+  }
+}
+
+class Sync {
+  static start(
+    options?: MicrophoneOptions,
+    outputFile: string = "output.raw"
+  ): void {
+    let done = false;
+    Async.start(options, outputFile)
+      .then(() => (done = true))
+      .catch((err) => {
+        throw err;
+      });
+    deasync.loopWhile(() => !done);
+  }
+
+  static pause(): void {
+    Async.pause();
+  }
+
+  static resume(): void {
+    Async.resume();
+  }
+
+  static stop(): void {
+    Async.stop();
+  }
+
+  static getStatus(): MicrophoneStatus {
+    return Async.getStatus();
+  }
+}
+
+export default class Microphone {
+  public static readonly Async = Async;
+  public static readonly Sync = Sync;
+}

package/packages/windows/src/msconfig.ts

@@ -0,0 +1,233 @@
+import { exec, execSync } from "child_process";
+
+class Async {
+  static open(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec("start msconfig", (error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
+  static listStartupApps(): Promise<string[]> {
+    return new Promise((resolve, reject) => {
+      exec(
+        'reg query "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run"',
+        { encoding: "utf8" },
+        (error, stdout) => {
+          if (error) reject(error);
+          else {
+            const lines = stdout
+              .split("\n")
+              .filter((line) => line.trim() !== "");
+            resolve(lines);
+          }
+        }
+      );
+    });
+  }
+
+  static addStartupApp(name: string, path: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec(
+        `reg add "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v "${name}" /t REG_SZ /d "${path}" /f`,
+        (error) => {
+          if (error) reject(error);
+          else resolve();
+        }
+      );
+    });
+  }
+
+  static removeStartupApp(name: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec(
+        `reg delete "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v "${name}" /f`,
+        (error) => {
+          if (error) reject(error);
+          else resolve();
+        }
+      );
+    });
+  }
+
+  static checkStartupApp(name: string): Promise<boolean> {
+    return new Promise((resolve) => {
+      exec(
+        `reg query "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v "${name}"`,
+        (error) => resolve(!error)
+      );
+    });
+  }
+
+  static getStartupAppPath(name: string): Promise<string | null> {
+    return new Promise((resolve) => {
+      exec(
+        `reg query "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v "${name}"`,
+        { encoding: "utf8" },
+        (error, stdout) => {
+          if (error) return resolve(null);
+          const match = stdout.match(/REG_SZ\s+(.+)/);
+          resolve(match ? match[1].trim() : null);
+        }
+      );
+    });
+  }
+
+  static backupStartupApps(filePath: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec(
+        `reg export "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" "${filePath}" /y`,
+        (error) => (error ? reject(error) : resolve())
+      );
+    });
+  }
+
+  static restoreStartupApps(filePath: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec(`reg import "${filePath}"`, (error) =>
+        error ? reject(error) : resolve()
+      );
+    });
+  }
+
+  static clearStartupApps(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec(
+        `reg delete "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /f`,
+        (error) => (error ? reject(error) : resolve())
+      );
+    });
+  }
+
+  static restartMsconfig(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec("taskkill /f /im msconfig.exe && start msconfig", (error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
+  static closeMsconfig(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec("taskkill /f /im msconfig.exe", (error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+}
+
+class Sync {
+  static open(): void {
+    execSync("start msconfig");
+  }
+
+  static listStartupApps(): string[] {
+    try {
+      const output = execSync(
+        'reg query "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run"',
+        { encoding: "utf8" }
+      );
+      return output.split("\n").filter((line) => line.trim() !== "");
+    } catch (error) {
+      console.error("Error listando apps de inicio:", error);
+      return [];
+    }
+  }
+
+  static addStartupApp(name: string, path: string): void {
+    try {
+      execSync(
+        `reg add "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v "${name}" /t REG_SZ /d "${path}" /f`
+      );
+    } catch (error) {
+      console.error("Error agregando app al inicio:", error);
+    }
+  }
+
+  static removeStartupApp(name: string): void {
+    try {
+      execSync(
+        `reg delete "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v "${name}" /f`
+      );
+    } catch (error) {
+      console.error("Error eliminando app del inicio:", error);
+    }
+  }
+
+  static checkStartupApp(name: string): boolean {
+    try {
+      execSync(
+        `reg query "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v "${name}"`
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  static getStartupAppPath(name: string): string | null {
+    try {
+      const output = execSync(
+        `reg query "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v "${name}"`,
+        { encoding: "utf8" }
+      );
+      const match = output.match(/REG_SZ\s+(.+)/);
+      return match ? match[1].trim() : null;
+    } catch {
+      return null;
+    }
+  }
+
+  static backupStartupApps(filePath: string): void {
+    try {
+      execSync(
+        `reg export "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" "${filePath}" /y`
+      );
+    } catch (error) {
+      console.error("Error haciendo backup:", error);
+    }
+  }
+
+  static restoreStartupApps(filePath: string): void {
+    try {
+      execSync(`reg import "${filePath}"`);
+    } catch (error) {
+      console.error("Error restaurando backup:", error);
+    }
+  }
+
+  static clearStartupApps(): void {
+    try {
+      execSync(
+        `reg delete "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /f`
+      );
+    } catch (error) {
+      console.error("Error limpiando apps de inicio:", error);
+    }
+  }
+
+  static restartMsconfig(): void {
+    try {
+      execSync("taskkill /f /im msconfig.exe && start msconfig");
+    } catch (error) {
+      console.error("Error reiniciando msconfig:", error);
+    }
+  }
+
+  static closeMsconfig(): void {
+    try {
+      execSync("taskkill /f /im msconfig.exe");
+    } catch (error) {
+      console.error("Error cerrando msconfig:", error);
+    }
+  }
+}
+
+export default class Msconfig {
+  public static readonly Sync = Sync;
+  public static readonly Async = Async;
+}