manageos 2.3.1 → 2.3.4

package/packages/windows/src/secpol.ts

@@ -0,0 +1,99 @@
+import { exec, execSync } from "child_process";
+
+class Async {
+  static validatePolicy(filePath: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec(`secedit /validate /cfg "${filePath}"`, (error, stdout, stderr) => {
+        if (error) reject(stderr || error);
+        else resolve();
+      });
+    });
+  }
+
+  static analyzePolicy(outputReport: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec(
+        `secedit /analyze /db secedit.sdb /log "${outputReport}"`,
+        (error) => {
+          if (error) reject(error);
+          else resolve();
+        }
+      );
+    });
+  }
+
+  static resetPolicy(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec(
+        `secedit /configure /cfg %windir%\\inf\\defltbase.inf /db secedit.sdb /overwrite`,
+        (error) => {
+          if (error) reject(error);
+          else resolve();
+        }
+      );
+    });
+  }
+  static applyPolicy(filePath: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec(
+        `secedit /configure /db secedit.sdb /cfg "${filePath}" /overwrite`,
+        (error) => {
+          if (error) reject(error);
+          else resolve();
+        }
+      );
+    });
+  }
+  static exportPolicy(outputPath: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec(`secedit /export /cfg "${outputPath}"`, (error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
+  static verifyPolicy(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      exec(`secedit /analyze /db secedit.sdb`, (error, stdout, stderr) => {
+        if (error) reject(stderr || error);
+        else resolve();
+      });
+    });
+  }
+}
+
+class Sync {
+  static validatePolicy(filePath: string): void {
+    execSync(`secedit /validate /cfg "${filePath}"`, { stdio: "inherit" });
+  }
+
+  static analyzePolicy(outputReport: string): void {
+    execSync(`secedit /analyze /db secedit.sdb /log "${outputReport}"`);
+  }
+
+  static resetPolicy(): void {
+    execSync(
+      `secedit /configure /cfg %windir%\\inf\\defltbase.inf /db secedit.sdb /overwrite`
+    );
+  }
+
+  static applyPolicy(filePath: string): void {
+    execSync(
+      `secedit /configure /db secedit.sdb /cfg "${filePath}" /overwrite`
+    );
+  }
+
+  static exportPolicy(outputPath: string): void {
+    execSync(`secedit /export /cfg "${outputPath}"`);
+  }
+
+  static verifyPolicy(): void {
+    execSync(`secedit /analyze /db secedit.sdb`, { stdio: "inherit" });
+  }
+}
+
+export default class SecPol {
+  public static readonly Sync = Sync;
+  public static readonly Async = Async;
+}

package/packages/windows/src/services.ts

@@ -0,0 +1,371 @@
+import { exec, execSync } from "child_process";
+import * as path from "path";
+import { Service } from "node-windows";
+
+type ServiceInfo = {
+  name: string;
+  status: string;
+};
+
+type ServiceResult = {
+  success: boolean;
+  error?: string;
+};
+
+class Sync {
+  static createService(config: {
+    name: string;
+    description?: string;
+    scriptPath: string;
+    args?: string[];
+    cwd?: string;
+    userName?: string;
+    password?: string;
+  }): ServiceResult {
+    try {
+      const svcConfig: any = {
+        name: config.name,
+        description: config.description || "Node.js Service",
+        script: path.resolve(config.scriptPath),
+        cwd: config.cwd || path.dirname(config.scriptPath),
+      };
+
+      if (config.userName) {
+        svcConfig.user = {
+          account: config.userName,
+          password: config.password || "",
+        };
+      }
+
+      if (config.args && config.args.length) {
+        svcConfig.env = config.args.map((arg, index) => ({
+          name: `ARG${index}`,
+          value: arg,
+        }));
+      }
+
+      const svc = new Service(svcConfig);
+
+      svc.on("install", () => svc.start());
+      svc.on("error", (err) => {});
+
+      svc.install();
+
+      return { success: true };
+    } catch (error: any) {
+      return { success: false, error: error.message || String(error) };
+    }
+  }
+
+  static list(): ServiceInfo[] {
+    try {
+      const output = execSync(
+        `powershell "Get-Service | Select-Object -Property Name, Status | Format-Table -HideTableHeaders"`,
+        { encoding: "utf-8" }
+      );
+
+      const lines = output
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+
+      return lines.map((line) => {
+        const [name, ...statusParts] = line.split(/\s{2,}/);
+        return { name, status: statusParts.join(" ") };
+      });
+    } catch {
+      return [];
+    }
+  }
+
+  static start(serviceName: string): ServiceResult {
+    try {
+      execSync(`powershell Start-Service -Name "${serviceName}"`);
+      return { success: true };
+    } catch (error: any) {
+      return { success: false, error: error.message || String(error) };
+    }
+  }
+
+  static stop(serviceName: string): ServiceResult {
+    try {
+      execSync(`powershell Stop-Service -Name "${serviceName}"`);
+      return { success: true };
+    } catch (error: any) {
+      return { success: false, error: error.message || String(error) };
+    }
+  }
+
+  static restart(serviceName: string): ServiceResult {
+    try {
+      execSync(`powershell Restart-Service -Name "${serviceName}"`);
+      return { success: true };
+    } catch (error: any) {
+      return { success: false, error: error.message || String(error) };
+    }
+  }
+
+  static enable(serviceName: string): ServiceResult {
+    try {
+      execSync(
+        `powershell Set-Service -Name "${serviceName}" -StartupType Automatic`
+      );
+      return { success: true };
+    } catch (error: any) {
+      return { success: false, error: error.message || String(error) };
+    }
+  }
+
+  static disable(serviceName: string): ServiceResult {
+    try {
+      execSync(
+        `powershell Set-Service -Name "${serviceName}" -StartupType Disabled`
+      );
+      return { success: true };
+    } catch (error: any) {
+      return { success: false, error: error.message || String(error) };
+    }
+  }
+
+  static status(serviceName: string): { status: string; error?: string } {
+    try {
+      const output = execSync(
+        `powershell "(Get-Service -Name '${serviceName}').Status"`,
+        { encoding: "utf-8" }
+      );
+      return { status: output.trim() };
+    } catch (error: any) {
+      return { status: "unknown", error: error.message || String(error) };
+    }
+  }
+
+  static install(
+    scriptPath: string,
+    serviceName: string,
+    description: string = "Node.js Service"
+  ): ServiceResult {
+    try {
+      const svc = new Service({
+        name: serviceName,
+        description,
+        script: path.resolve(scriptPath),
+      });
+
+      svc.on("install", () => svc.start());
+      svc.install();
+
+      return { success: true };
+    } catch (error: any) {
+      return { success: false, error: error.message || String(error) };
+    }
+  }
+
+  static uninstall(serviceName: string): ServiceResult {
+    try {
+      const svc = new Service({
+        name: serviceName,
+        script: "C:\\Windows\\System32\\cmd.exe",
+      });
+
+      svc.on("uninstall", () => {});
+      svc.uninstall();
+
+      return { success: true };
+    } catch (error: any) {
+      return { success: false, error: error.message || String(error) };
+    }
+  }
+}
+
+class Async {
+  static createService(config: {
+    name: string;
+    description?: string;
+    scriptPath: string;
+    args?: string[];
+    cwd?: string;
+    userName?: string;
+    password?: string;
+  }): Promise<ServiceResult> {
+    return new Promise((resolve) => {
+      try {
+        const svcConfig: any = {
+          name: config.name,
+          description: config.description || "Node.js Service",
+          script: path.resolve(config.scriptPath),
+          cwd: config.cwd || path.dirname(config.scriptPath),
+        };
+
+        if (config.userName) {
+          svcConfig.user = {
+            account: config.userName,
+            password: config.password || "",
+          };
+        }
+
+        if (config.args && config.args.length) {
+          svcConfig.env = config.args.map((arg, index) => ({
+            name: `ARG${index}`,
+            value: arg,
+          }));
+        }
+
+        const svc = new Service(svcConfig);
+
+        svc.on("install", () => svc.start());
+        svc.on("error", (err) =>
+          resolve({ success: false, error: err.message })
+        );
+
+        svc.install();
+        resolve({ success: true });
+      } catch (error: any) {
+        resolve({ success: false, error: error.message || String(error) });
+      }
+    });
+  }
+
+  static list(): Promise<ServiceInfo[]> {
+    return new Promise((resolve) => {
+      exec(
+        `powershell "Get-Service | Select-Object -Property Name, Status | Format-Table -HideTableHeaders"`,
+        { encoding: "utf-8" },
+        (err, stdout) => {
+          if (err) {
+            resolve([]);
+            return;
+          }
+
+          const lines = stdout
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+
+          const services = lines.map((line) => {
+            const [name, ...statusParts] = line.split(/\s{2,}/);
+            return { name, status: statusParts.join(" ") };
+          });
+
+          resolve(services);
+        }
+      );
+    });
+  }
+
+  static start(serviceName: string): Promise<ServiceResult> {
+    return new Promise((resolve) => {
+      exec(`powershell Start-Service -Name "${serviceName}"`, (err) => {
+        if (err) resolve({ success: false, error: err.message });
+        else resolve({ success: true });
+      });
+    });
+  }
+
+  static stop(serviceName: string): Promise<ServiceResult> {
+    return new Promise((resolve) => {
+      exec(`powershell Stop-Service -Name "${serviceName}"`, (err) => {
+        if (err) resolve({ success: false, error: err.message });
+        else resolve({ success: true });
+      });
+    });
+  }
+
+  static restart(serviceName: string): Promise<ServiceResult> {
+    return new Promise((resolve) => {
+      exec(`powershell Restart-Service -Name "${serviceName}"`, (err) => {
+        if (err) resolve({ success: false, error: err.message });
+        else resolve({ success: true });
+      });
+    });
+  }
+
+  static enable(serviceName: string): Promise<ServiceResult> {
+    return new Promise((resolve) => {
+      exec(
+        `powershell Set-Service -Name "${serviceName}" -StartupType Automatic`,
+        (err) => {
+          if (err) resolve({ success: false, error: err.message });
+          else resolve({ success: true });
+        }
+      );
+    });
+  }
+
+  static disable(serviceName: string): Promise<ServiceResult> {
+    return new Promise((resolve) => {
+      exec(
+        `powershell Set-Service -Name "${serviceName}" -StartupType Disabled`,
+        (err) => {
+          if (err) resolve({ success: false, error: err.message });
+          else resolve({ success: true });
+        }
+      );
+    });
+  }
+
+  static status(
+    serviceName: string
+  ): Promise<{ status: string; error?: string }> {
+    return new Promise((resolve) => {
+      exec(
+        `powershell "(Get-Service -Name '${serviceName}').Status"`,
+        { encoding: "utf-8" },
+        (err, stdout) => {
+          if (err) resolve({ status: "unknown", error: err.message });
+          else resolve({ status: stdout.trim() });
+        }
+      );
+    });
+  }
+
+  static install(
+    scriptPath: string,
+    serviceName: string,
+    description: string = "Node.js Service"
+  ): Promise<ServiceResult> {
+    return new Promise((resolve) => {
+      try {
+        const svc = new Service({
+          name: serviceName,
+          description,
+          script: path.resolve(scriptPath),
+        });
+
+        svc.on("install", () => svc.start());
+        svc.on("error", (err) =>
+          resolve({ success: false, error: err.message })
+        );
+
+        svc.install();
+        resolve({ success: true });
+      } catch (error: any) {
+        resolve({ success: false, error: error.message || String(error) });
+      }
+    });
+  }
+
+  static uninstall(serviceName: string): Promise<ServiceResult> {
+    return new Promise((resolve) => {
+      try {
+        const svc = new Service({
+          name: serviceName,
+          script: "C:\\Windows\\System32\\cmd.exe",
+        });
+
+        svc.on("uninstall", () => resolve({ success: true }));
+        svc.on("error", (err) =>
+          resolve({ success: false, error: err.message })
+        );
+
+        svc.uninstall();
+      } catch (error: any) {
+        resolve({ success: false, error: error.message || String(error) });
+      }
+    });
+  }
+}
+
+export default class Services {
+  public static readonly Sync = Sync;
+  public static readonly Async = Async;
+}

package/packages/windows/src/shell.ts

@@ -0,0 +1,227 @@
+import { execSync, exec as _exec } from "child_process";
+import { promisify } from "util";
+
+const exec = promisify(_exec);
+
+interface ShellInfo {
+  name: string;
+  path?: string;
+}
+
+function getDetectionCommand(name: string) {
+  const safeName = name.replace(/'/g, "''");
+  return `where.exe ${safeName} 2>nul`;
+}
+
+class ShellInstance {
+  constructor(public info: ShellInfo) {}
+  showPath(): string {
+    if (this.info.path) return this.info.path;
+    try {
+      const out = execSync(getDetectionCommand(this.info.name), {
+        encoding: "utf8",
+      });
+      return String(out).split(/\r?\n/)[0].trim();
+    } catch {
+      return "";
+    }
+  }
+}
+
+class AsyncShellInstance {
+  constructor(public info: ShellInfo) {}
+  async showPath(): Promise<string> {
+    if (this.info.path) return this.info.path;
+    try {
+      const { stdout } = (await exec(getDetectionCommand(this.info.name))) as {
+        stdout: string;
+        stderr: string;
+      };
+      return stdout ? stdout.split(/\r?\n/)[0].trim() : "";
+    } catch {
+      return "";
+    }
+  }
+}
+
+class SyncShell {
+  static listShells(): ShellInstance[] {
+    const shellsToCheck = [
+      "cmd.exe",
+      "powershell.exe",
+      "pwsh.exe",
+      "bash.exe",
+      "zsh.exe",
+      "wsl.exe",
+    ];
+    const found: ShellInstance[] = [];
+    for (const s of shellsToCheck) {
+      try {
+        const p = execSync(getDetectionCommand(s), { encoding: "utf8" })
+          .split(/\r?\n/)[0]
+          .trim();
+        if (p) found.push(new ShellInstance({ name: s, path: p }));
+      } catch {}
+    }
+    return found;
+  }
+
+  static showPath(shell: string): string {
+    try {
+      return execSync(getDetectionCommand(shell), { encoding: "utf8" })
+        .split(/\r?\n/)[0]
+        .trim();
+    } catch {
+      return "";
+    }
+  }
+}
+
+class AsyncShell {
+  static async listShells(): Promise<AsyncShellInstance[]> {
+    const shellsToCheck = [
+      "cmd.exe",
+      "powershell.exe",
+      "pwsh.exe",
+      "bash.exe",
+      "zsh.exe",
+      "wsl.exe",
+    ];
+    const found: AsyncShellInstance[] = [];
+    for (const s of shellsToCheck) {
+      try {
+        const { stdout } = (await exec(getDetectionCommand(s))) as {
+          stdout: string;
+          stderr: string;
+        };
+        const p = stdout ? stdout.split(/\r?\n/)[0].trim() : "";
+        if (p) found.push(new AsyncShellInstance({ name: s, path: p }));
+      } catch {}
+    }
+    return found;
+  }
+
+  static async showPath(shell: string): Promise<string> {
+    try {
+      const { stdout } = (await exec(getDetectionCommand(shell))) as {
+        stdout: string;
+        stderr: string;
+      };
+      return stdout ? stdout.split(/\r?\n/)[0].trim() : "";
+    } catch {
+      return "";
+    }
+  }
+}
+
+class SyncWSL {
+  static getPath(): string {
+    return execSync(getDetectionCommand("wsl.exe"), {
+      encoding: "utf8",
+    }).trim();
+  }
+  static exists(): boolean {
+    return !!this.getPath();
+  }
+  static getVersion(): string {
+    return execSync("wsl.exe --version", { encoding: "utf8" }).trim();
+  }
+  static listDistributions(): string[] {
+    const output = execSync("wsl.exe --list --quiet", { encoding: "utf8" });
+    return output
+      ? output
+          .split(/\r?\n/)
+          .map((d) => d.trim())
+          .filter(Boolean)
+      : [];
+  }
+  static runCommand(distribution: string, command: string): string {
+    return execSync(`wsl.exe -d ${distribution} -- ${command}`, {
+      encoding: "utf8",
+    }).trim();
+  }
+  static terminate(distribution?: string): void {
+    if (distribution) {
+      execSync(`wsl.exe --terminate ${distribution}`);
+    } else {
+      execSync(`wsl.exe --shutdown`);
+    }
+  }
+}
+
+class AsyncWSL {
+  static async getPath(): Promise<string> {
+    const { stdout } = await exec(getDetectionCommand("wsl.exe"));
+    return stdout.trim();
+  }
+  static async exists(): Promise<boolean> {
+    return !!(await this.getPath());
+  }
+  static async getVersion(): Promise<string> {
+    const { stdout } = await exec("wsl.exe --version");
+    return stdout.trim();
+  }
+  static async listDistributions(): Promise<string[]> {
+    const { stdout } = await exec("wsl.exe --list --quiet");
+    return stdout
+      ? stdout
+          .split(/\r?\n/)
+          .map((d) => d.trim())
+          .filter(Boolean)
+      : [];
+  }
+  static async runCommand(
+    distribution: string,
+    command: string
+  ): Promise<string> {
+    const { stdout } = await exec(`wsl.exe -d ${distribution} -- ${command}`);
+    return stdout.trim();
+  }
+  static async terminate(distribution?: string): Promise<void> {
+    if (distribution) {
+      await exec(`wsl.exe --terminate ${distribution}`);
+    } else {
+      await exec(`wsl.exe --shutdown`);
+    }
+  }
+}
+
+const Sync = new Proxy(SyncShell, {
+  get(target, prop) {
+    if (typeof prop === "string" && /^\d+$/.test(prop)) {
+      const list = target.listShells();
+      return list[Number(prop)];
+    }
+    const value = (target as any)[prop];
+    return typeof value === "function" ? value.bind(target) : value;
+  },
+});
+
+const Async = new Proxy(AsyncShell, {
+  get(target, prop) {
+    const value = (target as any)[prop];
+    return typeof value === "function" ? value.bind(target) : value;
+  },
+});
+
+export default class Shell {
+  public static readonly Sync = Sync;
+  public static readonly Async = Async;
+
+  public static readonly WSL: {
+    Sync?: typeof SyncWSL;
+    Async?: typeof AsyncWSL;
+  } = {};
+
+  static initWSL() {
+    try {
+      const path = execSync(getDetectionCommand("wsl.exe"), {
+        encoding: "utf8",
+      }).trim();
+      if (path) {
+        this.WSL.Sync = SyncWSL;
+        this.WSL.Async = AsyncWSL;
+      }
+    } catch {}
+  }
+}