manageos 2.3.2 → 2.3.4

package/packages/windows/src/users.ts

@@ -0,0 +1,409 @@
+import {
+  execSync as originalExecSync,
+  ExecSyncOptionsWithStringEncoding,
+} from "child_process";
+
+function execSync(
+  command: string,
+  options?: ExecSyncOptionsWithStringEncoding
+) {
+  return originalExecSync(command, {
+    encoding: "utf8",
+    stdio: "pipe",
+    ...options,
+  });
+}
+
+type UserList = string[];
+
+type UserInfo = {
+  username: string;
+  fullName: string;
+  comment: string;
+  countryRegionCode: string;
+  accountActive: string;
+  accountExpires: string;
+  passwordLastSet: string;
+  passwordExpires: string;
+  passwordChangeable: string;
+  passwordRequired: string;
+  userMayChangePassword: string;
+  workstationsAllowed: string;
+  logonScript: string;
+  profilePath: string;
+  homeDirectory: string;
+  lastLogon: string;
+  logonHoursAllowed: string;
+  localGroupMemberships: string[];
+  globalGroupMemberships: string[];
+};
+
+type CommandResult = {
+  success: boolean;
+  output?: string;
+  error?: string;
+};
+
+export default class Users {
+  private static parseDate(output: string): string | null {
+    if (!output) return null;
+
+    return output.replace(/\r/g, "").replace(/\n+/g, "").trim() || null;
+  }
+
+  private static cache: {
+    users?: { data: string[]; ts: number };
+    groups?: { data: string[]; ts: number };
+  } = {};
+
+  private static CACHE_TTL_MS = 5_000;
+
+  private static escapeArg(arg: string): string {
+    return `"${arg.replace(/"/g, '\\"')}"`;
+  }
+
+  private static execCommand(command: string): CommandResult {
+    try {
+      const output = execSync(command, { encoding: "utf8" });
+      return { success: true, output };
+    } catch (err) {
+      const errorMsg =
+        err instanceof Error
+          ? err.message
+          : typeof err === "string"
+          ? err
+          : JSON.stringify(err);
+      return { success: false, error: errorMsg };
+    }
+  }
+
+  private static parseSectionedOutput(output: string): string[] {
+    const lines = output.split(/\r?\n/);
+    const result: string[] = [];
+    let collecting = false;
+
+    for (let raw of lines) {
+      const line = raw.replace(/\r$/, "");
+      if (line.includes("-----")) {
+        collecting = !collecting;
+        continue;
+      }
+      if (!collecting) continue;
+      if (/The command completed/i.test(line)) continue;
+      const candidate = line.trim();
+      if (candidate) {
+        result.push(candidate);
+      }
+    }
+
+    return result;
+  }
+
+  static doesUserExist(username: string): boolean {
+    const res = this.execCommand(`net user ${this.escapeArg(username)}`);
+    return res.success && !res.error;
+  }
+
+  static lockUser(username: string): CommandResult {
+    const escUser = this.escapeArg(username);
+    return this.execCommand(`net user ${escUser} /lock`);
+  }
+
+  static unlockUser(username: string): CommandResult {
+    const escUser = this.escapeArg(username);
+    return this.execCommand(`net user ${escUser} /active:yes`);
+  }
+
+  static setUserComment(username: string, comment: string): CommandResult {
+    const escUser = this.escapeArg(username);
+    const escComment = this.escapeArg(comment);
+    return this.execCommand(`net user ${escUser} /comment:${escComment}`);
+  }
+
+  static getLastLogon(username: string): CommandResult {
+    const escUser = username.replace(/'/g, "''"); // Escapa comillas simples
+    const res = this.execCommand(
+      `powershell -Command "Get-LocalUser -Name '${escUser}' | Select-Object -ExpandProperty LastLogon"`
+    );
+
+    if (!res.success || !res.output) return res;
+
+    const isoDate = this.parseDate(res.output);
+    return { success: true, output: isoDate ?? "" };
+  }
+
+  static createUser(username: string, password?: string): CommandResult {
+    const escUser = this.escapeArg(username);
+    const passPart = password !== undefined ? this.escapeArg(password) : '""';
+    const res = this.execCommand(`net user ${escUser} ${passPart} /add`);
+    if (res.success) {
+      delete this.cache.users;
+    }
+    return res;
+  }
+
+  static deleteUser(username: string): CommandResult {
+    const escUser = this.escapeArg(username);
+    const res = this.execCommand(`net user ${escUser} /delete`);
+    if (res.success) delete this.cache.users;
+    return res;
+  }
+
+  static changePassword(username: string, newPassword: string): CommandResult {
+    const escUser = this.escapeArg(username);
+    const escPass = this.escapeArg(newPassword);
+    return this.execCommand(`net user ${escUser} ${escPass}`);
+  }
+
+  static setUserActive(username: string, active: boolean): CommandResult {
+    const escUser = this.escapeArg(username);
+    const res = this.execCommand(
+      `net user ${escUser} /active:${active ? "yes" : "no"}`
+    );
+    if (res.success) delete this.cache.users;
+    return res;
+  }
+
+  static requirePasswordChange(
+    username: string,
+    require: boolean
+  ): CommandResult {
+    const escUser = this.escapeArg(username);
+    return this.execCommand(
+      `net user ${escUser} /logonpasswordchg:${require ? "yes" : "no"}`
+    );
+  }
+
+  static addUserToGroup(username: string, group: string): CommandResult {
+    const escUser = this.escapeArg(username);
+    const escGroup = this.escapeArg(group);
+    const res = this.execCommand(`net localgroup ${escGroup} ${escUser} /add`);
+    if (res.success) delete this.cache.groups;
+    return res;
+  }
+
+  static removeUserFromGroup(username: string, group: string): CommandResult {
+    const escUser = this.escapeArg(username);
+    const escGroup = this.escapeArg(group);
+    const res = this.execCommand(
+      `net localgroup ${escGroup} ${escUser} /delete`
+    );
+    if (res.success) delete this.cache.groups;
+    return res;
+  }
+
+  static listUsers(): UserList {
+    const now = Date.now();
+    if (
+      this.cache.users &&
+      now - this.cache.users.ts < this.CACHE_TTL_MS &&
+      Array.isArray(this.cache.users.data)
+    ) {
+      return this.cache.users.data.slice();
+    }
+
+    const res = this.execCommand("net user");
+    if (!res.success || !res.output) {
+      return [];
+    }
+
+    const parsed = this.parseSectionedOutput(res.output)
+      .map((line) =>
+        line
+          .trim()
+          .split(/\s+/)
+          .filter(
+            (u) =>
+              u &&
+              u !== "The" &&
+              u !== "command" &&
+              u !== "completed" &&
+              u !== "successfully."
+          )
+      )
+      .flat();
+
+    this.cache.users = { data: parsed, ts: Date.now() };
+    return parsed;
+  }
+
+  static listGroups(): string[] {
+    const now = Date.now();
+    if (
+      this.cache.groups &&
+      now - this.cache.groups.ts < this.CACHE_TTL_MS &&
+      Array.isArray(this.cache.groups.data)
+    ) {
+      return this.cache.groups.data.slice();
+    }
+
+    const res = this.execCommand("net localgroup");
+    if (!res.success || !res.output) {
+      return [];
+    }
+
+    const parsed = this.parseSectionedOutput(res.output)
+      .map((l) => l.replace(/^\*/, "").trim())
+      .filter(Boolean);
+
+    this.cache.groups = { data: parsed, ts: Date.now() };
+    return parsed;
+  }
+
+  static listGroupMembers(groupName: string): string[] | string | undefined {
+    const escGroup = this.escapeArg(groupName);
+    const res = this.execCommand(`net localgroup ${escGroup}`);
+    if (!res.success || !res.output) {
+      return res.error;
+    }
+
+    const parsed = this.parseSectionedOutput(res.output)
+      .map((line) => line.split(/\s+/).filter(Boolean))
+      .flat();
+    return parsed;
+  }
+
+  static userExists(username: string): boolean {
+    return this.listUsers().includes(username);
+  }
+
+  static getUserInfo(username: string): UserInfo | null {
+    const escUser = this.escapeArg(username);
+    const res = this.execCommand(`net user ${escUser}`);
+    if (!res.success || !res.output) {
+      return null;
+    }
+
+    const lines = res.output.split(/\r?\n/).map((ln) => ln.replace(/\r$/, ""));
+    const details: Record<string, string> = {};
+    let currentKey: string | null = null;
+    const knownKeys = [
+      "User name",
+      "Full Name",
+      "Comment",
+      "User's comment",
+      "Country/region code",
+      "Account active",
+      "Account expires",
+      "Password last set",
+      "Password expires",
+      "Password changeable",
+      "Password required",
+      "User may change password",
+      "Workstations allowed",
+      "Logon script",
+      "User profile",
+      "Home directory",
+      "Last logon",
+      "Logon hours allowed",
+      "Local Group Memberships",
+      "Global Group memberships",
+    ];
+
+    let collecting = false;
+
+    for (let raw of lines) {
+      const line = raw.trimEnd();
+      if (line.startsWith("User name")) collecting = true;
+      if (!collecting) continue;
+      if (/The command completed/i.test(line)) break;
+
+      const match = line.match(/^([^:]+?)\s{2,}(.*)$/);
+      if (match) {
+        const key = match[1].trim();
+        const value = match[2].trim();
+        if (knownKeys.includes(key)) {
+          currentKey = key;
+          details[currentKey] = value;
+        } else {
+          currentKey = null;
+        }
+      } else {
+        const possibleKey = line.trim();
+        if (knownKeys.includes(possibleKey)) {
+          currentKey = possibleKey;
+          details[currentKey] = "";
+        } else if (currentKey) {
+          details[currentKey] = (details[currentKey] || "") + " " + line.trim();
+        }
+      }
+    }
+
+    return {
+      username,
+      fullName: details["Full Name"] || "",
+      comment: details["Comment"] || details["User's comment"] || "",
+      countryRegionCode: details["Country/region code"] || "",
+      accountActive: details["Account active"] || "",
+      accountExpires: details["Account expires"] || "",
+      passwordLastSet: details["Password last set"] || "",
+      passwordExpires: details["Password expires"] || "",
+      passwordChangeable: details["Password changeable"] || "",
+      passwordRequired: details["Password required"] || "",
+      userMayChangePassword: details["User may change password"] || "",
+      workstationsAllowed: details["Workstations allowed"] || "",
+      logonScript: details["Logon script"] || "",
+      profilePath: details["User profile"] || "",
+      homeDirectory: details["Home directory"] || "",
+      lastLogon: details["Last logon"] || "",
+      logonHoursAllowed: details["Logon hours allowed"] || "",
+      localGroupMemberships: (details["Local Group Memberships"] || "")
+        .split(/\s+/)
+        .filter(Boolean),
+      globalGroupMemberships: (details["Global Group memberships"] || "")
+        .split(/\s+/)
+        .filter(Boolean),
+    };
+  }
+
+  static getAllUsersInfo(): UserInfo[] {
+    const users = this.listUsers();
+    const allInfo: UserInfo[] = [];
+    for (const u of users) {
+      const info = this.getUserInfo(u);
+      if (info) allInfo.push(info);
+    }
+    return allInfo;
+  }
+
+  static getAllGroupMembers(): { group: string; members: string[] }[] {
+    const groups = this.listGroups();
+    const result: { group: string; members: string[] }[] = [];
+    for (const g of groups) {
+      const members = this.listGroupMembers(g);
+      result.push({ group: g, members: Array.isArray(members) ? members : [] });
+    }
+    return result;
+  }
+
+  static getUserGroups(username: string): string[] {
+    const allGroups = this.listGroups();
+    const userGroups: string[] = [];
+    for (const group of allGroups) {
+      const members = this.listGroupMembers(group);
+      if (Array.isArray(members) && members.includes(username)) {
+        userGroups.push(group);
+      }
+    }
+    return userGroups;
+  }
+
+  static listActiveSessions(): string[] {
+    const res = this.execCommand(
+      'powershell -Command "Get-LocalUser | Where-Object {$_.Enabled -eq $true} | Select-Object -ExpandProperty Name"'
+    );
+    if (!res.success || !res.output) return [];
+    return res.output
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean);
+  }
+
+  static currentUser(): string {
+    try {
+      return execSync("whoami", { encoding: "utf8" }).trim();
+    } catch (err) {
+      return String(err);
+    }
+  }
+}

package/packages/windows/src/windowsupdate.ts

@@ -0,0 +1,188 @@
+import { exec, execSync } from "child_process";
+
+type EnsureOptions = {
+  onInstallStart?: () => void;
+  onInstallSuccess?: () => void;
+  onInstallError?: (error: Error) => void;
+  installCommand?: string;
+};
+
+export type Parser<T> = (raw: string) => T;
+
+// Parser por defecto: intenta parsear a JSON, si falla retorna texto crudo
+function defaultParser<T = any>(raw: string): T {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw as any;
+  }
+}
+
+function ensurePSWindowsUpdate(options: EnsureOptions = {}): Promise<void> {
+  const {
+    onInstallStart,
+    onInstallSuccess,
+    onInstallError,
+    installCommand = 'powershell -Command "Install-Module -Name PSWindowsUpdate -Force -Confirm:$false"',
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    exec(
+      'powershell -Command "Get-Module -ListAvailable PSWindowsUpdate"',
+      (error, stdout) => {
+        if (error) return reject(error);
+
+        if (!stdout || !stdout.includes("PSWindowsUpdate")) {
+          if (onInstallStart) onInstallStart();
+
+          exec(installCommand, (installError) => {
+            if (installError) {
+              if (onInstallError) onInstallError(installError);
+              return reject(installError);
+            }
+
+            if (onInstallSuccess) onInstallSuccess();
+            resolve();
+          });
+        } else {
+          resolve();
+        }
+      }
+    );
+  });
+}
+
+class Async {
+  static async listInstalled<T = any>(
+    parser: Parser<T> = defaultParser
+  ): Promise<T> {
+    return new Promise((resolve, reject) => {
+      exec(
+        'powershell -Command "Get-HotFix | ConvertTo-Json -Compress"',
+        (error, stdout, stderr) => {
+          if (error) return reject(error);
+          resolve(parser(stdout || stderr || ""));
+        }
+      );
+    });
+  }
+
+  static async check<T = any>(
+    ensureOptions?: EnsureOptions,
+    parser: Parser<T> = defaultParser
+  ): Promise<T> {
+    await ensurePSWindowsUpdate(ensureOptions);
+
+    return new Promise((resolve, reject) => {
+      exec(
+        'powershell -Command "Get-WindowsUpdate | ConvertTo-Json -Compress"',
+        (error, stdout, stderr) => {
+          if (error) return reject(error);
+          resolve(parser(stdout || stderr || ""));
+        }
+      );
+    });
+  }
+
+  static async install<T = any>(
+    ensureOptions?: EnsureOptions,
+    parser: Parser<T> = defaultParser
+  ): Promise<T> {
+    await ensurePSWindowsUpdate(ensureOptions);
+
+    return new Promise((resolve, reject) => {
+      exec(
+        'powershell -Command "Install-WindowsUpdate -AcceptAll -AutoReboot | ConvertTo-Json -Compress"',
+        (error, stdout, stderr) => {
+          if (error) return reject(error);
+          resolve(parser(stdout || stderr || ""));
+        }
+      );
+    });
+  }
+
+  static async uninstall(
+    updateId: string,
+    ensureOptions?: EnsureOptions
+  ): Promise<string> {
+    await ensurePSWindowsUpdate(ensureOptions);
+
+    return new Promise((resolve, reject) => {
+      exec(
+        `powershell -Command "wusa /uninstall /kb:${updateId} /quiet /norestart"`,
+        (error, stdout, stderr) => {
+          if (error) return reject(error);
+          resolve(stdout || stderr);
+        }
+      );
+    });
+  }
+}
+
+class Sync {
+  static listInstalled<T = any>(parser: Parser<T> = defaultParser): T {
+    const raw = execSync(
+      'powershell -Command "Get-HotFix | ConvertTo-Json -Compress"'
+    ).toString();
+    return parser(raw);
+  }
+
+  static ensure(options: EnsureOptions = {}): void {
+    const {
+      onInstallStart,
+      onInstallSuccess,
+      onInstallError,
+      installCommand = 'powershell -Command "Install-Module -Name PSWindowsUpdate -Force -Confirm:$false"',
+    } = options;
+
+    const result = execSync(
+      'powershell -Command "Get-Module -ListAvailable PSWindowsUpdate"'
+    ).toString();
+
+    if (!result.includes("PSWindowsUpdate")) {
+      if (onInstallStart) onInstallStart();
+
+      try {
+        execSync(installCommand);
+        if (onInstallSuccess) onInstallSuccess();
+      } catch (err) {
+        if (onInstallError) onInstallError(err as Error);
+        throw err;
+      }
+    }
+  }
+
+  static check<T = any>(
+    options?: EnsureOptions,
+    parser: Parser<T> = defaultParser
+  ): T {
+    this.ensure(options);
+    const raw = execSync(
+      'powershell -Command "Get-WindowsUpdate | ConvertTo-Json -Compress"'
+    ).toString();
+    return parser(raw);
+  }
+
+  static install<T = any>(
+    options?: EnsureOptions,
+    parser: Parser<T> = defaultParser
+  ): T {
+    this.ensure(options);
+    const raw = execSync(
+      'powershell -Command "Install-WindowsUpdate -AcceptAll -AutoReboot | ConvertTo-Json -Compress"'
+    ).toString();
+    return parser(raw);
+  }
+
+  static uninstall(updateId: string, options?: EnsureOptions): string {
+    this.ensure(options);
+    return execSync(
+      `powershell -Command "wusa /uninstall /kb:${updateId} /quiet /norestart"`
+    ).toString();
+  }
+}
+
+export default class WindowsUpdate {
+  public static readonly Sync = Sync;
+  public static readonly Async = Async;
+}

package/packages/windows/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "lib": ["es2020", "DOM"],
+    "module": "esnext",
+    "moduleResolution": "node",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "baseUrl": ".",
+    "paths": {
+      "*": ["types/*"]
+    },
+    "typeRoots": ["./types", "../../node_modules/@types"],
+    "outDir": "./dist",
+    "types": ["node"],
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src"]
+}

package/packages/windows/typedoc.json

@@ -0,0 +1,18 @@
+{
+  "entryPoints": ["src/index.ts", "src/**/*.ts"],
+  "out": "docs",
+  "tsconfig": "tsconfig.json",
+  "excludePrivate": true,
+  "excludeProtected": true,
+  "excludeExternals": true,
+  "plugin": [
+    "typedoc-material-theme",
+    "typedoc-plugin-extras",
+    "typedoc-umlclass"
+  ],
+  "themeColor": "#007BFF",
+  "customTitle": "ManageOS",
+  "customDescription": "Documentation for ManageOS",
+  "footerLastModified": true,
+  "footerTypedocVersion": true
+}

package/packages/windows/types/regedit.d.ts

@@ -0,0 +1,9 @@
+declare module "regedit" {
+  type Callback<T = any> = (err: Error | null, result?: T) => void;
+  export function list(keys: string | string[], cb: Callback): void;
+  export function putValue(mapping: any, cb: Callback): void;
+  export function createKey(keys: string | string[], cb: Callback): void;
+  export function deleteKey(keys: string | string[], cb: Callback): void;
+  export function deleteValue(mapping: any, cb: Callback): void;
+  export const arch: { "32": string; "64": string };
+}