gpt-driver-node 1.0.0-alpha.1 → 1.0.0-alpha.11

package/dist/index.cjs

@@ -0,0 +1,367 @@
+'use strict';
+
+var axios = require('axios');
+var sharp = require('sharp');
+
+const delay = async (milliseconds) => {
+  await new Promise((resolve) => setTimeout(resolve, milliseconds));
+};
+function buildUrl(base, extraPath) {
+  let baseUrl = base.toString();
+  if (baseUrl.endsWith("/")) {
+    baseUrl = baseUrl.slice(0, -1);
+  }
+  if (!extraPath.startsWith("/")) {
+    extraPath = "/" + extraPath;
+  }
+  return `${baseUrl}${extraPath}`;
+}
+
+class GptDriver {
+  apiKey;
+  gptDriverSessionId;
+  gptDriverBaseUrl;
+  appiumSessionConfig;
+  driver;
+  /**
+   * Creates an instance of the GptDriver class.
+   *
+   * Initializes the GptDriver instance with the given configuration. This includes:
+   *
+   * - Setting the API key used for authenticating requests to the GPT Driver server.
+   * - Configuring the WebDriver instance if provided or validating server configuration if no WebDriver is given.
+   * - Setting up the Appium session configuration, including constructing the server URL and integrating device settings.
+   *
+   * @param {GptDriverConfig} config - The configuration object for initializing the GptDriver instance. This includes:
+   *                                    - `apiKey`: The API key for authenticating requests to the GPT Driver server.
+   *                                    - `driver` (optional): An existing WebDriver instance.
+   *                                    - `severConfig` (optional): Configuration for the Appium server, including URL and device settings.
+   * @throws {Error} If a WebDriver instance is provided without a server URL, or if neither a WebDriver instance nor
+   *                 a valid server configuration is supplied. A valid server configuration must include:
+   *                 - `url`: The URL of the server.
+   *                 - `device.platform`: The platform name of the device (e.g., iOS, Android).
+   */
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.gptDriverBaseUrl = "https://api.mobileboost.io";
+    this.initializeDriver(config);
+    this.initializeAppiumConfig(config);
+  }
+  initializeDriver(config) {
+    if (config.driver) {
+      this.driver = config.driver;
+      if (!config.serverConfig?.url) {
+        throw new Error("Server url is missing. Please specify the server url when providing a driver.");
+      }
+    } else {
+      const isValidServerConfig = config.serverConfig?.url && config.serverConfig.device?.platform;
+      if (!isValidServerConfig) {
+        throw new Error("Either provide a driver, or a valid severConfig object.");
+      }
+    }
+  }
+  initializeAppiumConfig(config) {
+    const defaultPort = parseInt(process.env.APPIUM_PORT ?? "4723", 10);
+    const defaultHost = process.env.APPIUM_HOST ?? "127.0.0.1";
+    let serverUrl = config.serverConfig?.url instanceof URL ? config.serverConfig.url : new URL(config.serverConfig?.url ?? `http://${defaultHost}:${defaultPort}`);
+    this.appiumSessionConfig = {
+      serverUrl,
+      ...config.serverConfig?.device
+    };
+  }
+  /**
+   * Starts a new GPTDriver session and initializes the Appium session.
+   * The session creation process is logged, and a link is provided to monitor the session's execution.
+   *
+   * @throws {Error} If the session cannot be started or the driver is not properly initialized.
+   */
+  async startSession() {
+    console.log(">> Starting session...");
+    if (this.driver) {
+      let platform;
+      let platformVersion;
+      let deviceName;
+      let sessionId;
+      if (this.driver.sessionId == null) {
+        const driver = this.driver;
+        const capabilities = await driver.getCapabilities();
+        platform = capabilities.get("platformName");
+        platformVersion = capabilities.get("platformVersion") ?? this.appiumSessionConfig?.platformVersion;
+        deviceName = this.appiumSessionConfig?.deviceName ?? capabilities.get("deviceName");
+        const session = await driver.getSession();
+        sessionId = session.getId();
+      } else {
+        const driver = this.driver;
+        platform = driver.capabilities["appium:platformName"] ?? driver.capabilities["platformName"];
+        platformVersion = driver.capabilities["appium:platformVersion"] ?? driver.capabilities["platformVersion"];
+        deviceName = this.appiumSessionConfig?.deviceName ?? driver.capabilities["appium:deviceName"] ?? driver.capabilities["deviceName"];
+        sessionId = driver.sessionId;
+      }
+      this.appiumSessionConfig = {
+        ...this.appiumSessionConfig,
+        id: sessionId,
+        platform,
+        platformVersion,
+        deviceName
+      };
+    } else {
+      this.appiumSessionConfig.id = await this.createSession();
+    }
+    await this.createGptDriverSession();
+    const url = buildUrl(this.appiumSessionConfig.serverUrl, `/session/${this.appiumSessionConfig.id}/window/rect`);
+    const rectResponse = await axios.get(
+      url
+    );
+    this.appiumSessionConfig.size = {
+      width: rectResponse.data.value.width,
+      height: rectResponse.data.value.height
+    };
+    console.log(`>> Session created. Monitor execution at: ${this.getSessionLink()}`);
+  }
+  async createSession() {
+    const { platform, deviceName, platformVersion, serverUrl } = this.appiumSessionConfig;
+    const url = buildUrl(serverUrl, `/session`);
+    const response = await axios.post(
+      url,
+      {
+        capabilities: {
+          alwaysMatch: {
+            platformName: platform,
+            "appium:automationName": platform === "iOS" ? "XCUITest" : "UiAutomator2",
+            "appium:deviceName": deviceName,
+            "appium:platformVersion": platformVersion
+          }
+        }
+      }
+    );
+    return response.data.value.sessionId;
+  }
+  async createGptDriverSession() {
+    const response = await axios.post(
+      `${this.gptDriverBaseUrl}/sessions/create`,
+      {
+        api_key: this.apiKey,
+        appium_session_id: this.appiumSessionConfig.id,
+        device_config: {
+          platform: this.appiumSessionConfig.platform,
+          device: this.appiumSessionConfig.deviceName,
+          os: this.appiumSessionConfig.platformVersion
+        }
+      }
+    );
+    this.gptDriverSessionId = response.data.sessionId;
+  }
+  getSessionLink() {
+    return `https://app.mobileboost.io/gpt-driver/sessions/${this.gptDriverSessionId}`;
+  }
+  /**
+   * Stops the current GPTDriver session and update its state.
+   *
+   * This method sends a request to the GPT Driver server to stop the session and logs the session status as either "failed" or "success."
+   *
+   * @param {"failed" | "success"} status - Indicates the outcome of the session.
+   *                                         Use "success" if the session completed as expected,
+   *                                         or "failed" if the session encountered an error or issue.
+   *
+   * @throws {Error} If the request to stop the session fails.
+   */
+  async stopSession(status) {
+    console.log(">> Stopping session...");
+    await axios.post(
+      `${this.gptDriverBaseUrl}/sessions/${this.gptDriverSessionId}/stop`,
+      {
+        api_key: this.apiKey,
+        status
+      }
+    );
+    const url = buildUrl(this.appiumSessionConfig.serverUrl, `/session/${this.appiumSessionConfig.id}`);
+    await axios.delete(url);
+    console.log(">> Session stopped.");
+    this.gptDriverSessionId = void 0;
+  }
+  /**
+   * Executes a specified command within the WebDriver session, optionally using an Appium handler.
+   *
+   * If an `appiumHandler` is provided, it will be invoked with the WebDriver instance to perform
+   * the command-specific operations. After executing the handler, the executed commands get logged on the GPTDriver servers.
+   * If the handler execution fails or no handler is provided, the command gets executed by the GPTDriver using just natural language.
+   *
+   * @param {string} command - The natural language command to be executed by the GPTDriver.
+   * @param {AppiumHandler} [appiumHandler] - An optional function that processes Appium-specific commands.
+   *                                          If provided, this handler is executed instead of calling the GPTDriver serves.
+   *
+   * @throws {Error} If an error occurs during the execution of the Appium handler or while processing the command by the GPTDriver.
+   */
+  async execute(command, appiumHandler) {
+    console.log(">> Executing command:", command);
+    const driver = this.driver;
+    if (appiumHandler != null) {
+      try {
+        await appiumHandler(driver);
+        const screenshot = await this.getScreenshot(this.appiumSessionConfig);
+        await axios.post(`${this.gptDriverBaseUrl}/sessions/${this.gptDriverSessionId}/log_code_execution`, {
+          api_key: this.apiKey,
+          base64_screenshot: screenshot,
+          command: appiumHandler.toString()
+        });
+      } catch (e) {
+        await this.gptHandler(command);
+      }
+    } else {
+      await this.gptHandler(command);
+    }
+  }
+  /**
+   * Asserts a single condition using the GPTDriver.
+   *
+   * This method sends an assertion request and verifies if the specified condition is met.
+   * If the assertion fails, an error is thrown.
+   *
+   * @param {string} assertion - The condition to be asserted.
+   * @throws {Error} If the assertion fails.
+   */
+  async assert(assertion) {
+    console.log(">> Asserting:", assertion);
+    const results = await this.checkBulk([assertion]);
+    if (!Object.values(results).at(0)) {
+      throw new Error(`Failed assertion: ${assertion}`);
+    }
+  }
+  /**
+   * Asserts multiple conditions using the GPTDriver.
+   *
+   * This method sends a bulk assertion request and verifies if all specified conditions are met.
+   * If any assertion fails, an error is thrown listing all failed assertions.
+   *
+   * @param {string[]} assertions - An array of conditions to be asserted.
+   * @throws {Error} If any of the assertions fail.
+   */
+  async assertBulk(assertions) {
+    console.log(">> Asserting:", assertions);
+    const results = await this.checkBulk(assertions);
+    const failedAssertions = Object.values(results).reduce((prev, current, currentIndex) => {
+      if (!current) {
+        return [...prev, assertions.at(currentIndex)];
+      }
+      return prev;
+    }, []);
+    if (failedAssertions.length > 0) {
+      throw new Error(`Failed assertions: ${failedAssertions.join(", ")}`);
+    }
+  }
+  /**
+   * Checks multiple conditions and returns their results using the GPTDriver.
+   *
+   * This method sends a bulk condition request and returns the results of the conditions.
+   *
+   * @param {string[]} conditions - An array of conditions to be checked.
+   * @returns {Promise<Record<string, boolean>>} A promise that resolves with an object mapping each condition
+   *                                             to a boolean indicating whether the condition was met.
+   */
+  async checkBulk(conditions) {
+    console.log(">> Checking:", conditions);
+    const screenshot = await this.getScreenshot(this.appiumSessionConfig);
+    const response = await axios.post(
+      `${this.gptDriverBaseUrl}/sessions/${this.gptDriverSessionId}/assert`,
+      {
+        api_key: this.apiKey,
+        base64_screenshot: screenshot,
+        assertions: conditions,
+        command: `Assert: ${JSON.stringify(conditions)}`
+      }
+    );
+    return response.data.results;
+  }
+  /**
+   * Extracts specified information using the GPTDriver.
+   *
+   * This method sends a request to perform data extraction based on
+   * the provided extraction criteria and returns the results of the extractions.
+   *
+   * @param {string[]} extractions - An array of extraction criteria. Each criterion specifies what information
+   *                                 should be extracted from the session.
+   * @returns {Promise<Record<string, any>>} A promise that resolves with an object mapping each extraction criterion
+   *                                         to the extracted data. The structure of the returned data depends on the
+   *                                         specifics of the extraction criteria.
+   */
+  async extract(extractions) {
+    console.log(">> Extracting:", extractions);
+    const screenshot = await this.getScreenshot(this.appiumSessionConfig);
+    const response = await axios.post(
+      `${this.gptDriverBaseUrl}/sessions/${this.gptDriverSessionId}/extract`,
+      {
+        api_key: this.apiKey,
+        base64_screenshot: screenshot,
+        extractions,
+        command: `Extract: ${JSON.stringify(extractions)}`
+      }
+    );
+    return response.data.results;
+  }
+  async gptHandler(command) {
+    try {
+      let conditionSucceeded = false;
+      while (!conditionSucceeded) {
+        const screenshot = await this.getScreenshot(this.appiumSessionConfig);
+        console.log(">> Asking GTP Driver for next action...");
+        const response = await axios.request(
+          {
+            url: `${this.gptDriverBaseUrl}/sessions/${this.gptDriverSessionId}/execute`,
+            method: "POST",
+            data: {
+              api_key: this.apiKey,
+              command,
+              base64_screenshot: screenshot
+            }
+          }
+        );
+        const executeStatus = response.data.status;
+        if (executeStatus === "failed") {
+          const errorMessage = response?.data?.commands?.at(0)?.data;
+          throw new Error(errorMessage ?? "Execution failed");
+        }
+        conditionSucceeded = executeStatus !== "inProgress";
+        const executeResponse = response.data;
+        for (const command2 of executeResponse.commands) {
+          await this.executeCommand(command2);
+        }
+        if (!conditionSucceeded) {
+          await delay(1500);
+        }
+      }
+    } catch (e) {
+      await this.stopSession("failed");
+      throw e;
+    }
+  }
+  async executeCommand(command) {
+    const firstAction = command.data.actions?.at(0);
+    if (firstAction?.type === "pause" && firstAction.duration != null) {
+      await delay(firstAction * 1e3);
+    } else {
+      const parsedUrl = new URL(command.url);
+      parsedUrl.protocol = this.appiumSessionConfig.serverUrl.protocol;
+      parsedUrl.host = this.appiumSessionConfig.serverUrl.host;
+      parsedUrl.port = this.appiumSessionConfig.serverUrl.port != "" ? `${this.appiumSessionConfig.serverUrl.port}` : "";
+      parsedUrl.pathname = this.appiumSessionConfig.serverUrl.pathname != "/" ? `${this.appiumSessionConfig.serverUrl.pathname}${parsedUrl.pathname}` : parsedUrl.pathname;
+      await axios.request({
+        url: parsedUrl.toString(),
+        method: command.method,
+        data: command.data
+      });
+    }
+  }
+  async getScreenshot(appiumSessionConfig) {
+    const url = buildUrl(this.appiumSessionConfig.serverUrl, `/session/${this.appiumSessionConfig.id}/screenshot`);
+    const screenshotResponse = await axios.get(url);
+    let screenshot = await screenshotResponse.data.value;
+    if (appiumSessionConfig.platform === "iOS") {
+      const imageBuffer = Buffer.from(screenshot, "base64");
+      const transformedImage = await sharp(imageBuffer).resize(appiumSessionConfig.size.width, appiumSessionConfig.size.height).toBuffer();
+      screenshot = transformedImage.toString("base64");
+    }
+    return screenshot;
+  }
+}
+
+module.exports = GptDriver;

package/dist/index.d.cts

@@ -0,0 +1,133 @@
+import { WebDriver } from 'selenium-webdriver';
+import { Browser } from 'webdriverio';
+
+type Platform = "iOS" | "Android";
+interface AppiumHandler {
+    (driver: WebDriver | Browser): Promise<any>;
+}
+interface ServerSessionInitConfig {
+    platform?: Platform;
+    deviceName?: string;
+    platformVersion?: string;
+}
+interface GptDriverConfig {
+    apiKey: string;
+    driver?: WebDriver | Browser;
+    serverConfig: {
+        device?: ServerSessionInitConfig;
+        url?: URL | string;
+    };
+}
+
+declare class GptDriver {
+    private apiKey;
+    private gptDriverSessionId?;
+    private gptDriverBaseUrl;
+    private appiumSessionConfig?;
+    private driver?;
+    /**
+     * Creates an instance of the GptDriver class.
+     *
+     * Initializes the GptDriver instance with the given configuration. This includes:
+     *
+     * - Setting the API key used for authenticating requests to the GPT Driver server.
+     * - Configuring the WebDriver instance if provided or validating server configuration if no WebDriver is given.
+     * - Setting up the Appium session configuration, including constructing the server URL and integrating device settings.
+     *
+     * @param {GptDriverConfig} config - The configuration object for initializing the GptDriver instance. This includes:
+     *                                    - `apiKey`: The API key for authenticating requests to the GPT Driver server.
+     *                                    - `driver` (optional): An existing WebDriver instance.
+     *                                    - `severConfig` (optional): Configuration for the Appium server, including URL and device settings.
+     * @throws {Error} If a WebDriver instance is provided without a server URL, or if neither a WebDriver instance nor
+     *                 a valid server configuration is supplied. A valid server configuration must include:
+     *                 - `url`: The URL of the server.
+     *                 - `device.platform`: The platform name of the device (e.g., iOS, Android).
+     */
+    constructor(config: GptDriverConfig);
+    private initializeDriver;
+    private initializeAppiumConfig;
+    /**
+     * Starts a new GPTDriver session and initializes the Appium session.
+     * The session creation process is logged, and a link is provided to monitor the session's execution.
+     *
+     * @throws {Error} If the session cannot be started or the driver is not properly initialized.
+     */
+    startSession(): Promise<void>;
+    private createSession;
+    private createGptDriverSession;
+    private getSessionLink;
+    /**
+     * Stops the current GPTDriver session and update its state.
+     *
+     * This method sends a request to the GPT Driver server to stop the session and logs the session status as either "failed" or "success."
+     *
+     * @param {"failed" | "success"} status - Indicates the outcome of the session.
+     *                                         Use "success" if the session completed as expected,
+     *                                         or "failed" if the session encountered an error or issue.
+     *
+     * @throws {Error} If the request to stop the session fails.
+     */
+    stopSession(status: "failed" | "success"): Promise<void>;
+    /**
+     * Executes a specified command within the WebDriver session, optionally using an Appium handler.
+     *
+     * If an `appiumHandler` is provided, it will be invoked with the WebDriver instance to perform
+     * the command-specific operations. After executing the handler, the executed commands get logged on the GPTDriver servers.
+     * If the handler execution fails or no handler is provided, the command gets executed by the GPTDriver using just natural language.
+     *
+     * @param {string} command - The natural language command to be executed by the GPTDriver.
+     * @param {AppiumHandler} [appiumHandler] - An optional function that processes Appium-specific commands.
+     *                                          If provided, this handler is executed instead of calling the GPTDriver serves.
+     *
+     * @throws {Error} If an error occurs during the execution of the Appium handler or while processing the command by the GPTDriver.
+     */
+    execute(command: string, appiumHandler?: AppiumHandler): Promise<void>;
+    /**
+     * Asserts a single condition using the GPTDriver.
+     *
+     * This method sends an assertion request and verifies if the specified condition is met.
+     * If the assertion fails, an error is thrown.
+     *
+     * @param {string} assertion - The condition to be asserted.
+     * @throws {Error} If the assertion fails.
+     */
+    assert(assertion: string): Promise<void>;
+    /**
+     * Asserts multiple conditions using the GPTDriver.
+     *
+     * This method sends a bulk assertion request and verifies if all specified conditions are met.
+     * If any assertion fails, an error is thrown listing all failed assertions.
+     *
+     * @param {string[]} assertions - An array of conditions to be asserted.
+     * @throws {Error} If any of the assertions fail.
+     */
+    assertBulk(assertions: string[]): Promise<void>;
+    /**
+     * Checks multiple conditions and returns their results using the GPTDriver.
+     *
+     * This method sends a bulk condition request and returns the results of the conditions.
+     *
+     * @param {string[]} conditions - An array of conditions to be checked.
+     * @returns {Promise<Record<string, boolean>>} A promise that resolves with an object mapping each condition
+     *                                             to a boolean indicating whether the condition was met.
+     */
+    checkBulk(conditions: string[]): Promise<any>;
+    /**
+     * Extracts specified information using the GPTDriver.
+     *
+     * This method sends a request to perform data extraction based on
+     * the provided extraction criteria and returns the results of the extractions.
+     *
+     * @param {string[]} extractions - An array of extraction criteria. Each criterion specifies what information
+     *                                 should be extracted from the session.
+     * @returns {Promise<Record<string, any>>} A promise that resolves with an object mapping each extraction criterion
+     *                                         to the extracted data. The structure of the returned data depends on the
+     *                                         specifics of the extraction criteria.
+     */
+    extract(extractions: string[]): Promise<any>;
+    private gptHandler;
+    private executeCommand;
+    private getScreenshot;
+}
+
+export { GptDriver as default };

package/dist/index.mjs

@@ -0,0 +1,365 @@
+import axios from 'axios';
+import sharp from 'sharp';
+
+const delay = async (milliseconds) => {
+  await new Promise((resolve) => setTimeout(resolve, milliseconds));
+};
+function buildUrl(base, extraPath) {
+  let baseUrl = base.toString();
+  if (baseUrl.endsWith("/")) {
+    baseUrl = baseUrl.slice(0, -1);
+  }
+  if (!extraPath.startsWith("/")) {
+    extraPath = "/" + extraPath;
+  }
+  return `${baseUrl}${extraPath}`;
+}
+
+class GptDriver {
+  apiKey;
+  gptDriverSessionId;
+  gptDriverBaseUrl;
+  appiumSessionConfig;
+  driver;
+  /**
+   * Creates an instance of the GptDriver class.
+   *
+   * Initializes the GptDriver instance with the given configuration. This includes:
+   *
+   * - Setting the API key used for authenticating requests to the GPT Driver server.
+   * - Configuring the WebDriver instance if provided or validating server configuration if no WebDriver is given.
+   * - Setting up the Appium session configuration, including constructing the server URL and integrating device settings.
+   *
+   * @param {GptDriverConfig} config - The configuration object for initializing the GptDriver instance. This includes:
+   *                                    - `apiKey`: The API key for authenticating requests to the GPT Driver server.
+   *                                    - `driver` (optional): An existing WebDriver instance.
+   *                                    - `severConfig` (optional): Configuration for the Appium server, including URL and device settings.
+   * @throws {Error} If a WebDriver instance is provided without a server URL, or if neither a WebDriver instance nor
+   *                 a valid server configuration is supplied. A valid server configuration must include:
+   *                 - `url`: The URL of the server.
+   *                 - `device.platform`: The platform name of the device (e.g., iOS, Android).
+   */
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.gptDriverBaseUrl = "https://api.mobileboost.io";
+    this.initializeDriver(config);
+    this.initializeAppiumConfig(config);
+  }
+  initializeDriver(config) {
+    if (config.driver) {
+      this.driver = config.driver;
+      if (!config.serverConfig?.url) {
+        throw new Error("Server url is missing. Please specify the server url when providing a driver.");
+      }
+    } else {
+      const isValidServerConfig = config.serverConfig?.url && config.serverConfig.device?.platform;
+      if (!isValidServerConfig) {
+        throw new Error("Either provide a driver, or a valid severConfig object.");
+      }
+    }
+  }
+  initializeAppiumConfig(config) {
+    const defaultPort = parseInt(process.env.APPIUM_PORT ?? "4723", 10);
+    const defaultHost = process.env.APPIUM_HOST ?? "127.0.0.1";
+    let serverUrl = config.serverConfig?.url instanceof URL ? config.serverConfig.url : new URL(config.serverConfig?.url ?? `http://${defaultHost}:${defaultPort}`);
+    this.appiumSessionConfig = {
+      serverUrl,
+      ...config.serverConfig?.device
+    };
+  }
+  /**
+   * Starts a new GPTDriver session and initializes the Appium session.
+   * The session creation process is logged, and a link is provided to monitor the session's execution.
+   *
+   * @throws {Error} If the session cannot be started or the driver is not properly initialized.
+   */
+  async startSession() {
+    console.log(">> Starting session...");
+    if (this.driver) {
+      let platform;
+      let platformVersion;
+      let deviceName;
+      let sessionId;
+      if (this.driver.sessionId == null) {
+        const driver = this.driver;
+        const capabilities = await driver.getCapabilities();
+        platform = capabilities.get("platformName");
+        platformVersion = capabilities.get("platformVersion") ?? this.appiumSessionConfig?.platformVersion;
+        deviceName = this.appiumSessionConfig?.deviceName ?? capabilities.get("deviceName");
+        const session = await driver.getSession();
+        sessionId = session.getId();
+      } else {
+        const driver = this.driver;
+        platform = driver.capabilities["appium:platformName"] ?? driver.capabilities["platformName"];
+        platformVersion = driver.capabilities["appium:platformVersion"] ?? driver.capabilities["platformVersion"];
+        deviceName = this.appiumSessionConfig?.deviceName ?? driver.capabilities["appium:deviceName"] ?? driver.capabilities["deviceName"];
+        sessionId = driver.sessionId;
+      }
+      this.appiumSessionConfig = {
+        ...this.appiumSessionConfig,
+        id: sessionId,
+        platform,
+        platformVersion,
+        deviceName
+      };
+    } else {
+      this.appiumSessionConfig.id = await this.createSession();
+    }
+    await this.createGptDriverSession();
+    const url = buildUrl(this.appiumSessionConfig.serverUrl, `/session/${this.appiumSessionConfig.id}/window/rect`);
+    const rectResponse = await axios.get(
+      url
+    );
+    this.appiumSessionConfig.size = {
+      width: rectResponse.data.value.width,
+      height: rectResponse.data.value.height
+    };
+    console.log(`>> Session created. Monitor execution at: ${this.getSessionLink()}`);
+  }
+  async createSession() {
+    const { platform, deviceName, platformVersion, serverUrl } = this.appiumSessionConfig;
+    const url = buildUrl(serverUrl, `/session`);
+    const response = await axios.post(
+      url,
+      {
+        capabilities: {
+          alwaysMatch: {
+            platformName: platform,
+            "appium:automationName": platform === "iOS" ? "XCUITest" : "UiAutomator2",
+            "appium:deviceName": deviceName,
+            "appium:platformVersion": platformVersion
+          }
+        }
+      }
+    );
+    return response.data.value.sessionId;
+  }
+  async createGptDriverSession() {
+    const response = await axios.post(
+      `${this.gptDriverBaseUrl}/sessions/create`,
+      {
+        api_key: this.apiKey,
+        appium_session_id: this.appiumSessionConfig.id,
+        device_config: {
+          platform: this.appiumSessionConfig.platform,
+          device: this.appiumSessionConfig.deviceName,
+          os: this.appiumSessionConfig.platformVersion
+        }
+      }
+    );
+    this.gptDriverSessionId = response.data.sessionId;
+  }
+  getSessionLink() {
+    return `https://app.mobileboost.io/gpt-driver/sessions/${this.gptDriverSessionId}`;
+  }
+  /**
+   * Stops the current GPTDriver session and update its state.
+   *
+   * This method sends a request to the GPT Driver server to stop the session and logs the session status as either "failed" or "success."
+   *
+   * @param {"failed" | "success"} status - Indicates the outcome of the session.
+   *                                         Use "success" if the session completed as expected,
+   *                                         or "failed" if the session encountered an error or issue.
+   *
+   * @throws {Error} If the request to stop the session fails.
+   */
+  async stopSession(status) {
+    console.log(">> Stopping session...");
+    await axios.post(
+      `${this.gptDriverBaseUrl}/sessions/${this.gptDriverSessionId}/stop`,
+      {
+        api_key: this.apiKey,
+        status
+      }
+    );
+    const url = buildUrl(this.appiumSessionConfig.serverUrl, `/session/${this.appiumSessionConfig.id}`);
+    await axios.delete(url);
+    console.log(">> Session stopped.");
+    this.gptDriverSessionId = void 0;
+  }
+  /**
+   * Executes a specified command within the WebDriver session, optionally using an Appium handler.
+   *
+   * If an `appiumHandler` is provided, it will be invoked with the WebDriver instance to perform
+   * the command-specific operations. After executing the handler, the executed commands get logged on the GPTDriver servers.
+   * If the handler execution fails or no handler is provided, the command gets executed by the GPTDriver using just natural language.
+   *
+   * @param {string} command - The natural language command to be executed by the GPTDriver.
+   * @param {AppiumHandler} [appiumHandler] - An optional function that processes Appium-specific commands.
+   *                                          If provided, this handler is executed instead of calling the GPTDriver serves.
+   *
+   * @throws {Error} If an error occurs during the execution of the Appium handler or while processing the command by the GPTDriver.
+   */
+  async execute(command, appiumHandler) {
+    console.log(">> Executing command:", command);
+    const driver = this.driver;
+    if (appiumHandler != null) {
+      try {
+        await appiumHandler(driver);
+        const screenshot = await this.getScreenshot(this.appiumSessionConfig);
+        await axios.post(`${this.gptDriverBaseUrl}/sessions/${this.gptDriverSessionId}/log_code_execution`, {
+          api_key: this.apiKey,
+          base64_screenshot: screenshot,
+          command: appiumHandler.toString()
+        });
+      } catch (e) {
+        await this.gptHandler(command);
+      }
+    } else {
+      await this.gptHandler(command);
+    }
+  }
+  /**
+   * Asserts a single condition using the GPTDriver.
+   *
+   * This method sends an assertion request and verifies if the specified condition is met.
+   * If the assertion fails, an error is thrown.
+   *
+   * @param {string} assertion - The condition to be asserted.
+   * @throws {Error} If the assertion fails.
+   */
+  async assert(assertion) {
+    console.log(">> Asserting:", assertion);
+    const results = await this.checkBulk([assertion]);
+    if (!Object.values(results).at(0)) {
+      throw new Error(`Failed assertion: ${assertion}`);
+    }
+  }
+  /**
+   * Asserts multiple conditions using the GPTDriver.
+   *
+   * This method sends a bulk assertion request and verifies if all specified conditions are met.
+   * If any assertion fails, an error is thrown listing all failed assertions.
+   *
+   * @param {string[]} assertions - An array of conditions to be asserted.
+   * @throws {Error} If any of the assertions fail.
+   */
+  async assertBulk(assertions) {
+    console.log(">> Asserting:", assertions);
+    const results = await this.checkBulk(assertions);
+    const failedAssertions = Object.values(results).reduce((prev, current, currentIndex) => {
+      if (!current) {
+        return [...prev, assertions.at(currentIndex)];
+      }
+      return prev;
+    }, []);
+    if (failedAssertions.length > 0) {
+      throw new Error(`Failed assertions: ${failedAssertions.join(", ")}`);
+    }
+  }
+  /**
+   * Checks multiple conditions and returns their results using the GPTDriver.
+   *
+   * This method sends a bulk condition request and returns the results of the conditions.
+   *
+   * @param {string[]} conditions - An array of conditions to be checked.
+   * @returns {Promise<Record<string, boolean>>} A promise that resolves with an object mapping each condition
+   *                                             to a boolean indicating whether the condition was met.
+   */
+  async checkBulk(conditions) {
+    console.log(">> Checking:", conditions);
+    const screenshot = await this.getScreenshot(this.appiumSessionConfig);
+    const response = await axios.post(
+      `${this.gptDriverBaseUrl}/sessions/${this.gptDriverSessionId}/assert`,
+      {
+        api_key: this.apiKey,
+        base64_screenshot: screenshot,
+        assertions: conditions,
+        command: `Assert: ${JSON.stringify(conditions)}`
+      }
+    );
+    return response.data.results;
+  }
+  /**
+   * Extracts specified information using the GPTDriver.
+   *
+   * This method sends a request to perform data extraction based on
+   * the provided extraction criteria and returns the results of the extractions.
+   *
+   * @param {string[]} extractions - An array of extraction criteria. Each criterion specifies what information
+   *                                 should be extracted from the session.
+   * @returns {Promise<Record<string, any>>} A promise that resolves with an object mapping each extraction criterion
+   *                                         to the extracted data. The structure of the returned data depends on the
+   *                                         specifics of the extraction criteria.
+   */
+  async extract(extractions) {
+    console.log(">> Extracting:", extractions);
+    const screenshot = await this.getScreenshot(this.appiumSessionConfig);
+    const response = await axios.post(
+      `${this.gptDriverBaseUrl}/sessions/${this.gptDriverSessionId}/extract`,
+      {
+        api_key: this.apiKey,
+        base64_screenshot: screenshot,
+        extractions,
+        command: `Extract: ${JSON.stringify(extractions)}`
+      }
+    );
+    return response.data.results;
+  }
+  async gptHandler(command) {
+    try {
+      let conditionSucceeded = false;
+      while (!conditionSucceeded) {
+        const screenshot = await this.getScreenshot(this.appiumSessionConfig);
+        console.log(">> Asking GTP Driver for next action...");
+        const response = await axios.request(
+          {
+            url: `${this.gptDriverBaseUrl}/sessions/${this.gptDriverSessionId}/execute`,
+            method: "POST",
+            data: {
+              api_key: this.apiKey,
+              command,
+              base64_screenshot: screenshot
+            }
+          }
+        );
+        const executeStatus = response.data.status;
+        if (executeStatus === "failed") {
+          const errorMessage = response?.data?.commands?.at(0)?.data;
+          throw new Error(errorMessage ?? "Execution failed");
+        }
+        conditionSucceeded = executeStatus !== "inProgress";
+        const executeResponse = response.data;
+        for (const command2 of executeResponse.commands) {
+          await this.executeCommand(command2);
+        }
+        if (!conditionSucceeded) {
+          await delay(1500);
+        }
+      }
+    } catch (e) {
+      await this.stopSession("failed");
+      throw e;
+    }
+  }
+  async executeCommand(command) {
+    const firstAction = command.data.actions?.at(0);
+    if (firstAction?.type === "pause" && firstAction.duration != null) {
+      await delay(firstAction * 1e3);
+    } else {
+      const parsedUrl = new URL(command.url);
+      parsedUrl.protocol = this.appiumSessionConfig.serverUrl.protocol;
+      parsedUrl.host = this.appiumSessionConfig.serverUrl.host;
+      parsedUrl.port = this.appiumSessionConfig.serverUrl.port != "" ? `${this.appiumSessionConfig.serverUrl.port}` : "";
+      parsedUrl.pathname = this.appiumSessionConfig.serverUrl.pathname != "/" ? `${this.appiumSessionConfig.serverUrl.pathname}${parsedUrl.pathname}` : parsedUrl.pathname;
+      await axios.request({
+        url: parsedUrl.toString(),
+        method: command.method,
+        data: command.data
+      });
+    }
+  }
+  async getScreenshot(appiumSessionConfig) {
+    const url = buildUrl(this.appiumSessionConfig.serverUrl, `/session/${this.appiumSessionConfig.id}/screenshot`);
+    const screenshotResponse = await axios.get(url);
+    let screenshot = await screenshotResponse.data.value;
+    if (appiumSessionConfig.platform === "iOS") {
+      const imageBuffer = Buffer.from(screenshot, "base64");
+      const transformedImage = await sharp(imageBuffer).resize(appiumSessionConfig.size.width, appiumSessionConfig.size.height).toBuffer();
+      screenshot = transformedImage.toString("base64");
+    }
+    return screenshot;
+  }
+}
+
+export { GptDriver as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gpt-driver-node",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0-alpha.11",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.cts",
@@ -10,15 +10,18 @@
     "watch": "tsx watch src/index.ts",
     "test": "jest"
   },
+  "type": "module",
   "keywords": [],
   "author": "MobileBoost",
   "license": "CC BY-NC-SA 4.0",
   "description": "Test your mobile apps with the AI native GPT Driver (docs.mobileboost.io).",
   "dependencies": {
-    "appium-xcuitest-driver": "^7.24.14",
+    "@types/selenium-webdriver": "^4.1.25",
+    "@wdio/types": "^9.0.4",
     "axios": "^1.7.3",
+    "selenium-webdriver": "^4.23.0",
     "sharp": "^0.33.4",
-    "webdriverio": "^8.40.0"
+    "webdriverio": "^9.0.7"
   },
   "devDependencies": {
     "tsx": "^4.16.5",

package/tsconfig.json

@@ -3,7 +3,8 @@
     "target": "ESNext",
     "module": "ESNext",
     "strict": true,
-//    "esModuleInterop": true,
+    "outDir": "./dist",
+    "esModuleInterop": true,
     "declaration": true,
     "moduleResolution": "node",
     "isolatedModules": true,

package/src/helpers.ts

@@ -1,31 +0,0 @@
-import sharp from "sharp";
-
-const delay = async (milliseconds: number): Promise<void> => {
-    await new Promise((resolve) => setTimeout(resolve, milliseconds));
-};
-
-
-const getScreenshot = async (driver: WebdriverIO.Browser, deviceSize: DeviceSize) => {
-    let screenshot = await driver.takeScreenshot();
-    if (driver.capabilities.platformName === "iOS") {
-        const imageBuffer = Buffer.from(screenshot, 'base64');
-        const transformedImage = await sharp(imageBuffer).resize(deviceSize.width, deviceSize.height).toBuffer()
-        screenshot = transformedImage.toString('base64')
-    }
-
-    return screenshot;
-}
-
-const delayIfNeeded = async (lastResponseTime?: number) => {
-    if (lastResponseTime == null) {
-        return;
-    }
-    const currentTime = Date.now();
-    const difference = currentTime - lastResponseTime;
-
-    if (difference < 1500) {
-        await delay(difference);
-    }
-}
-
-export {delay, getScreenshot, delayIfNeeded}

package/src/index.ts

@@ -1,151 +0,0 @@
-import axios from "axios";
-import {remote, RemoteOptions} from 'webdriverio'
-import {delay, delayIfNeeded, getScreenshot} from "./helpers";
-import {AppiumHandler, Command, DeviceConfig, DeviceSize, ExecuteResponse, GptDriverConfig} from "./types";
-
-class GptDriver {
-    apiKey: string;
-    baseUrl: string;
-    driver?: WebdriverIO.Browser;
-    deviceConfig?: DeviceConfig;
-    firestoreSessionId?: string;
-    deviceSize?: DeviceSize;
-    lastCommandExecutionTime?: number;
-
-    constructor(config: GptDriverConfig) {
-        this.apiKey = config.apiKey;
-        this.baseUrl = "https://api.mobileboost.io";
-
-        if (config.driver !== undefined) {
-            this.driver = config.driver
-        } else if (config.deviceConfig !== undefined) {
-            this.deviceConfig = config.deviceConfig;
-        } else {
-            throw new Error("Either provide an appium driver or a deviceConfig object")
-        }
-    }
-
-    async startSession() {
-        if (this.driver == undefined && this.deviceConfig != undefined) {
-            const capabilities = {
-                platformName: this.deviceConfig.platform,
-                'appium:automationName': this.deviceConfig.platform === "Android" ? 'UiAutomator2' : "XCUITest",
-                'appium:deviceName': this.deviceConfig.deviceName,
-            };
-
-            const wdOpts: RemoteOptions = {
-                hostname: process.env.APPIUM_HOST || 'localhost',
-                port: process.env.APPIUM_PORT != null ? parseInt(process.env.APPIUM_PORT, 10) : 4723,
-                logLevel: 'info',
-                capabilities: capabilities,
-            };
-
-            this.driver = await remote(wdOpts);
-        }
-
-
-        const driver = this.driver!;
-
-        const response = await axios.post(
-            `${this.baseUrl}/sessions/create`,
-            {
-                api_key: this.apiKey,
-                appium_session_id: driver.sessionId,
-                device_config: {
-                    // @ts-ignore
-                    platform: driver.capabilities.platformName,
-                    // @ts-ignore
-                    device: driver.capabilities.deviceName,
-                    // @ts-ignore
-                    os: driver.capabilities.platformVersion
-                },
-            },
-        )
-        const rect = await driver.getWindowRect();
-        this.deviceSize = {width: rect.width, height: rect.height}
-
-        this.firestoreSessionId = response.data.sessionId;
-
-    }
-
-    async stopSession({status}: { status: "failed" | "success" }) {
-        await axios.post(
-            `${this.baseUrl}/sessions/${this.firestoreSessionId}/stop`,
-            {
-                api_key: this.apiKey,
-                status,
-            },
-        )
-
-        this.firestoreSessionId = undefined;
-    }
-
-    async execute(command: string, appiumHandler?: AppiumHandler) {
-        const driver = this.driver!;
-
-        if (appiumHandler != null) {
-            try {
-                await appiumHandler(driver);
-            } catch (e) {
-                await this.gptHandler(command)
-            }
-        } else {
-            await this.gptHandler(command)
-        }
-    }
-
-    private async gptHandler(command: string) {
-        const driver = this.driver!;
-
-        try {
-            let conditionSucceeded = false;
-
-            while (!conditionSucceeded) {
-                await delayIfNeeded(this.lastCommandExecutionTime);
-                const screenshot = await getScreenshot(driver, this.deviceSize!)
-
-                const response = await axios.request({
-                        url: `${this.baseUrl}/sessions/${this.firestoreSessionId}/execute`,
-                        method: "POST",
-                        data: {
-                            api_key: this.apiKey,
-                            command,
-                            base64_screenshot: screenshot,
-                        },
-                    }
-                )
-                const executeStatus = response.data.status;
-                if (executeStatus === "failed") {
-                    throw new Error("Execution failed");
-                }
-
-                conditionSucceeded = executeStatus !== "inProgress";
-                const executeResponse: ExecuteResponse = response.data;
-                for (const command of executeResponse.commands) {
-                    await this.executeCommand(command)
-                }
-                this.lastCommandExecutionTime = Date.now();
-            }
-        } catch (e) {
-            await this.stopSession({status: "failed"})
-            throw e;
-        }
-
-    }
-
-    private async executeCommand(command: Command) {
-        const firstAction = command.data.actions?.at(0);
-        if (firstAction?.type === "pause" && firstAction.duration != null) {
-            await delay(firstAction * 1000)
-        } else {
-            await axios.request({
-                url: command.url,
-                method: command.method,
-                data: command.data
-            })
-        }
-
-    }
-}
-
-export default GptDriver;

package/src/types.ts

@@ -1,33 +0,0 @@
-interface ExecuteResponse {
-    commands: Command[]
-    status: "inProgress" | "success" | "failed"
-}
-
-interface Command {
-    method: 'GET' | 'DELETE' | 'POST';
-    url: string;
-    data: any;
-}
-
-interface AppiumHandler {
-    (driver: WebdriverIO.Browser): Promise<any>;
-}
-
-interface DeviceConfig {
-    platform: "iOS" | "Android";
-    deviceName?: string;
-    platformVersion?: string;
-}
-
-interface GptDriverConfig {
-    apiKey: string;
-    driver?: WebdriverIO.Browser;
-    deviceConfig?: DeviceConfig;
-}
-
-interface DeviceSize {
-    width: number,
-    height: number
-}
-
-export type {ExecuteResponse, Command, AppiumHandler, DeviceConfig, GptDriverConfig, DeviceSize}