manageos 2.3.2 → 2.3.4

package/packages/windows/src/camera.ts

@@ -0,0 +1,229 @@
+import NodeWebcam from "node-webcam";
+import { exec, execSync } from "child_process";
+import util from "util";
+import deasync from "deasync";
+
+type WebcamOptions = Record<string, any>;
+const execAsync = util.promisify(exec);
+
+interface DriverInfo {
+  Status?: string;
+  Class?: string;
+  FriendlyName?: string;
+  InstanceId?: string;
+  Description?: string;
+}
+
+interface CameraInfo {
+  name: string;
+  device: string;
+  resolution?: string;
+  driver?: DriverInfo | DriverInfo[];
+}
+
+class Sync {
+  static captureMultiple(
+    baseFileName: string,
+    count: number,
+    options?: WebcamOptions
+  ): string[] {
+    const results: string[] = [];
+    for (let i = 0; i < count; i++) {
+      const fileName = `${baseFileName}_${i}.jpg`;
+      results.push(this.capture(fileName, options) as string);
+    }
+    return results;
+  }
+
+  static getCameraResolution(name: string): string {
+    try {
+      const stdout = execSync(
+        `powershell -Command "Get-CimInstance -Namespace root\\CIMV2 -ClassName Win32_PnPEntity | Where-Object { $_.Name -like '*${name}*' } | Select-Object -ExpandProperty Caption"`,
+        { encoding: "utf8" }
+      );
+      return stdout.trim() || "Unknown";
+    } catch (err) {
+      return "Unknown";
+    }
+  }
+
+  static checkCameraStatus(name: string): boolean {
+    try {
+      const stdout = execSync(
+        `powershell -Command "Get-PnpDevice | Where-Object { $_.FriendlyName -like '*${name}*' -and $_.Class -eq 'Camera' } | Select-Object Status | ConvertTo-Json"`,
+        { encoding: "utf8" }
+      );
+      const parsed = JSON.parse(stdout);
+      return parsed.Status === "OK";
+    } catch (err) {
+      return false;
+    }
+  }
+
+  static capture(fileName: string, options?: WebcamOptions): string | Buffer {
+    let result: string | Buffer = "";
+    let done = false;
+
+    const Webcam = NodeWebcam.create(options || {});
+    Webcam.capture(fileName, (err, data) => {
+      if (err) {
+        result = "";
+      } else {
+        result = data;
+      }
+      done = true;
+    });
+
+    deasync.loopWhile(() => !done);
+    return result;
+  }
+
+  static listCameras(): CameraInfo[] {
+    let result: CameraInfo[] = [];
+    let done = false;
+
+    NodeWebcam.list((list) => {
+      if (!list || list.length === 0) {
+        done = true;
+        return;
+      }
+
+      const cameraDetails: CameraInfo[] = [];
+
+      list.forEach((cam) => {
+        let resolution = "Unknown";
+        let driver: DriverInfo | DriverInfo[] = [];
+
+        if (process.platform === "win32") {
+          try {
+            const stdout = execSync(
+              `powershell -Command "Get-PnpDevice | Where-Object { $_.Class -eq 'Camera' } | Select-Object Status,Class,FriendlyName,InstanceId,Description | ConvertTo-Json -Compress"`,
+              { encoding: "utf8" }
+            );
+            if (stdout && stdout.trim().length > 0) {
+              try {
+                const parsed = JSON.parse(stdout);
+                driver = Array.isArray(parsed) ? parsed : [parsed];
+              } catch (jsonErr) {}
+            }
+          } catch (err) {}
+        }
+
+        cameraDetails.push({
+          name: cam,
+          device: cam,
+          resolution,
+          driver,
+        });
+      });
+
+      result = cameraDetails;
+      done = true;
+    });
+
+    deasync.loopWhile(() => !done);
+    return result;
+  }
+}
+
+class Async {
+  static async captureMultiple(
+    baseFileName: string,
+    count: number,
+    options?: WebcamOptions
+  ): Promise<string[]> {
+    const results: string[] = [];
+    for (let i = 0; i < count; i++) {
+      const fileName = `${baseFileName}_${i}.jpg`;
+      await this.capture(fileName, options);
+      results.push(fileName);
+    }
+    return results;
+  }
+
+  static async getCameraResolution(name: string): Promise<string> {
+    try {
+      const { stdout } = await execAsync(
+        `powershell -Command "Get-CimInstance -Namespace root\\CIMV2 -ClassName Win32_PnPEntity | Where-Object { $_.Name -like '*${name}*' } | Select-Object -ExpandProperty Caption"`
+      );
+      return stdout.trim() || "Unknown";
+    } catch (err) {
+      return "Unknown";
+    }
+  }
+
+  static async checkCameraStatus(name: string): Promise<boolean> {
+    try {
+      const { stdout } = await execAsync(
+        `powershell -Command "Get-PnpDevice | Where-Object { $_.FriendlyName -like '*${name}*' -and $_.Class -eq 'Camera' } | Select-Object Status | ConvertTo-Json"`
+      );
+      const parsed = JSON.parse(stdout);
+      return parsed.Status === "OK";
+    } catch (err) {
+      return false;
+    }
+  }
+
+  static capture(
+    fileName: string,
+    options?: WebcamOptions
+  ): Promise<string | Buffer> {
+    return new Promise((resolve, reject) => {
+      const Webcam = NodeWebcam.create(options || {});
+      Webcam.capture(fileName, (err, data) => {
+        if (err) reject(err);
+        else resolve(data);
+      });
+    });
+  }
+
+  static async listCameras(): Promise<CameraInfo[]> {
+    return new Promise((resolve, reject) => {
+      NodeWebcam.list(async (list) => {
+        if (!list || list.length === 0) {
+          reject(new Error("No se pudieron listar cámaras"));
+          return;
+        }
+
+        const cameraDetails: CameraInfo[] = [];
+
+        for (const cam of list) {
+          let resolution = "Unknown";
+          let driver: DriverInfo | DriverInfo[] = [];
+
+          try {
+            if (process.platform === "win32") {
+              const { stdout } = await execAsync(
+                `powershell -Command ` +
+                  `"Get-PnpDevice | Where-Object { $_.Class -eq 'Camera' } | ` +
+                  `Select-Object Status,Class,FriendlyName,InstanceId,Description | ` +
+                  `ConvertTo-Json -Compress"`
+              );
+
+              if (stdout && stdout.trim().length > 0) {
+                try {
+                  const parsed = JSON.parse(stdout);
+                  driver = Array.isArray(parsed) ? parsed : [parsed];
+                } catch (jsonErr) {}
+              }
+            }
+          } catch (err) {}
+
+          cameraDetails.push({
+            name: cam,
+            device: cam,
+            resolution,
+            driver,
+          });
+        }
+
+        resolve(cameraDetails);
+      });
+    });
+  }
+}
+
+export default class Camera {
+  public static readonly Sync = Sync;
+  public static readonly Async = Async;
+}

package/packages/windows/src/certificates.ts

@@ -0,0 +1,154 @@
+import { exec, execSync } from "child_process";
+
+class Async {
+  static open(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec("certmgr.msc", (error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
+  static list(store: string = "My"): Promise<string> {
+    return new Promise((resolve, reject) => {
+      exec(`certutil -store ${store}`, (error, stdout) => {
+        if (error) reject(error);
+        else resolve(stdout.trim());
+      });
+    });
+  }
+
+  static export(
+    certName: string,
+    outputPath: string,
+    store: string = "My"
+  ): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const cmd = `certutil -exportPFX ${store} "${certName}" "${outputPath}"`;
+      exec(cmd, (error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
+  static import(filePath: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec(`certutil -importPFX "${filePath}"`, (error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
+  static delete(certName: string, store: string = "My"): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec(`certutil -delstore ${store} "${certName}"`, (error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
+  static dump(filePath: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+      exec(`certutil -dump "${filePath}"`, (error, stdout) => {
+        if (error) reject(error);
+        else resolve(stdout.trim());
+      });
+    });
+  }
+
+  static verify(filePath: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+      exec(`certutil -verify "${filePath}"`, (error, stdout) => {
+        if (error) reject(error);
+        else resolve(stdout.trim());
+      });
+    });
+  }
+
+  static view(filePath: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec(`certutil -viewstore "${filePath}"`, (error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
+  static renew(certName: string, store: string = "My"): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec(`certreq -new "${certName}" "${store}"`, (error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
+  static generateSelfSigned(
+    subject: string,
+    outputPath: string
+  ): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const cmd = `powershell -Command "New-SelfSignedCertificate -Subject '${subject}' -CertStoreLocation 'Cert:\\CurrentUser\\My'; Export-Certificate -Cert (Get-ChildItem Cert:\\CurrentUser\\My | where {$_.Subject -like '*${subject}*'}) -FilePath '${outputPath}'"`;
+      exec(cmd, (error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+}
+
+class Sync {
+  static open(): void {
+    execSync("certmgr.msc");
+  }
+
+  static list(store: string = "My"): string {
+    return execSync(`certutil -store ${store}`).toString().trim();
+  }
+
+  static export(
+    certName: string,
+    outputPath: string,
+    store: string = "My"
+  ): void {
+    execSync(`certutil -exportPFX ${store} "${certName}" "${outputPath}"`);
+  }
+
+  static import(filePath: string): void {
+    execSync(`certutil -importPFX "${filePath}"`);
+  }
+
+  static delete(certName: string, store: string = "My"): void {
+    execSync(`certutil -delstore ${store} "${certName}"`);
+  }
+
+  static dump(filePath: string): string {
+    return execSync(`certutil -dump "${filePath}"`).toString().trim();
+  }
+
+  static verify(filePath: string): string {
+    return execSync(`certutil -verify "${filePath}"`).toString().trim();
+  }
+
+  static view(filePath: string): void {
+    execSync(`certutil -viewstore "${filePath}"`);
+  }
+
+  static renew(certName: string, store: string = "My"): void {
+    execSync(`certreq -new "${certName}" "${store}"`);
+  }
+
+  static generateSelfSigned(subject: string, outputPath: string): void {
+    const cmd = `powershell -Command "New-SelfSignedCertificate -Subject '${subject}' -CertStoreLocation 'Cert:\\CurrentUser\\My'; Export-Certificate -Cert (Get-ChildItem Cert:\\CurrentUser\\My | where {$_.Subject -like '*${subject}*'}) -FilePath '${outputPath}'"`;
+    execSync(cmd);
+  }
+}
+
+export default class Certificates {
+  public static readonly Sync = Sync;
+  public static readonly Async = Async;
+}

package/packages/windows/src/clipboard.ts

@@ -0,0 +1,52 @@
+import clipboardy from "clipboardy";
+
+class Sync {
+  static read(): string | unknown {
+    try {
+      return clipboardy.readSync();
+    } catch (error) {
+      return error;
+    }
+  }
+
+  static write(text: string): boolean | unknown {
+    try {
+      clipboardy.writeSync(text);
+      return true;
+    } catch (error) {
+      return error;
+    }
+  }
+
+  static clear(): boolean | unknown {
+    return this.write("");
+  }
+}
+
+class Async {
+  static async read(): Promise<string | unknown> {
+    try {
+      return await clipboardy.read();
+    } catch (error) {
+      return error;
+    }
+  }
+
+  static async write(text: string): Promise<boolean | unknown> {
+    try {
+      await clipboardy.write(text);
+      return true;
+    } catch (error) {
+      return error;
+    }
+  }
+
+  static async clear(): Promise<boolean | unknown> {
+    return await this.write("");
+  }
+}
+
+export default class Clipboard {
+  public static readonly Sync = Sync;
+  public static readonly Async = Async;
+}

package/packages/windows/src/encryption.ts

@@ -0,0 +1,56 @@
+import crypto from "crypto";
+import fs from "fs";
+
+export default class Encryption {
+  private static algorithm: string = "aes-256-cbc";
+  private static key: Buffer;
+  private static iv: Buffer;
+
+  static init(key: string, iv?: Buffer) {
+    if (!key || key.length < 32) {
+      throw new Error("La clave debe tener al menos 32 caracteres");
+    }
+    this.key = Buffer.from(key.slice(0, 32));
+    this.iv = iv || crypto.randomBytes(16);
+  }
+
+  static encrypt(text: string): { iv: string; encryptedData: string } {
+    if (!this.key) throw new Error("Encryption key no inicializada");
+
+    const cipher = crypto.createCipheriv(this.algorithm, this.key, this.iv);
+    let encrypted = cipher.update(text, "utf8", "hex");
+    encrypted += cipher.final("hex");
+
+    return {
+      iv: this.iv.toString("hex"),
+      encryptedData: encrypted,
+    };
+  }
+
+  static decrypt(encryptedData: string, ivHex: string): string {
+    if (!this.key) throw new Error("Encryption key no inicializada");
+
+    const iv = Buffer.from(ivHex, "hex");
+    const decipher = crypto.createDecipheriv(this.algorithm, this.key, iv);
+    let decrypted = decipher.update(encryptedData, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+
+    return decrypted;
+  }
+
+  static hash(data: string, algorithm: string = "sha256"): string {
+    return crypto.createHash(algorithm).update(data).digest("hex");
+  }
+
+  static generateKey(length: number = 32): string {
+    return crypto.randomBytes(length).toString("hex");
+  }
+
+  static saveKeyToFile(path: string, key: string) {
+    fs.writeFileSync(path, key, { encoding: "utf8" });
+  }
+
+  static loadKeyFromFile(path: string): string {
+    return fs.readFileSync(path, { encoding: "utf8" });
+  }
+}

package/packages/windows/src/eventlogs.ts

@@ -0,0 +1,179 @@
+import { exec, execSync } from "child_process";
+import * as fs from "fs";
+
+type EventLogEntry = {
+  index?: number;
+  timeGenerated?: string;
+  entryType?: string;
+  source?: string;
+  message?: string;
+};
+
+type EventLogResult = {
+  success: boolean;
+  error?: string;
+  output?: string;
+  data?: EventLogEntry[];
+};
+
+type FilterOptions = {
+  since?: Date;
+  until?: Date;
+  entryType?: string;
+  source?: string;
+};
+
+class EventLogsParser {
+  static parse(output: string): EventLogEntry[] {
+    const entries: EventLogEntry[] = [];
+    const lines = output.split(/\r?\n/);
+
+    let current: EventLogEntry | null = null;
+    let lastField: keyof EventLogEntry | null = null;
+
+    for (let line of lines) {
+      line = line.trim();
+      if (!line) continue;
+
+      const indexMatch = line.match(/^Index\s*:\s*(\d+)/i);
+      if (indexMatch) {
+        if (current) entries.push(current);
+        current = { index: parseInt(indexMatch[1], 10) };
+        lastField = null;
+        continue;
+      }
+
+      if (!current) continue;
+
+      const fieldMatch = line.match(/^(\w+)\s*:\s*(.*)$/);
+      if (fieldMatch) {
+        const key = fieldMatch[1].toLowerCase();
+        const value = fieldMatch[2].trim();
+
+        switch (key) {
+          case "timegenerated":
+            current.timeGenerated = value;
+            lastField = "timeGenerated";
+            break;
+          case "entrytype":
+            current.entryType = value;
+            lastField = "entryType";
+            break;
+          case "source":
+            current.source = value;
+            lastField = "source";
+            break;
+          case "message":
+            current.message = value;
+            lastField = "message";
+            break;
+          default:
+            lastField = null;
+            break;
+        }
+      } else {
+        if (lastField && lastField === "message") {
+          current.message += "\n" + line;
+        }
+      }
+    }
+
+    if (current) entries.push(current);
+    return entries;
+  }
+}
+
+class Async {
+  static list(
+    logName: string = "System",
+    maxEvents: number = 50
+  ): Promise<EventLogResult> {
+    return new Promise((resolve) => {
+      const command = `powershell -Command "Get-EventLog -LogName '${logName}' -Newest ${maxEvents} | Format-List Index,TimeGenerated,EntryType,Source,Message"`;
+
+      exec(command, { encoding: "utf-8" }, (err, stdout, stderr) => {
+        if (err) {
+          return resolve({ success: false, error: stderr || err.message });
+        }
+        const data = EventLogsParser.parse(stdout);
+        resolve({ success: true, output: stdout, data });
+      });
+    });
+  }
+
+  static listSystemEvents(maxEvents = 50) {
+    return Async.list("System", maxEvents);
+  }
+
+  static listApplicationEvents(maxEvents = 50) {
+    return Async.list("Application", maxEvents);
+  }
+
+  static listSecurityEvents(maxEvents = 50) {
+    return Async.list("Security", maxEvents);
+  }
+
+  static watch(
+    logName: string = "System",
+    callback: (entry: EventLogEntry) => void
+  ) {
+    const command = `powershell -Command "Get-WinEvent -LogName '${logName}' -MaxEvents 1 -Wait | Format-List"`;
+    const child = exec(command);
+    child.stdout?.on("data", (chunk) => {
+      const entries = EventLogsParser.parse(chunk);
+      if (entries.length) callback(entries[0]);
+    });
+  }
+}
+
+class Sync {
+  static list(
+    logName: string = "System",
+    maxEvents: number = 50
+  ): EventLogResult {
+    try {
+      const command = `powershell -Command "Get-EventLog -LogName '${logName}' -Newest ${maxEvents} | Format-List Index,TimeGenerated,EntryType,Source,Message"`;
+      const output = execSync(command, { encoding: "utf-8" });
+      const data = EventLogsParser.parse(output);
+      return { success: true, output, data };
+    } catch (error: any) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  static listSystemEvents(maxEvents = 50) {
+    return Sync.list("System", maxEvents);
+  }
+
+  static listApplicationEvents(maxEvents = 50) {
+    return Sync.list("Application", maxEvents);
+  }
+
+  static listSecurityEvents(maxEvents = 50) {
+    return Sync.list("Security", maxEvents);
+  }
+}
+
+export default class EventLogs {
+  public static readonly Sync = Sync;
+  public static readonly Async = Async;
+
+  static exportToJson(data: EventLogEntry[], path: string) {
+    fs.writeFileSync(path, JSON.stringify(data, null, 2));
+  }
+
+  static exportToCsv(data: EventLogEntry[], path: string) {
+    const csv = data.map(
+      (e) =>
+        `"${e.index}","${e.timeGenerated}","${e.entryType}","${
+          e.source
+        }","${e.message?.replace(/\n/g, " ")}"`
+    );
+    fs.writeFileSync(
+      path,
+      `"Index","TimeGenerated","EntryType","Source","Message"\n${csv.join(
+        "\n"
+      )}`
+    );
+  }
+}