manageos 2.3.2 → 2.3.4

package/packages/windows/src/Android/fastboot.ts

@@ -0,0 +1,217 @@
+import { execSync, exec } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+
+interface FastbootDeviceInfo {
+  serial: string;
+  state: string;
+}
+
+interface FastbootVar {
+  name: string;
+  value: string;
+}
+
+type FastbootCommandResult = {
+  success: boolean;
+  command: string;
+  output?: string;
+  error?: string;
+};
+
+class Sync {
+  static getFastbootPath(): string {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    return path.join(__dirname, "dependencies", "fastboot.exe");
+  }
+
+  static exec(serial: string, command: string): FastbootCommandResult {
+    try {
+      const fastboot = this.getFastbootPath();
+      const cmd = `"${fastboot}" -s ${serial} ${command}`;
+      const output = execSync(cmd, { encoding: "utf8" });
+      return { success: true, command: cmd, output: output.trim() };
+    } catch (error: any) {
+      return { success: false, command: command, error: error.message };
+    }
+  }
+
+  static listDevices(): FastbootDeviceInfo[] {
+    try {
+      const fastboot = this.getFastbootPath();
+      const output = execSync(`"${fastboot}" devices`, { encoding: "utf8" });
+      const lines = output.split("\n").filter((l) => l.trim());
+      const devices: FastbootDeviceInfo[] = [];
+      for (const line of lines) {
+        const [serial, state] = line.split("\t");
+        if (serial && state) {
+          devices.push({ serial: serial.trim(), state: state.trim() });
+        }
+      }
+      return devices;
+    } catch {
+      return [];
+    }
+  }
+
+  static getVar(serial: string, variable: string): FastbootVar | null {
+    const result = this.exec(serial, `getvar ${variable}`);
+    if (result.success && result.output) {
+      const match = result.output.match(new RegExp(`${variable}:\\s*(.+)`));
+      if (match) {
+        return { name: variable, value: match[1].trim() };
+      }
+    }
+    return null;
+  }
+
+  static reboot(serial: string): FastbootCommandResult {
+    return this.exec(serial, "reboot");
+  }
+
+  static rebootBootloader(serial: string): FastbootCommandResult {
+    return this.exec(serial, "reboot bootloader");
+  }
+
+  static flash(
+    serial: string,
+    partition: string,
+    filePath: string
+  ): FastbootCommandResult {
+    return this.exec(serial, `flash ${partition} "${filePath}"`);
+  }
+
+  static erase(serial: string, partition: string): FastbootCommandResult {
+    return this.exec(serial, `erase ${partition}`);
+  }
+
+  static oemCommand(serial: string, command: string): FastbootCommandResult {
+    return this.exec(serial, `oem ${command}`);
+  }
+
+  static continue(serial: string): FastbootCommandResult {
+    return this.exec(serial, "continue");
+  }
+
+  static getFlashInfo(serial: string): Record<string, string> | null {
+    const result = this.exec(serial, "getvar all");
+    if (!result.success || !result.output) return null;
+
+    const info: Record<string, string> = {};
+    result.output.split("\n").forEach((line) => {
+      const match = line.match(/^(\S+):\s*(.+)$/);
+      if (match) {
+        info[match[1]] = match[2];
+      }
+    });
+    return Object.keys(info).length ? info : null;
+  }
+
+  static getVersion(serial: string): string | null {
+    const result = this.getVar(serial, "version");
+    return result?.value || null;
+  }
+}
+
+class Async {
+  static getFastbootPath(): string {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    return path.join(__dirname, "dependencies", "fastboot.exe");
+  }
+
+  static exec(serial: string, command: string): Promise<FastbootCommandResult> {
+    return new Promise((resolve) => {
+      const fastboot = this.getFastbootPath();
+      const cmd = `"${fastboot}" -s ${serial} ${command}`;
+      exec(cmd, (error, stdout) => {
+        if (error) {
+          resolve({ success: false, command: command, error: error.message });
+        } else {
+          resolve({ success: true, command: cmd, output: stdout.trim() });
+        }
+      });
+    });
+  }
+
+  static async listDevices(): Promise<FastbootDeviceInfo[]> {
+    const fastboot = this.getFastbootPath();
+    try {
+      const output = await this.exec(fastboot, "devices");
+      if (!output.output) return [];
+      return output.output
+        .split("\n")
+        .filter((l) => l.trim())
+        .map((line) => {
+          const [serial, state] = line.split("\t");
+          return { serial: serial.trim(), state: state.trim() };
+        });
+    } catch {
+      return [];
+    }
+  }
+
+  static async getVar(
+    serial: string,
+    variable: string
+  ): Promise<FastbootVar | null> {
+    const result = await this.exec(serial, `getvar ${variable}`);
+    if (result.success && result.output) {
+      const match = result.output.match(new RegExp(`${variable}:\\s*(.+)`));
+      if (match) {
+        return { name: variable, value: match[1].trim() };
+      }
+    }
+    return null;
+  }
+
+  static reboot(serial: string) {
+    return this.exec(serial, "reboot");
+  }
+
+  static rebootBootloader(serial: string) {
+    return this.exec(serial, "reboot bootloader");
+  }
+
+  static flash(serial: string, partition: string, filePath: string) {
+    return this.exec(serial, `flash ${partition} "${filePath}"`);
+  }
+
+  static erase(serial: string, partition: string) {
+    return this.exec(serial, `erase ${partition}`);
+  }
+
+  static oemCommand(serial: string, command: string) {
+    return this.exec(serial, `oem ${command}`);
+  }
+
+  static continue(serial: string) {
+    return this.exec(serial, "continue");
+  }
+
+  static async getFlashInfo(
+    serial: string
+  ): Promise<Record<string, string> | null> {
+    const result = await this.exec(serial, "getvar all");
+    if (!result.success || !result.output) return null;
+    const info: Record<string, string> = {};
+    result.output.split("\n").forEach((line) => {
+      const match = line.match(/^(\S+):\s*(.+)$/);
+      if (match) {
+        info[match[1]] = match[2];
+      }
+    });
+    return Object.keys(info).length ? info : null;
+  }
+
+  static async getVersion(serial: string): Promise<string | null> {
+    const result = await this.getVar(serial, "version");
+    return result?.value || null;
+  }
+}
+
+export default class Fastboot {
+  static readonly Sync = Sync;
+  static readonly Async = Async;
+}

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

@@ -0,0 +1,7 @@
+import ADB from "./adb";
+import Fastboot from "./fastboot";
+
+export default class Android {
+  public static readonly ADB = ADB;
+  public static readonly Fastboot = Fastboot;
+}

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

@@ -0,0 +1,139 @@
+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 keyboardExe = path.join(__dirname, "keyboard.exe");
+
+function parseJSON(stdout: string) {
+  try {
+    return JSON.parse(stdout.trim());
+  } catch (e) {
+    throw new Error("Invalid JSON from keyboard.exe: " + stdout);
+  }
+}
+
+class Async {
+  static press(key: string): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      exec(`"${keyboardExe}" press ${key}`, (error, stdout) => {
+        if (error) return reject(error);
+        const result = parseJSON(stdout);
+        resolve(result.success || false);
+      });
+    });
+  }
+
+  static release(key: string): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      exec(`"${keyboardExe}" release ${key}`, (error, stdout) => {
+        if (error) return reject(error);
+        const result = parseJSON(stdout);
+        resolve(result.success || false);
+      });
+    });
+  }
+
+  static type(text: string): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      exec(`"${keyboardExe}" type "${text}"`, (error, stdout) => {
+        if (error) return reject(error);
+        const result = parseJSON(stdout);
+        resolve(result.success || false);
+      });
+    });
+  }
+
+  static repeat(key: string, count: number): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      exec(`"${keyboardExe}" repeat ${key} ${count}`, (error, stdout) => {
+        if (error) return reject(error);
+        const result = parseJSON(stdout);
+        resolve(result.success || false);
+      });
+    });
+  }
+
+  static isKeyDown(key: string): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      exec(`"${keyboardExe}" iskeydown ${key}`, (error, stdout) => {
+        if (error) return reject(error);
+        const result = parseJSON(stdout);
+        resolve(result.keydown || false);
+      });
+    });
+  }
+
+  static block(): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      exec(`"${keyboardExe}" block`, (error, stdout) => {
+        if (error) return reject(error);
+        const result = parseJSON(stdout);
+        resolve(result.success || false);
+      });
+    });
+  }
+
+  static unblock(): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      exec(`"${keyboardExe}" unblock`, (error, stdout) => {
+        if (error) return reject(error);
+        const result = parseJSON(stdout);
+        resolve(result.success || false);
+      });
+    });
+  }
+}
+
+class Sync {
+  static press(key: string): boolean {
+    const stdout = execSync(`"${keyboardExe}" press ${key}`).toString();
+    const result = parseJSON(stdout);
+    return result.success || false;
+  }
+
+  static release(key: string): boolean {
+    const stdout = execSync(`"${keyboardExe}" release ${key}`).toString();
+    const result = parseJSON(stdout);
+    return result.success || false;
+  }
+
+  static type(text: string): boolean {
+    const stdout = execSync(`"${keyboardExe}" type "${text}"`).toString();
+    const result = parseJSON(stdout);
+    return result.success || false;
+  }
+
+  static repeat(key: string, count: number): boolean {
+    const stdout = execSync(
+      `"${keyboardExe}" repeat ${key} ${count}`
+    ).toString();
+    const result = parseJSON(stdout);
+    return result.success || false;
+  }
+
+  static isKeyDown(key: string): boolean {
+    const stdout = execSync(`"${keyboardExe}" iskeydown ${key}`).toString();
+    const result = parseJSON(stdout);
+    return result.keydown || false;
+  }
+
+  static block(): boolean {
+    const stdout = execSync(`"${keyboardExe}" block`).toString();
+    const result = parseJSON(stdout);
+    return result.success || false;
+  }
+
+  static unblock(): boolean {
+    const stdout = execSync(`"${keyboardExe}" unblock`).toString();
+    const result = parseJSON(stdout);
+    return result.success || false;
+  }
+}
+
+export default class Keyboard {
+  public static readonly Async = Async;
+  public static readonly Sync = Sync;
+}

package/packages/windows/src/Keyboard/keyboard.c

@@ -0,0 +1,181 @@
+#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);
+}
+
+int get_vk_code(const char *key)
+{
+    if (strlen(key) == 1)
+    {
+        char c = key[0];
+        if (c >= 'a' && c <= 'z')
+            c -= 32;
+        return VkKeyScan(c);
+    }
+
+    if (strcmp(key, "enter") == 0)
+        return VK_RETURN;
+    if (strcmp(key, "shift") == 0)
+        return VK_SHIFT;
+    if (strcmp(key, "ctrl") == 0)
+        return VK_CONTROL;
+    if (strcmp(key, "alt") == 0)
+        return VK_MENU;
+    if (strcmp(key, "tab") == 0)
+        return VK_TAB;
+    if (strcmp(key, "esc") == 0)
+        return VK_ESCAPE;
+    if (strcmp(key, "space") == 0)
+        return VK_SPACE;
+    if (strcmp(key, "backspace") == 0)
+        return VK_BACK;
+    if (strcmp(key, "up") == 0)
+        return VK_UP;
+    if (strcmp(key, "down") == 0)
+        return VK_DOWN;
+    if (strcmp(key, "left") == 0)
+        return VK_LEFT;
+    if (strcmp(key, "right") == 0)
+        return VK_RIGHT;
+    if (strcmp(key, "delete") == 0)
+        return VK_DELETE;
+    if (strcmp(key, "home") == 0)
+        return VK_HOME;
+    if (strcmp(key, "end") == 0)
+        return VK_END;
+    if (strcmp(key, "f1") == 0)
+        return VK_F1;
+    if (strcmp(key, "f2") == 0)
+        return VK_F2;
+    if (strcmp(key, "f3") == 0)
+        return VK_F3;
+    if (strcmp(key, "f4") == 0)
+        return VK_F4;
+    if (strcmp(key, "f5") == 0)
+        return VK_F5;
+    if (strcmp(key, "f6") == 0)
+        return VK_F6;
+    if (strcmp(key, "f7") == 0)
+        return VK_F7;
+    if (strcmp(key, "f8") == 0)
+        return VK_F8;
+    if (strcmp(key, "f9") == 0)
+        return VK_F9;
+    if (strcmp(key, "f10") == 0)
+        return VK_F10;
+    if (strcmp(key, "f11") == 0)
+        return VK_F11;
+    if (strcmp(key, "f12") == 0)
+        return VK_F12;
+
+    return -1;
+}
+
+int press_key(const char *key)
+{
+    int vk = get_vk_code(key);
+    if (vk == -1)
+        return 0;
+    keybd_event(vk, 0, 0, 0);
+    return 1;
+}
+
+int release_key(const char *key)
+{
+    int vk = get_vk_code(key);
+    if (vk == -1)
+        return 0;
+    keybd_event(vk, 0, KEYEVENTF_KEYUP, 0);
+    return 1;
+}
+
+int type_text(const char *text)
+{
+    for (size_t i = 0; i < strlen(text); i++)
+    {
+        SHORT vk = VkKeyScan(text[i]);
+        if (vk == -1)
+            continue;
+        keybd_event((BYTE)vk, 0, 0, 0);
+        keybd_event((BYTE)vk, 0, KEYEVENTF_KEYUP, 0);
+        Sleep(10);
+    }
+    return 1;
+}
+
+int repeat_key(const char *key, int count)
+{
+    int vk = get_vk_code(key);
+    if (vk == -1)
+        return 0;
+    for (int i = 0; i < count; i++)
+    {
+        keybd_event(vk, 0, 0, 0);
+        keybd_event(vk, 0, KEYEVENTF_KEYUP, 0);
+        Sleep(50);
+    }
+    return 1;
+}
+
+int is_key_down(const char *key)
+{
+    int vk = get_vk_code(key);
+    if (vk == -1)
+        return 0;
+    return (GetAsyncKeyState(vk) & 0x8000) != 0;
+}
+
+int block_keyboard()
+{
+    BlockInput(TRUE);
+    return 1;
+}
+
+int unblock_keyboard()
+{
+    BlockInput(FALSE);
+    return 1;
+}
+
+int main(int argc, char *argv[])
+{
+    if (argc < 2)
+    {
+        output_json_bool("error", 1);
+        return 1;
+    }
+
+    if (strcmp(argv[1], "press") == 0 && argc == 3)
+        output_json_bool("success", press_key(argv[2]));
+    else if (strcmp(argv[1], "release") == 0 && argc == 3)
+        output_json_bool("success", release_key(argv[2]));
+    else if (strcmp(argv[1], "type") == 0 && argc == 3)
+        output_json_bool("success", type_text(argv[2]));
+    else if (strcmp(argv[1], "iskeydown") == 0 && argc == 3)
+        output_json_bool("keydown", is_key_down(argv[2]));
+    else if (strcmp(argv[1], "repeat") == 0 && argc == 4)
+        output_json_bool("success", repeat_key(argv[2], atoi(argv[3])));
+    else if (strcmp(argv[1], "block") == 0)
+        output_json_bool("success", block_keyboard());
+    else if (strcmp(argv[1], "unblock") == 0)
+        output_json_bool("success", unblock_keyboard());
+    else
+        output_json_bool("error", 1);
+
+    return 0;
+}