manageos 2.3.2 → 2.3.4

package/packages/windows/src/Mouse/index.ts

@@ -0,0 +1,173 @@
+import { exec, execSync } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const mouseExe = path.join(__dirname, "mouse.exe");
+
+function parseJSON(stdout: string) {
+  try {
+    return JSON.parse(stdout);
+  } catch (e) {
+    throw new Error("Invalid JSON from mouse.exe");
+  }
+}
+
+class Async {
+  static move(x: number, y: number): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      exec(`"${mouseExe}" move ${x} ${y}`, (error, stdout) => {
+        if (error) return reject(error);
+        const result = parseJSON(stdout);
+        resolve(result.success || false);
+      });
+    });
+  }
+
+  static click(button: "left" | "right" = "left"): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      exec(`"${mouseExe}" click ${button}`, (error, stdout) => {
+        if (error) return reject(error);
+        const result = parseJSON(stdout);
+        resolve(result.success || false);
+      });
+    });
+  }
+
+  static doubleClick(): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      exec(`"${mouseExe}" doubleclick`, (error, stdout) => {
+        if (error) return reject(error);
+        const result = parseJSON(stdout);
+        resolve(result.success || false);
+      });
+    });
+  }
+
+  static position(): Promise<{ x: number; y: number }> {
+    return new Promise((resolve, reject) => {
+      exec(`"${mouseExe}" position`, (error, stdout) => {
+        if (error) return reject(error);
+        const result = parseJSON(stdout);
+        if (result.position && Array.isArray(result.position)) {
+          resolve({ x: result.position[0], y: result.position[1] });
+        } else {
+          reject(new Error("Invalid position format"));
+        }
+      });
+    });
+  }
+
+  static speed(value: number): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      exec(`"${mouseExe}" speed ${value}`, (error, stdout) => {
+        if (error) return reject(error);
+        const result = parseJSON(stdout);
+        resolve(result.success || false);
+      });
+    });
+  }
+
+  static getButtonState(): Promise<{ left: boolean; right: boolean }> {
+    return new Promise((resolve, reject) => {
+      exec(`"${mouseExe}" getbuttonstate`, (error, stdout) => {
+        if (error) return reject(error);
+        const result = parseJSON(stdout);
+        if (result.buttons && Array.isArray(result.buttons)) {
+          resolve({
+            left: result.buttons[0].left === 1,
+            right: result.buttons[1].right === 1,
+          });
+        } else {
+          reject(new Error("Invalid button state format"));
+        }
+      });
+    });
+  }
+
+  static hide(): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      exec(`"${mouseExe}" hide`, (error, stdout) => {
+        if (error) return reject(error);
+        const result = parseJSON(stdout);
+        resolve(result.success || false);
+      });
+    });
+  }
+
+  static show(): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      exec(`"${mouseExe}" show`, (error, stdout) => {
+        if (error) return reject(error);
+        const result = parseJSON(stdout);
+        resolve(result.success || false);
+      });
+    });
+  }
+}
+
+class Sync {
+  static move(x: number, y: number): boolean {
+    const stdout = execSync(`"${mouseExe}" move ${x} ${y}`).toString();
+    const result = parseJSON(stdout);
+    return result.success || false;
+  }
+
+  static click(button: "left" | "right" = "left"): boolean {
+    const stdout = execSync(`"${mouseExe}" click ${button}`).toString();
+    const result = parseJSON(stdout);
+    return result.success || false;
+  }
+
+  static doubleClick(): boolean {
+    const stdout = execSync(`"${mouseExe}" doubleclick`).toString();
+    const result = parseJSON(stdout);
+    return result.success || false;
+  }
+
+  static position(): { x: number; y: number } {
+    const stdout = execSync(`"${mouseExe}" position`).toString();
+    const result = parseJSON(stdout);
+    if (result.position && Array.isArray(result.position)) {
+      return { x: result.position[0], y: result.position[1] };
+    }
+    throw new Error("Invalid position format");
+  }
+
+  static speed(value: number): boolean {
+    const stdout = execSync(`"${mouseExe}" speed ${value}`).toString();
+    const result = parseJSON(stdout);
+    return result.success || false;
+  }
+
+  static getButtonState(): { left: boolean; right: boolean } {
+    const stdout = execSync(`"${mouseExe}" getbuttonstate`).toString();
+    const result = parseJSON(stdout);
+    if (result.buttons && Array.isArray(result.buttons)) {
+      return {
+        left: result.buttons[0].left === 1,
+        right: result.buttons[1].right === 1,
+      };
+    }
+    throw new Error("Invalid button state format");
+  }
+
+  static hide(): boolean {
+    const stdout = execSync(`"${mouseExe}" hide`).toString();
+    const result = parseJSON(stdout);
+    return result.success || false;
+  }
+
+  static show(): boolean {
+    const stdout = execSync(`"${mouseExe}" show`).toString();
+    const result = parseJSON(stdout);
+    return result.success || false;
+  }
+}
+
+export default class Mouse {
+  public static readonly Async = Async;
+  public static readonly Sync = Sync;
+}

package/packages/windows/src/Mouse/mouse.c

@@ -0,0 +1,239 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <windows.h>
+
+void output_json(const char *key, const char *value)
+{
+    printf("{\"%s\":%s}\n", key, value);
+}
+
+void output_json_bool(const char *key, int bool_value)
+{
+    printf("{\"%s\":%s}\n", key, bool_value ? "true" : "false");
+}
+
+void output_json_int(const char *key, int int_value)
+{
+    printf("{\"%s\":%d}\n", key, int_value);
+}
+
+void output_json_array(const char *key, int a, int b)
+{
+    printf("{\"%s\":[%d,%d]}\n", key, a, b);
+}
+
+int move_mouse(int x, int y)
+{
+    return SetCursorPos(x, y);
+}
+
+int click_mouse(const char *button)
+{
+    if (strcmp(button, "left") == 0)
+    {
+        mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
+        mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
+        return 1;
+    }
+    else if (strcmp(button, "right") == 0)
+    {
+        mouse_event(MOUSEEVENTF_RIGHTDOWN, 0, 0, 0, 0);
+        mouse_event(MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0);
+        return 1;
+    }
+    return 0;
+}
+
+int double_click()
+{
+    click_mouse("left");
+    Sleep(50);
+    click_mouse("left");
+    return 1;
+}
+
+int drag_mouse(int startX, int startY, int endX, int endY)
+{
+    SetCursorPos(startX, startY);
+    mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
+    Sleep(100);
+    SetCursorPos(endX, endY);
+    Sleep(100);
+    mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
+    return 1;
+}
+
+int scroll_mouse(int amount)
+{
+    mouse_event(MOUSEEVENTF_WHEEL, 0, 0, amount, 0);
+    return 1;
+}
+
+int get_position()
+{
+    POINT p;
+    if (GetCursorPos(&p))
+    {
+        output_json_array("position", p.x, p.y);
+        return 1;
+    }
+    return 0;
+}
+
+int track_position()
+{
+    POINT p;
+    printf("[");
+    while (1)
+    {
+        if (GetCursorPos(&p))
+        {
+            printf("[%d,%d],", p.x, p.y);
+            fflush(stdout);
+        }
+        Sleep(100);
+    }
+    printf("]");
+    return 1;
+}
+
+int set_speed(int speed)
+{
+    return SystemParametersInfo(SPI_SETMOUSESPEED, 0, (PVOID)(LONG_PTR)speed, 0);
+}
+
+int hide_cursor()
+{
+    while (ShowCursor(FALSE) >= 0)
+        ;
+    return 1;
+}
+
+int show_cursor()
+{
+    while (ShowCursor(TRUE) < 0)
+        ;
+    return 1;
+}
+
+int middle_click()
+{
+    mouse_event(MOUSEEVENTF_MIDDLEDOWN, 0, 0, 0, 0);
+    mouse_event(MOUSEEVENTF_MIDDLEUP, 0, 0, 0, 0);
+    return 1;
+}
+
+int click_down(const char *button)
+{
+    if (strcmp(button, "left") == 0)
+        mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
+    else if (strcmp(button, "right") == 0)
+        mouse_event(MOUSEEVENTF_RIGHTDOWN, 0, 0, 0, 0);
+    else
+        return 0;
+    return 1;
+}
+
+int click_up(const char *button)
+{
+    if (strcmp(button, "left") == 0)
+        mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
+    else if (strcmp(button, "right") == 0)
+        mouse_event(MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0);
+    else
+        return 0;
+    return 1;
+}
+
+int swap_buttons()
+{
+    return SwapMouseButton(TRUE);
+}
+
+int restore_buttons()
+{
+    return SwapMouseButton(FALSE);
+}
+
+int get_button_state()
+{
+    int left = GetAsyncKeyState(VK_LBUTTON) & 0x8000 ? 1 : 0;
+    int right = GetAsyncKeyState(VK_RBUTTON) & 0x8000 ? 1 : 0;
+    printf("{\"buttons\":[{\"left\":%d},{\"right\":%d}]}\n", left, right);
+    return 1;
+}
+
+int enable_mouse()
+{
+    BlockInput(FALSE);
+    return 1;
+}
+
+int disable_mouse()
+{
+    BlockInput(TRUE);
+    return 1;
+}
+
+int repeat_click(const char *button, int count)
+{
+    for (int i = 0; i < count; i++)
+    {
+        click_mouse(button);
+        Sleep(100);
+    }
+    return 1;
+}
+
+int main(int argc, char *argv[])
+{
+    if (argc < 2)
+    {
+        output_json_bool("error", 1);
+        return 1;
+    }
+
+    if (strcmp(argv[1], "move") == 0 && argc == 4)
+        output_json_bool("success", move_mouse(atoi(argv[2]), atoi(argv[3])));
+    else if (strcmp(argv[1], "click") == 0 && argc == 3)
+        output_json_bool("success", click_mouse(argv[2]));
+    else if (strcmp(argv[1], "doubleclick") == 0)
+        output_json_bool("success", double_click());
+    else if (strcmp(argv[1], "drag") == 0 && argc == 6)
+        output_json_bool("success", drag_mouse(atoi(argv[2]), atoi(argv[3]), atoi(argv[4]), atoi(argv[5])));
+    else if (strcmp(argv[1], "scroll") == 0 && argc == 3)
+        output_json_bool("success", scroll_mouse(atoi(argv[2])));
+    else if (strcmp(argv[1], "position") == 0)
+        get_position();
+    else if (strcmp(argv[1], "track") == 0)
+        track_position();
+    else if (strcmp(argv[1], "speed") == 0 && argc == 3)
+        output_json_bool("success", set_speed(atoi(argv[2])));
+    else if (strcmp(argv[1], "hide") == 0)
+        output_json_bool("success", hide_cursor());
+    else if (strcmp(argv[1], "show") == 0)
+        output_json_bool("success", show_cursor());
+    else if (strcmp(argv[1], "middleclick") == 0)
+        output_json_bool("success", middle_click());
+    else if (strcmp(argv[1], "clickdown") == 0 && argc == 3)
+        output_json_bool("success", click_down(argv[2]));
+    else if (strcmp(argv[1], "clickup") == 0 && argc == 3)
+        output_json_bool("success", click_up(argv[2]));
+    else if (strcmp(argv[1], "swapbuttons") == 0)
+        output_json_bool("success", swap_buttons());
+    else if (strcmp(argv[1], "restorebuttons") == 0)
+        output_json_bool("success", restore_buttons());
+    else if (strcmp(argv[1], "getbuttonstate") == 0)
+        get_button_state();
+    else if (strcmp(argv[1], "enablemouse") == 0)
+        output_json_bool("success", enable_mouse());
+    else if (strcmp(argv[1], "disablemouse") == 0)
+        output_json_bool("success", disable_mouse());
+    else if (strcmp(argv[1], "repeatclick") == 0 && argc == 4)
+        output_json_bool("success", repeat_click(argv[2], atoi(argv[3])));
+    else
+        output_json_bool("error", 1);
+
+    return 0;
+}

package/packages/windows/src/PsExec/index.ts

@@ -0,0 +1,11 @@
+import PSExec from "./psexec";
+import PsFile from "./psfile";
+import PsGetSid from "./psgetsid";
+import PsInfo from "./psinfo";
+
+export default class PsExec {
+  public static readonly PsExec = PSExec;
+  public static readonly PsFile = PsFile;
+  public static readonly PsGetSid = PsGetSid;
+  public static readonly PsInfo = PsInfo;
+}

package/packages/windows/src/PsExec/psexec.ts

@@ -0,0 +1,129 @@
+import { spawn, spawnSync } from "child_process";
+import { fileURLToPath } from "url";
+import path from "path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const ARCH = process.arch;
+const PS_EXEC_PATH = path.join(
+  __dirname,
+  "dependencies",
+  ARCH === "x64" ? "PsExec64.exe" : "PsExec.exe"
+);
+
+export type PsExecOptions = {
+  computer?: string;
+  fileList?: string;
+  user?: string;
+  password?: string;
+  timeout?: number;
+  limited?: boolean;
+  system?: boolean;
+  profile?: boolean;
+  interactive?: boolean;
+  session?: number;
+  copy?: boolean;
+  force?: boolean;
+  versionCheck?: boolean;
+  noWait?: boolean;
+  workingDir?: string;
+  priority?: "low" | "belownormal" | "abovenormal" | "high" | "realtime";
+  processors?: number[];
+  winlogon?: boolean;
+  windowsHide?: boolean;
+};
+
+class Sync {
+  static run(
+    cmd: string,
+    options?: PsExecOptions
+  ): { stdout: string; stderr: string; status: number | null } {
+    const args = Sync.buildArgs(cmd, options);
+
+    const child = spawnSync(PS_EXEC_PATH, args.split(" "), {
+      shell: true,
+      stdio: "pipe",
+      windowsHide: options?.windowsHide ?? true,
+      timeout: options?.timeout ? options.timeout * 1000 : undefined,
+    });
+
+    return {
+      stdout: child.stdout?.toString() || "",
+      stderr: child.stderr?.toString() || "",
+      status: child.status,
+    };
+  }
+
+  private static buildArgs(cmd: string, options?: PsExecOptions): string {
+    let args = "";
+
+    if (options?.computer) args += `\\\\${options.computer} `;
+    if (options?.fileList) args += `@${options.fileList} `;
+    if (options?.user) args += `-u ${options.user} `;
+    if (options?.password) args += `-p ${options.password} `;
+    if (options?.timeout) args += `-n ${options.timeout} `;
+    if (options?.limited) args += "-l ";
+    if (options?.system) args += "-s ";
+    if (options?.profile) args += "-e ";
+    if (options?.interactive)
+      args += `-i${options.session ? " " + options.session : ""} `;
+    if (options?.copy) args += "-c ";
+    if (options?.force) args += "-f ";
+    if (options?.versionCheck) args += "-v ";
+    if (options?.noWait) args += "-d ";
+    if (options?.workingDir) args += `-w "${options.workingDir}" `;
+    if (options?.winlogon) args += "-x ";
+    if (options?.priority) args += `-${options.priority} `;
+    if (options?.processors) args += `-a ${options.processors.join(",")} `;
+
+    args += cmd;
+    return args;
+  }
+}
+
+class Async {
+  static run(cmd: string, options?: PsExecOptions): void {
+    const args = Async.buildArgs(cmd, options);
+
+    const child = spawn(PS_EXEC_PATH, args.split(" "), {
+      shell: true,
+      detached: true,
+      stdio: "ignore",
+      windowsHide: options?.windowsHide ?? true,
+    });
+
+    child.unref();
+  }
+
+  private static buildArgs(cmd: string, options?: PsExecOptions): string {
+    let args = "";
+
+    if (options?.computer) args += `\\\\${options.computer} `;
+    if (options?.fileList) args += `@${options.fileList} `;
+    if (options?.user) args += `-u ${options.user} `;
+    if (options?.password) args += `-p ${options.password} `;
+    if (options?.timeout) args += `-n ${options.timeout} `;
+    if (options?.limited) args += "-l ";
+    if (options?.system) args += "-s ";
+    if (options?.profile) args += "-e ";
+    if (options?.interactive)
+      args += `-i${options.session ? " " + options.session : ""} `;
+    if (options?.copy) args += "-c ";
+    if (options?.force) args += "-f ";
+    if (options?.versionCheck) args += "-v ";
+    if (options?.noWait) args += "-d ";
+    if (options?.workingDir) args += `-w "${options.workingDir}" `;
+    if (options?.winlogon) args += "-x ";
+    if (options?.priority) args += `-${options.priority} `;
+    if (options?.processors) args += `-a ${options.processors.join(",")} `;
+
+    args += cmd;
+    return args;
+  }
+}
+
+export default class PsExec {
+  public static readonly Async = Async;
+  public static readonly Sync = Sync;
+}

package/packages/windows/src/PsExec/psfile.ts

@@ -0,0 +1,110 @@
+import { spawn, spawnSync } from "child_process";
+import { fileURLToPath } from "url";
+import path from "path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const PSFILE_PATH = path.join(__dirname, "dependencies", "PsFile.exe");
+
+export type PsFileOptions = {
+  computer?: string;
+  user?: string;
+  password?: string;
+  idOrPath?: string; // ID o path del archivo
+  close?: boolean; // -c
+  windowsHide?: boolean; // ocultar ventana
+  timeout?: number; // timeout en segundos
+};
+
+class Async {
+  static run(
+    cmd?: string,
+    options?: PsFileOptions
+  ): Promise<{ stdout: string; stderr: string }> {
+    return new Promise((resolve, reject) => {
+      try {
+        const args = Async.buildArgs(cmd, options);
+        const child = spawn(PSFILE_PATH, args, {
+          shell: true,
+          windowsHide: options?.windowsHide ?? true,
+        });
+
+        let stdout = "";
+        let stderr = "";
+
+        child.stdout.on("data", (data) => (stdout += data.toString()));
+        child.stderr.on("data", (data) => (stderr += data.toString()));
+
+        if (options?.timeout) {
+          setTimeout(() => {
+            child.kill();
+            reject(new Error("PsFile timeout reached"));
+          }, options.timeout * 1000);
+        }
+
+        child.on("close", (code) => {
+          if (code === 0) resolve({ stdout, stderr });
+          else reject(new Error(stderr || `PsFile exited with code ${code}`));
+        });
+
+        child.on("error", reject);
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  private static buildArgs(cmd?: string, options?: PsFileOptions): string[] {
+    const args: string[] = [];
+
+    if (options?.computer) args.push(`\\\\${options.computer}`);
+    if (options?.user) args.push("-u", options.user);
+    if (options?.password) args.push("-p", options.password);
+    if (options?.idOrPath) args.push(options.idOrPath);
+    if (options?.close) args.push("-c");
+    if (cmd) args.push(cmd);
+
+    return args;
+  }
+}
+
+class Sync {
+  static run(
+    cmd?: string,
+    options?: PsFileOptions
+  ): { stdout: string; stderr: string; status: number | null } {
+    const args = Sync.buildArgs(cmd, options);
+
+    const child = spawnSync(PSFILE_PATH, args, {
+      shell: true,
+      stdio: "pipe",
+      windowsHide: options?.windowsHide ?? true,
+      timeout: options?.timeout ? options.timeout * 1000 : undefined,
+    });
+
+    return {
+      stdout: child.stdout?.toString() || "",
+      stderr: child.stderr?.toString() || "",
+      status: child.status,
+    };
+  }
+
+  private static buildArgs(cmd?: string, options?: PsFileOptions): string[] {
+    const args: string[] = [];
+
+    if (options?.computer) args.push(`\\\\${options.computer}`);
+    if (options?.user) args.push("-u", options.user);
+    if (options?.password) args.push("-p", options.password);
+    if (options?.idOrPath) args.push(options.idOrPath);
+    if (options?.close) args.push("-c");
+    if (cmd) args.push(cmd);
+
+    return args;
+  }
+}
+
+export default class PsFile {
+  public static readonly Async = Async;
+  public static readonly Sync = Sync;
+}