@elizaos/computeruse 0.24.20 → 0.24.21

package/tests/locator-waitfor.test.js

@@ -1,286 +0,0 @@
-const { Desktop } = require("../index.js");
-
-/**
- * Test for Locator.waitFor() method with 'exists' condition
- */
-async function testWaitForExists() {
-  console.log("🕐 Testing Locator.waitFor('exists')...");
-
-  try {
-    const desktop = new Desktop();
-
-    // Get any available application for testing
-    const apps = desktop.applications();
-    if (apps.length === 0) {
-      throw new Error("No applications found for testing");
-    }
-
-    const testApp = apps[0];
-    console.log(`📱 Testing with app: ${testApp.name()}`);
-
-    // Test: Wait for a window to exist (should succeed immediately)
-    console.log("Test: Wait for window to exist");
-    const element = await desktop.locator("role:window").waitFor("exists", 5000);
-
-    if (!element) {
-      throw new Error("Expected element to be returned");
-    }
-
-    console.log(`✅ Found window: ${element.name()}`);
-    return true;
-  } catch (error) {
-    console.error("❌ WaitFor exists test failed:", error.message);
-    return false;
-  }
-}
-
-/**
- * Test waitFor() with 'visible' condition
- */
-async function testWaitForVisible() {
-  console.log("🕐 Testing Locator.waitFor('visible')...");
-
-  try {
-    const desktop = new Desktop();
-
-    // Test: Wait for a visible window
-    console.log("Test: Wait for window to be visible");
-    const element = await desktop.locator("role:window").waitFor("visible", 5000);
-
-    // Check that the element is actually visible
-    if (!element.isVisible()) {
-      throw new Error("Element should be visible");
-    }
-
-    console.log(`✅ Found visible window: ${element.name()}`);
-    return true;
-  } catch (error) {
-    console.error("❌ WaitFor visible test failed:", error.message);
-    return false;
-  }
-}
-
-/**
- * Test waitFor() timeout behavior
- */
-async function testWaitForTimeout() {
-  console.log("🕐 Testing Locator.waitFor() timeout...");
-
-  try {
-    const desktop = new Desktop();
-
-    // Test: Wait for a non-existent element (should timeout)
-    console.log("Test: Wait for non-existent element (expecting timeout)");
-    let timedOut = false;
-
-    try {
-      await desktop
-        .locator("role:button|ThisButtonDoesNotExist12345XYZ")
-        .waitFor("exists", 1000);
-    } catch (err) {
-      if (err.message.includes("Timed out") || err.message.includes("timeout")) {
-        timedOut = true;
-        console.log("✅ Correctly timed out");
-      } else {
-        throw new Error(`Unexpected error: ${err.message}`);
-      }
-    }
-
-    if (!timedOut) {
-      throw new Error("Expected timeout error");
-    }
-
-    return true;
-  } catch (error) {
-    console.error("❌ WaitFor timeout test failed:", error.message);
-    return false;
-  }
-}
-
-/**
- * Test waitFor() with different conditions
- */
-async function testWaitForConditions() {
-  console.log("🕐 Testing Locator.waitFor() with different conditions...");
-
-  try {
-    const desktop = new Desktop();
-
-    // Test each condition on a window (which should be visible and enabled)
-    const conditions = ["exists", "visible", "enabled"];
-
-    for (const condition of conditions) {
-      console.log(`Test: waitFor('${condition}')`);
-      const element = await desktop
-        .locator("role:window")
-        .waitFor(condition, 5000);
-
-      if (!element) {
-        throw new Error(`No element returned for condition '${condition}'`);
-      }
-
-      console.log(`✅ Condition '${condition}' met`);
-    }
-
-    return true;
-  } catch (error) {
-    console.error("❌ WaitFor conditions test failed:", error.message);
-    return false;
-  }
-}
-
-/**
- * Test waitFor() with invalid condition
- */
-async function testWaitForInvalidCondition() {
-  console.log("🕐 Testing Locator.waitFor() with invalid condition...");
-
-  try {
-    const desktop = new Desktop();
-
-    // Test: Invalid condition should throw error
-    console.log("Test: Wait with invalid condition");
-    let errorThrown = false;
-
-    try {
-      await desktop.locator("role:window").waitFor("invalid_condition", 1000);
-    } catch (err) {
-      if (err.message.includes("Invalid condition")) {
-        errorThrown = true;
-        console.log("✅ Correctly rejected invalid condition");
-      } else {
-        throw new Error(`Unexpected error: ${err.message}`);
-      }
-    }
-
-    if (!errorThrown) {
-      throw new Error("Expected error for invalid condition");
-    }
-
-    return true;
-  } catch (error) {
-    console.error("❌ WaitFor invalid condition test failed:", error.message);
-    return false;
-  }
-}
-
-/**
- * Test waitFor() with chaining
- */
-async function testWaitForChaining() {
-  console.log("🕐 Testing Locator.waitFor() with chaining...");
-
-  try {
-    const desktop = new Desktop();
-    const apps = desktop.applications();
-
-    if (apps.length === 0) {
-      throw new Error("No applications found for testing");
-    }
-
-    const testApp = apps[0];
-
-    // Test: Wait with chained locator
-    console.log("Test: waitFor with chained locator");
-    const element = await testApp
-      .locator("role:window")
-      .waitFor("visible", 3000);
-
-    console.log(`✅ Found element via chain: ${element.name()}`);
-    return true;
-  } catch (error) {
-    // This might fail if the app has no window, which is acceptable
-    if (error.message.includes("Timed out")) {
-      console.log("ℹ️  No window found in chain (acceptable)");
-      return true;
-    }
-    console.error("❌ WaitFor chaining test failed:", error.message);
-    return false;
-  }
-}
-
-/**
- * Main test runner
- */
-async function runWaitForTests() {
-  console.log("🚀 Starting Locator.waitFor() tests...\n");
-
-  let passed = 0;
-  let total = 0;
-
-  // Test 1: Wait for exists
-  total++;
-  if (await testWaitForExists()) {
-    passed++;
-  }
-
-  console.log(); // Empty line
-
-  // Test 2: Wait for visible
-  total++;
-  if (await testWaitForVisible()) {
-    passed++;
-  }
-
-  console.log(); // Empty line
-
-  // Test 3: Timeout behavior
-  total++;
-  if (await testWaitForTimeout()) {
-    passed++;
-  }
-
-  console.log(); // Empty line
-
-  // Test 4: Different conditions
-  total++;
-  if (await testWaitForConditions()) {
-    passed++;
-  }
-
-  console.log(); // Empty line
-
-  // Test 5: Invalid condition
-  total++;
-  if (await testWaitForInvalidCondition()) {
-    passed++;
-  }
-
-  console.log(); // Empty line
-
-  // Test 6: Chaining
-  total++;
-  if (await testWaitForChaining()) {
-    passed++;
-  }
-
-  console.log(); // Empty line
-
-  // Results
-  if (passed === total) {
-    console.log(`🎉 All waitFor tests passed! (${passed}/${total})`);
-    process.exit(0);
-  } else {
-    console.log(`❌ Some tests failed: ${passed}/${total} passed`);
-    process.exit(1);
-  }
-}
-
-// Export for use in other test files
-module.exports = {
-  testWaitForExists,
-  testWaitForVisible,
-  testWaitForTimeout,
-  testWaitForConditions,
-  testWaitForInvalidCondition,
-  testWaitForChaining,
-  runWaitForTests,
-};
-
-// Run tests if this file is executed directly
-if (require.main === module) {
-  runWaitForTests().catch((error) => {
-    console.error("💥 Test runner crashed:", error);
-    process.exit(1);
-  });
-}

package/wrapper.ts

@@ -1,394 +0,0 @@
-import * as native from "./index.js";
-import * as util from "util";
-import * as fs from "fs";
-import * as path from "path";
-
-// Type definitions for native classes
-type NativeClass =
-  | typeof native.Desktop
-  | typeof native.Element
-  | typeof native.Locator
-  | typeof native.Selector;
-
-function patchInspector(
-  Klass: any,
-  methodName = "toString",
-  forcePlainObject = false,
-): void {
-  if (!Klass || typeof Klass !== "function") {
-    console.log("inspect not a function");
-    return;
-  }
-  const proto = Klass.prototype;
-  const original = proto[util.inspect.custom];
-  proto[util.inspect.custom] = function (...args: any[]) {
-    if (typeof this[methodName] === "function") {
-      const result = this[methodName](...args);
-      if (forcePlainObject && result && typeof result === "object") {
-        return { ...result };
-      }
-      return result;
-    }
-    if (typeof original === "function") {
-      return original.apply(this, args);
-    }
-    return { ...this };
-  };
-}
-
-function wrapNativeFunction<T extends Function>(fn: T): T {
-  if (typeof fn !== "function") return fn;
-  return function (this: any, ...args: any[]) {
-    try {
-      const result = fn.apply(this, args);
-      if (result instanceof Promise) {
-        return result.catch((error) => {
-          throw mapNativeError(error);
-        });
-      }
-      return result;
-    } catch (error) {
-      throw mapNativeError(error);
-    }
-  } as any;
-}
-
-function wrapClassMethods<T extends NativeClass>(Class: T): T {
-  const prototype = Class.prototype;
-  const methods = Object.getOwnPropertyNames(prototype);
-  methods.forEach((method) => {
-    if (method !== "constructor" && typeof prototype[method] === "function") {
-      prototype[method] = wrapNativeFunction(prototype[method]);
-    }
-  });
-  return Class;
-}
-
-function wrapClass<T extends NativeClass>(
-  Class: T,
-  ...inspectOptions: any[]
-): T {
-  const Wrapped = wrapClassMethods(Class);
-  patchInspector(Wrapped, ...(inspectOptions || []));
-  return Wrapped;
-}
-
-// Custom error classes
-export class ElementNotFoundError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "ElementNotFoundError";
-  }
-}
-
-export class TimeoutError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "TimeoutError";
-  }
-}
-
-export class PermissionDeniedError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "PermissionDeniedError";
-  }
-}
-
-export class PlatformError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "PlatformError";
-  }
-}
-
-export class UnsupportedOperationError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "UnsupportedOperationError";
-  }
-}
-
-export class UnsupportedPlatformError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "UnsupportedPlatformError";
-  }
-}
-
-export class InvalidArgumentError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "InvalidArgumentError";
-  }
-}
-
-export class InternalError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "InternalError";
-  }
-}
-
-// Error mapping function
-function mapNativeError(error: any): Error {
-  if (!error.message) return error;
-
-  const message = error.message;
-  if (message.startsWith("ELEMENT_NOT_FOUND:")) {
-    return new ElementNotFoundError(
-      message.replace("ELEMENT_NOT_FOUND:", "").trim(),
-    );
-  }
-  if (message.startsWith("OPERATION_TIMED_OUT:")) {
-    return new TimeoutError(message.replace("OPERATION_TIMED_OUT:", "").trim());
-  }
-  if (message.startsWith("PERMISSION_DENIED:")) {
-    return new PermissionDeniedError(
-      message.replace("PERMISSION_DENIED:", "").trim(),
-    );
-  }
-  if (message.startsWith("PLATFORM_ERROR:")) {
-    return new PlatformError(message.replace("PLATFORM_ERROR:", "").trim());
-  }
-  if (message.startsWith("UNSUPPORTED_OPERATION:")) {
-    return new UnsupportedOperationError(
-      message.replace("UNSUPPORTED_OPERATION:", "").trim(),
-    );
-  }
-  if (message.startsWith("UNSUPPORTED_PLATFORM:")) {
-    return new UnsupportedPlatformError(
-      message.replace("UNSUPPORTED_PLATFORM:", "").trim(),
-    );
-  }
-  if (message.startsWith("INVALID_ARGUMENT:")) {
-    return new InvalidArgumentError(
-      message.replace("INVALID_ARGUMENT:", "").trim(),
-    );
-  }
-  if (message.startsWith("INTERNAL_ERROR:")) {
-    return new InternalError(message.replace("INTERNAL_ERROR:", "").trim());
-  }
-  return error;
-}
-
-// Types for executeBrowserScript arguments
-export type BrowserScriptEnv = Record<string, unknown>;
-export type BrowserScriptFunction = (env?: BrowserScriptEnv) => any;
-export type BrowserScriptOptions = {
-  file: string;
-  env?: BrowserScriptEnv;
-};
-type BrowserScriptInput = string | BrowserScriptFunction | BrowserScriptOptions;
-
-// Enhanced executeBrowserScript with function and file support
-// Desktop signature: (script, process, timeoutMs?)
-// Element signature: (script)
-async function enhancedExecuteBrowserScript(
-  this: any,
-  scriptOrFunction: BrowserScriptInput,
-  processOrEnv?: string | any,
-  timeoutMs?: number,
-): Promise<any> {
-  // Detect if this is Desktop or Element
-  // Can't use .length on napi functions (always returns 0), so check constructor name
-  const isDesktop = this.constructor?.name === 'Desktop';
-
-  // For Desktop: second param is process name, third is timeout
-  // For Element: second param is env options (backward compatible)
-  let process: string | undefined;
-  let envOrOptions: any;
-
-  if (isDesktop) {
-    if (typeof processOrEnv !== 'string') {
-      throw new Error(
-        "Desktop.executeBrowserScript requires 'process' as second argument (e.g., 'chrome', 'msedge', 'firefox'). " +
-        "Usage: desktop.executeBrowserScript(script, 'chrome', timeoutMs?)"
-      );
-    }
-    process = processOrEnv;
-  } else {
-    // Element - second param is env options
-    envOrOptions = processOrEnv;
-  }
-  let script: string;
-  let env: any = {};
-  let shouldInjectEnv = false; // Only inject env for file-based and string scripts, not functions
-
-  // Handle different input types
-  if (typeof scriptOrFunction === "string") {
-    // Check if it's a file path
-    if (scriptOrFunction.endsWith(".ts") || scriptOrFunction.endsWith(".js")) {
-      // File path - read and compile
-      const filePath = path.resolve(scriptOrFunction);
-      if (!fs.existsSync(filePath)) {
-        throw new Error(`Browser script file not found: ${filePath}`);
-      }
-
-      let fileContent = fs.readFileSync(filePath, "utf-8");
-
-      // If TypeScript, compile it
-      if (filePath.endsWith(".ts")) {
-        try {
-          const esbuild = require("esbuild");
-          const result = await esbuild.transform(fileContent, {
-            loader: "ts",
-            target: "es2020",
-            format: "iife",
-          });
-          fileContent = result.code;
-        } catch (e: any) {
-          // If esbuild not available, try to use as-is (may work for simple TS)
-          console.warn(
-            "esbuild not found - using TypeScript file as-is:",
-            e.message,
-          );
-        }
-      }
-
-      script = fileContent;
-      env = envOrOptions || {};
-      shouldInjectEnv = true; // Inject env for file paths passed as strings
-    } else {
-      // Plain string script - use as-is (backward compatible)
-      script = scriptOrFunction;
-    }
-  } else if (typeof scriptOrFunction === "function") {
-    // Function - convert to IIFE with proper wrapping
-    const funcString = scriptOrFunction.toString();
-    env = envOrOptions || {};
-
-    // Wrap function in IIFE that handles return values
-    script = `
-      (async function() {
-        const fn = ${funcString};
-        const result = await fn(${JSON.stringify(env)});
-
-        // Auto-stringify result if it's an object
-        if (result !== undefined && result !== null) {
-          if (typeof result === 'object') {
-            return JSON.stringify(result);
-          }
-          return String(result);
-        }
-        return "undefined";
-      })()
-    `;
-  } else if (
-    typeof scriptOrFunction === "object" &&
-    (scriptOrFunction as BrowserScriptOptions).file
-  ) {
-    // Object with file property
-    const options = scriptOrFunction as BrowserScriptOptions;
-    const filePath = path.resolve(options.file);
-    if (!fs.existsSync(filePath)) {
-      throw new Error(`Browser script file not found: ${filePath}`);
-    }
-
-    let fileContent = fs.readFileSync(filePath, "utf-8");
-
-    // If TypeScript, compile it
-    if (filePath.endsWith(".ts")) {
-      try {
-        const esbuild = require("esbuild");
-        const result = await esbuild.transform(fileContent, {
-          loader: "ts",
-          target: "es2020",
-          format: "iife",
-        });
-        fileContent = result.code;
-      } catch (e: any) {
-        console.warn(
-          "esbuild not found - using TypeScript file as-is:",
-          e.message,
-        );
-      }
-    }
-
-    script = fileContent;
-    env = options.env || {};
-    shouldInjectEnv = true; // Inject env for file option objects
-  } else {
-    throw new Error(
-      "Invalid argument to executeBrowserScript: expected string, function, or {file, env} object",
-    );
-  }
-
-  // If env variables are provided and we should inject them (file-based scripts only)
-  if (shouldInjectEnv && env && Object.keys(env).length > 0) {
-    // Inject as an env object that scripts can access
-    const envObject = `const env = ${JSON.stringify(env)};`;
-    script = `${envObject}\n${script}`;
-  }
-
-  // Call the original native method
-  // Desktop requires (script, process, timeoutMs?), Element only needs (script)
-  const resultStr = isDesktop
-    ? await this._originalExecuteBrowserScript(script, process, timeoutMs)
-    : await this._originalExecuteBrowserScript(script);
-
-  // If function was passed, try to parse JSON result
-  if (typeof scriptOrFunction === "function") {
-    try {
-      return JSON.parse(resultStr);
-    } catch (e) {
-      // Not JSON, return as-is
-      return resultStr;
-    }
-  }
-
-  // For string/file, return raw result (backward compatible)
-  return resultStr;
-}
-
-// Wrap the native classes
-export const Desktop = wrapClassMethods(native.Desktop);
-export const Element = wrapClass(native.Element);
-export const Locator = wrapClass(native.Locator);
-export const Selector = wrapClass(native.Selector);
-export const WindowManager = wrapClassMethods(native.WindowManager);
-
-// Patch executeBrowserScript on Desktop and Element
-if (Desktop.prototype.executeBrowserScript) {
-  (Desktop.prototype as any)._originalExecuteBrowserScript =
-    Desktop.prototype.executeBrowserScript;
-  Desktop.prototype.executeBrowserScript = enhancedExecuteBrowserScript;
-}
-
-if (Element.prototype.executeBrowserScript) {
-  (Element.prototype as any)._originalExecuteBrowserScript =
-    Element.prototype.executeBrowserScript;
-  Element.prototype.executeBrowserScript = enhancedExecuteBrowserScript;
-}
-
-// Re-export native types
-export type {
-  ValidationResult,
-  Bounds,
-  Coordinates,
-  ClickResult,
-  CommandOutput,
-  Monitor,
-  MonitorScreenshotPair,
-  ScreenshotResult,
-  UIElementAttributes,
-  UINode,
-  WindowInfo,
-  ActionOptions,
-  TypeTextOptions,
-  PressKeyOptions,
-  // Computer Use types
-  ComputerUseResult,
-  ComputerUseStep,
-  ComputerUsePendingConfirmation,
-} from "./index.js";
-export {
-  ClickType,
-  ClusteredBoundsEntry,
-  ClusteredFormattingResult,
-  ElementSource,
-  PropertyLoadingMode,
-  TextPosition,
-  TreeOutputFormat,
-  VisionType,
-} from "./index.js";