manageos 2.3.2 → 2.3.4

package/packages/windows/src/filesystem.ts

@@ -0,0 +1,166 @@
+import { exec, execSync } from "child_process";
+import path from "path";
+
+interface FileInfo {
+  name: string;
+  path: string;
+  size: string;
+  isDirectory: boolean;
+}
+
+class Sync {
+  static createFile(filePath: string, content = ""): boolean | unknown {
+    try {
+      execSync(`echo ${content} > "${filePath}"`);
+      return true;
+    } catch (e) {
+      return e;
+    }
+  }
+
+  static currentPath(): string {
+    return __dirname;
+  }
+  static listDirectory(dirPath: string): FileInfo[] {
+    try {
+      const stdout = execSync(`dir "${dirPath}" /B`, { encoding: "utf8" });
+      const files = stdout
+        .trim()
+        .split("\n")
+        .map((name) => ({
+          name: name.trim(),
+          path: path.join(dirPath, name.trim()),
+          size: "",
+          isDirectory: false,
+        }));
+      return files;
+    } catch (error) {
+      return [];
+    }
+  }
+
+  static readFile(filePath: string): string {
+    try {
+      const content = execSync(`type "${filePath}"`, { encoding: "utf8" });
+      return content;
+    } catch (error) {
+      return "";
+    }
+  }
+
+  static deleteFile(filePath: string, force = false): boolean | unknown {
+    try {
+      execSync(`del ${force ? "/F" : ""} "${filePath}"`);
+      return true;
+    } catch (e) {
+      return e;
+    }
+  }
+
+  static createDirectory(dirPath: string): boolean | unknown {
+    try {
+      execSync(`mkdir "${dirPath}"`);
+      return true;
+    } catch (e) {
+      return e;
+    }
+  }
+
+  static deleteDirectory(dirPath: string, force = false): boolean | unknown {
+    try {
+      execSync(`rmdir ${force ? "/S /Q" : ""} "${dirPath}"`);
+      return true;
+    } catch (e) {
+      return e;
+    }
+  }
+}
+
+class Async {
+  static currentPath(): string {
+    return __dirname;
+  }
+  static createFile(
+    filePath: string,
+    content = ""
+  ): Promise<boolean | unknown> {
+    return new Promise((resolve) => {
+      exec(`echo ${content} > "${filePath}"`, (err) => {
+        if (err) resolve(err);
+        else resolve(true);
+      });
+    });
+  }
+
+  static listDirectory(dirPath: string): Promise<FileInfo[]> {
+    return new Promise((resolve, reject) => {
+      exec(`dir "${dirPath}" /B`, (err, stdout) => {
+        if (err) return reject(err);
+        const files = stdout
+          .trim()
+          .split("\n")
+          .map((name) => ({
+            name: name.trim(),
+            path: path.join(dirPath, name.trim()),
+            size: "",
+            isDirectory: false,
+          }));
+
+        resolve(files);
+      });
+    });
+  }
+
+  static readFile(filePath: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+      exec(`type "${filePath}"`, (err, stdout) => {
+        if (err) return reject(err);
+        resolve(stdout);
+      });
+    });
+  }
+
+  static deleteFile(
+    filePath: string,
+    force = false
+  ): Promise<boolean | unknown> {
+    return new Promise((resolve) => {
+      exec(`del ${force ? "/F" : ""} "${filePath}"`, (err) => {
+        if (err) resolve(err);
+        else {
+          resolve(true);
+        }
+      });
+    });
+  }
+
+  static createDirectory(dirPath: string): Promise<boolean | unknown> {
+    return new Promise((resolve) => {
+      exec(`mkdir "${dirPath}"`, (err) => {
+        if (err) resolve(err);
+        else {
+          resolve(true);
+        }
+      });
+    });
+  }
+
+  static deleteDirectory(
+    dirPath: string,
+    force = false
+  ): Promise<boolean | unknown> {
+    return new Promise((resolve) => {
+      exec(`rmdir ${force ? "/S /Q" : ""} "${dirPath}"`, (err) => {
+        if (err) resolve(err);
+        else {
+          resolve(true);
+        }
+      });
+    });
+  }
+}
+
+export default class FileSystem {
+  static readonly async = Async;
+  static readonly sync = Sync;
+}

package/packages/windows/src/firewall.ts

@@ -0,0 +1,143 @@
+import { exec, execSync } from "child_process";
+
+type Rule = {
+  name: string;
+  direction?: "Inbound" | "Outbound";
+  action?: "Allow" | "Block";
+  protocol?: "TCP" | "UDP" | "Any";
+  localPort?: number | string;
+  remoteAddress?: string;
+};
+
+type FirewallResult = {
+  success: boolean;
+  error?: string;
+};
+
+type ListRulesResult = {
+  success: boolean;
+  rules?: string[];
+  error?: string;
+};
+
+class Async {
+  private static runCommand(cmd: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec(`powershell -Command "${cmd}"`, (error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
+  static async addRule(rule: Rule): Promise<FirewallResult> {
+    try {
+      const parts: string[] = [
+        `-DisplayName "${rule.name}"`,
+        `-Direction ${rule.direction || "Inbound"}`,
+        `-Action ${rule.action || "Allow"}`,
+      ];
+
+      if (rule.protocol) parts.push(`-Protocol ${rule.protocol}`);
+      if (rule.localPort) parts.push(`-LocalPort ${rule.localPort}`);
+      if (rule.remoteAddress)
+        parts.push(`-RemoteAddress ${rule.remoteAddress}`);
+
+      const cmd = `New-NetFirewallRule ${parts.join(" ")}`;
+      await this.runCommand(cmd);
+
+      return { success: true };
+    } catch (error: any) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  static async removeRule(name: string): Promise<FirewallResult> {
+    try {
+      const cmd = `Remove-NetFirewallRule -DisplayName "${name}"`;
+      await this.runCommand(cmd);
+      return { success: true };
+    } catch (error: any) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  static async listRules(): Promise<ListRulesResult> {
+    return new Promise((resolve) => {
+      exec(
+        `powershell -Command "Get-NetFirewallRule | Select-Object -ExpandProperty DisplayName"`,
+        { encoding: "utf-8" },
+        (error, stdout) => {
+          if (error) {
+            resolve({ success: false, error: error.message });
+            return;
+          }
+          const rules = stdout
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line);
+          resolve({ success: true, rules });
+        }
+      );
+    });
+  }
+}
+
+class Sync {
+  private static runCommand(cmd: string): void {
+    execSync(`powershell -Command "${cmd}"`, { stdio: "ignore" });
+  }
+
+  static addRule(rule: Rule): FirewallResult {
+    try {
+      const parts: string[] = [
+        `-DisplayName "${rule.name}"`,
+        `-Direction ${rule.direction || "Inbound"}`,
+        `-Action ${rule.action || "Allow"}`,
+      ];
+
+      if (rule.protocol) parts.push(`-Protocol ${rule.protocol}`);
+      if (rule.localPort) parts.push(`-LocalPort ${rule.localPort}`);
+      if (rule.remoteAddress)
+        parts.push(`-RemoteAddress ${rule.remoteAddress}`);
+
+      const cmd = `New-NetFirewallRule ${parts.join(" ")}`;
+      this.runCommand(cmd);
+
+      return { success: true };
+    } catch (error: any) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  static removeRule(name: string): FirewallResult {
+    try {
+      const cmd = `Remove-NetFirewallRule -DisplayName "${name}"`;
+      this.runCommand(cmd);
+      return { success: true };
+    } catch (error: any) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  static listRules(): { success: boolean; rules?: string[]; error?: string } {
+    try {
+      const output = execSync(
+        `powershell -Command "Get-NetFirewallRule | Select-Object -ExpandProperty DisplayName"`,
+        { encoding: "utf-8" }
+      );
+      const rules = output
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line);
+      return { success: true, rules };
+    } catch (error: any) {
+      return { success: false, error: error.message };
+    }
+  }
+}
+
+export default class Firewall {
+  public static readonly Sync = Sync;
+  public static readonly Async = Async;
+}

package/packages/windows/src/index.ts

@@ -0,0 +1,77 @@
+import Antivirus from "./antivirus";
+import Audio from "./audio";
+import BitLocker from "./bitlocker";
+import Clipboard from "./clipboard";
+import Camera from "./camera";
+import Encryption from "./encryption";
+import EventLogs from "./eventlogs";
+import FileSystem from "./filesystem";
+import Firewall from "./firewall";
+import Localization from "./localization";
+import Microphone from "./microphone";
+import Network from "./network";
+import Notification from "./notification";
+import Power from "./power";
+import Printer from "./printer";
+import Regedit from "./regedit";
+import Scheduler from "./scheduler";
+import Screen from "./screen";
+import Services from "./services";
+import SystemInfo from "./systeminfo";
+import TaskScheduler from "./taskscheduler";
+import Taskmgr from "./taskmgr";
+import UAC from "./uac";
+import Users from "./users";
+import USB from "./usb";
+import WindowsUpdate from "./windowsupdate";
+import Android from "./Android";
+import SecPol from "./secpol";
+import Msconfig from "./msconfig";
+import AuditPolicy from "./auditpolicy";
+import Certificates from "./certificates";
+import Shell from "./shell";
+import PsExec from "./PsExec";
+import Mouse from "./Mouse";
+import Keyboard from "./Keyboard";
+import Startup from "./startup";
+import Server from "./Server";
+
+export default class Windows {
+  static readonly Android = Android;
+  static readonly Antivirus = Antivirus;
+  static readonly Audio = Audio;
+  static readonly AuditPolicy = AuditPolicy;
+  static readonly Bitlocker = BitLocker;
+  static readonly Clipboard = Clipboard;
+  static readonly Certificates = Certificates;
+  static readonly Camera = Camera;
+  static readonly Encryption = Encryption;
+  static readonly EventLogs = EventLogs;
+  static readonly FileSystem = FileSystem;
+  static readonly Firewall = Firewall;
+  static readonly Localization = Localization;
+  static readonly Network = Network;
+  static readonly Notification = Notification;
+  static readonly Power = Power;
+  static readonly Printer = Printer;
+  static readonly Regedit = Regedit;
+  static readonly SecPol = SecPol;
+  static readonly Scheduler = Scheduler;
+  static readonly Screen = Screen;
+  static readonly Services = Services;
+  static readonly SystemInfo = SystemInfo;
+  static readonly Shell = Shell;
+  static readonly Taskmgr = Taskmgr;
+  static readonly TaskScheduler = TaskScheduler;
+  static readonly UAC = UAC;
+  static readonly USB = USB;
+  static readonly Users = Users;
+  static readonly WindowsUpdate = WindowsUpdate;
+  static readonly Msconfig = Msconfig;
+  static readonly Microphone = Microphone;
+  static readonly PsExec = PsExec;
+  static readonly Mouse = Mouse;
+  static readonly Keyboard = Keyboard;
+  static readonly Startup = Startup;
+  static readonly Server = Server;
+}

package/packages/windows/src/joystick.ts

@@ -0,0 +1,87 @@
+import HID from "node-hid";
+
+export interface JoystickDevice {
+  vendorId: number;
+  productId: number;
+  path: string;
+  product: string;
+  usagePage?: number;
+  usage?: number;
+}
+
+export type JoystickDataCallback = (data: Buffer) => void;
+
+class Async {
+  static scan(): Promise<JoystickDevice[]> {
+    return new Promise((resolve) => {
+      const devices = HID.devices();
+      const joysticks = devices.filter(
+        (d) => d.usagePage === 1 || d.usagePage === 5
+      ) as JoystickDevice[];
+      resolve(joysticks);
+    });
+  }
+
+  static listen(
+    deviceInfo: JoystickDevice,
+    callback: JoystickDataCallback
+  ): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        const joystick = new HID.HID(deviceInfo.path);
+        joystick.on("data", callback);
+        joystick.on("error", (err) => reject(err));
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  static sendInput(
+    deviceInfo: JoystickDevice,
+    inputData: number[]
+  ): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        const joystick = new HID.HID(deviceInfo.path);
+        joystick.write(inputData);
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+}
+
+class Sync {
+  static scan(): JoystickDevice[] {
+    const devices = HID.devices();
+    return devices.filter(
+      (d) => d.usagePage === 1 || d.usagePage === 5
+    ) as JoystickDevice[];
+  }
+
+  static listen(
+    deviceInfo: JoystickDevice,
+    callback: JoystickDataCallback
+  ): void {
+    try {
+      const joystick = new HID.HID(deviceInfo.path);
+      joystick.on("data", callback);
+      joystick.on("error", () => {});
+    } catch (err) {}
+  }
+
+  static sendInput(deviceInfo: JoystickDevice, inputData: number[]): void {
+    try {
+      const joystick = new HID.HID(deviceInfo.path);
+      joystick.write(inputData);
+    } catch (err) {}
+  }
+}
+
+export default class Joystick {
+  public static readonly Sync = Sync;
+  public static readonly Async = Async;
+}

package/packages/windows/src/localization.ts

@@ -0,0 +1,133 @@
+import { exec, execSync } from "child_process";
+
+class Async {
+  static getSystemLocale(): Promise<string> {
+    return new Promise((resolve, reject) => {
+      exec(
+        'powershell -Command "Get-WinSystemLocale | Select-Object -ExpandProperty Name"',
+        (error, stdout) => {
+          if (error) reject(error);
+          else resolve(stdout.trim());
+        }
+      );
+    });
+  }
+
+  static getDisplayLanguage(): Promise<string> {
+    return new Promise((resolve, reject) => {
+      exec(
+        'powershell -Command "[System.Globalization.CultureInfo]::InstalledUICulture.Name"',
+        (error, stdout) => {
+          if (error) reject(error);
+          else resolve(stdout.trim());
+        }
+      );
+    });
+  }
+
+  static setSystemLocale(locale: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec(
+        `powershell -Command "Set-WinSystemLocale -SystemLocale ${locale}"`,
+        (error) => {
+          if (error) reject(error);
+          else resolve();
+        }
+      );
+    });
+  }
+
+  static getTimeZone(): Promise<string> {
+    return new Promise((resolve, reject) => {
+      exec(
+        'powershell -Command "Get-TimeZone | Select-Object -ExpandProperty Id"',
+        (error, stdout) => {
+          if (error) reject(error);
+          else resolve(stdout.trim());
+        }
+      );
+    });
+  }
+
+  static setTimeZone(timeZoneId: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec(
+        `powershell -Command "Set-TimeZone -Id '${timeZoneId}'"`,
+        (error) => {
+          if (error) reject(error);
+          else resolve();
+        }
+      );
+    });
+  }
+
+  static listTimeZones(): Promise<string[]> {
+    return new Promise((resolve, reject) => {
+      exec(
+        'powershell -Command "Get-TimeZone -ListAvailable | Select-Object -ExpandProperty Id"',
+        (error, stdout) => {
+          if (error) reject(error);
+          else {
+            resolve(
+              stdout
+                .split(/\r?\n/)
+                .map((tz) => tz.trim())
+                .filter(Boolean)
+            );
+          }
+        }
+      );
+    });
+  }
+}
+
+class Sync {
+  static getSystemLocale(): string {
+    return execSync(
+      'powershell -Command "Get-WinSystemLocale | Select-Object -ExpandProperty Name"'
+    )
+      .toString()
+      .trim();
+  }
+
+  static getDisplayLanguage(): string {
+    return execSync(
+      'powershell -Command "[System.Globalization.CultureInfo]::InstalledUICulture.Name"'
+    )
+      .toString()
+      .trim();
+  }
+
+  static setSystemLocale(locale: string): void {
+    execSync(
+      `powershell -Command "Set-WinSystemLocale -SystemLocale ${locale}"`
+    );
+  }
+
+  static getTimeZone(): string {
+    return execSync(
+      'powershell -Command "Get-TimeZone | Select-Object -ExpandProperty Id"'
+    )
+      .toString()
+      .trim();
+  }
+
+  static setTimeZone(timeZoneId: string): void {
+    execSync(`powershell -Command "Set-TimeZone -Id '${timeZoneId}'"`);
+  }
+
+  static listTimeZones(): string[] {
+    return execSync(
+      'powershell -Command "Get-TimeZone -ListAvailable | Select-Object -ExpandProperty Id"'
+    )
+      .toString()
+      .split(/\r?\n/)
+      .map((tz) => tz.trim())
+      .filter(Boolean);
+  }
+}
+
+export default class Localization {
+  public static readonly Sync = Sync;
+  public static readonly Async = Async;
+}