@airtop/sdk 0.1.36 → 1.0.0-alpha2.1

package/dist/index.js

@@ -1,51 +1,1195 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports, module) {
+    module.exports = {
+      name: "@airtop/sdk",
+      description: "Airtop SDK for TypeScript",
+      version: "1.0.0-alpha2.1",
+      type: "module",
+      main: "./dist/index.cjs",
+      module: "./dist/index.js",
+      exports: {
+        import: {
+          types: "./dist/index.d.ts",
+          import: "./dist/index.js"
+        },
+        require: {
+          types: "./dist/index.d.cts",
+          require: "./dist/index.cjs"
+        }
+      },
+      types: "./dist/index.d.ts",
+      license: "MIT",
+      repository: "airtop-ai/airtop-sdk.git",
+      author: "Theo Gravity <theo@airtop.ai>",
+      keywords: [
+        "airtop",
+        "browser automation",
+        "ai",
+        "playwright",
+        "puppeteer",
+        "selenium",
+        "web scraping",
+        "agentic"
+      ],
+      scripts: {
+        "build:second-stage": "tsup src/index.ts",
+        "test:e2e": "vitest --run",
+        "build:dev": "node_modules/.bin/hash-runner",
+        clean: "rm -rf .turbo node_modules dist",
+        lint: "biome check --write --unsafe src && biome format src --write && biome lint src --fix",
+        "verify-types": "tsc --noEmit"
+      },
+      dependencies: {
+        "@airtop/json-schema-adapter": "workspace:*",
+        "@airtop/core": "0.1.0-alpha.17",
+        "date-fns": "4.1.0",
+        loglayer: "6.3.3",
+        "serialize-error": "12.0.0",
+        uuid: "11.1.0"
+      },
+      devDependencies: {
+        "@biomejs/biome": "1.9.4",
+        "@dotenvx/dotenvx": "1.39.0",
+        "@internal/tsconfig": "workspace:*",
+        "deep-utility-types": "1.3.1",
+        "env-var": "7.5.0",
+        "hash-runner": "2.0.1",
+        nanoid: "5.1.5",
+        tsup: "8.4.0",
+        typescript: "5.8.2",
+        "utility-types": "3.11.0",
+        uuid: "11.1.0",
+        vitest: "3.1.1",
+        zod: "*"
+      },
+      bugs: "https://github.com/airtop-ai/airtop-sdk/issues",
+      engines: {
+        node: ">=18"
+      },
+      files: [
+        "dist"
+      ],
+      homepage: "https://airtop.ai",
+      optionalDependencies: {
+        "@airtop/json-schema-adapter-zod": "workspace:*"
+      },
+      packageManager: "pnpm@10.5.0"
+    };
+  }
 });
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
+
+// src/AirtopBase.ts
+import { secondsToMilliseconds } from "date-fns";
+var AirtopBase = class {
+  /**
+   * Logger instance for the SDK
+   * @internal
+   **/
+  log;
+  /**
+   * Airtop Core SDK client instance
+   * @internal
+   **/
+  client;
+  /**
+   * JSON schema adapter for output conversion
+   * @internal
+   **/
+  outputJsonAdapter;
+  /**
+   * Creates a new instance of AirtopBase
+   * @param config - Configuration options for the SDK
+   */
+  constructor(config) {
+    this.log = config.log.withPrefix("[Airtop]");
+    this.client = config.client;
+    this.outputJsonAdapter = config.outputSchemaAdapter;
+  }
+  /**
+   * Returns the API key used by the SDK
+   * @returns API key string
+   */
+  getApiKey() {
+    return this.client.apiKey;
+  }
+  /**
+   * Sets the base URL for the Airtop API.
+   * @param airtopUrl - The base URL for the Airtop API
+   */
+  setAirtopUrl(airtopUrl) {
+    this.client.baseURL = airtopUrl;
+  }
+  /**
+   * Sets the API key for authentication.
+   * @param apiKey - The API key to use for authentication
+   */
+  setApiKey(apiKey) {
+    this.client.apiKey = apiKey;
+  }
+  /**
+   * Returns the LogLayer logger instance used by the SDK
+   * @returns Logger instance
+   * @see {@link https://loglayer.dev | LogLayer Documentation}
+   */
+  getLogger() {
+    return this.log;
+  }
+  /**
+   * Converts input data to JSON schema format
+   * @param input - Data to be converted (schema input, string, or object)
+   * @returns JSON string representation of the input
+   * @internal
+   */
+  convertToJsonSchema(input) {
+    if (input && this.outputJsonAdapter?.shouldRunConversion(input)) {
+      return JSON.stringify(this.outputJsonAdapter.toJsonSchema(input));
+    }
+    if (typeof input === "object") {
+      return JSON.stringify(input);
+    }
+    return input;
+  }
+  /**
+   * Returns the common configuration used by the SDK
+   * @returns Common configuration object
+   * @internal
+   */
+  getCommonConfig() {
+    return {
+      client: this.client,
+      log: this.log
+    };
+  }
+  /**
+   * Translates the request options to ones used by the Core SDK
+   * @param options - Request options to be resolved
+   * @returns Resolved request options with defaults
+   * @internal
+   */
+  resolveRequestOptions(options = {}) {
+    return {
+      timeout: secondsToMilliseconds(options.timeoutInSeconds || 60),
+      maxRetries: options.maxRetries || 0,
+      signal: options.abortSignal
+    };
+  }
+};
+
+// src/AirtopClient.ts
+import { Airtop as AirtopCore } from "@airtop/core";
+import { minutesToMilliseconds } from "date-fns/minutesToMilliseconds";
+import { ConsoleTransport, LogLayer } from "loglayer";
+import { serializeError } from "serialize-error";
+
+// src/logger-utils.ts
+var processLogMessage = (log, logLevel, ...args) => {
+  if (logLevel === "off") {
+    return;
+  }
+  const data = {};
+  let hasData = false;
+  let error = null;
+  const messages = [];
+  for (const arg of args) {
+    if (arg instanceof Error) {
+      error = arg;
+      continue;
+    }
+    if (typeof arg === "object" && arg !== null) {
+      Object.assign(data, arg);
+      hasData = true;
+      continue;
+    }
+    if (typeof arg === "string") {
+      messages.push(arg);
+    }
+  }
+  let finalMessage = messages.join(" ").trim();
+  if (finalMessage === "\u2A2F" && error) {
+    finalMessage = error?.message || "";
+  }
+  if (error && hasData && messages.length > 0) {
+    log.withError(error).withMetadata(data)[logLevel](finalMessage);
+  } else if (error && messages.length > 0) {
+    log.withError(error)[logLevel](finalMessage);
+  } else if (hasData && messages.length > 0) {
+    log.withMetadata(data)[logLevel](finalMessage);
+  } else if (error && hasData && messages.length === 0) {
+    log.withError(error).withMetadata(data)[logLevel]("");
+  } else if (error && messages.length === 0) {
+    log.errorOnly(error);
+  } else if (hasData && messages.length === 0) {
+    log.metadataOnly(data);
+  } else {
+    log[logLevel](finalMessage);
+  }
+};
+
+// src/session/AirtopSessionClient.ts
+import { NotFoundError } from "@airtop/core";
+
+// src/window/AirtopWindowClient.ts
+import { secondsToMilliseconds as secondsToMilliseconds2 } from "date-fns";
+
+// src/window/AirtopWindowScreenshot.ts
+function extractMimeAndBase64(dataUrl) {
+  const match = dataUrl.match(/^data:(image\/\w+);base64,(.+)$/);
+  if (match) {
+    return { mimeType: match[1], base64Data: match[2] };
+  }
+  return {
+    mimeType: "image/jpeg",
+    base64Data: dataUrl.replace(/^data:image\/jpeg;base64,/, "")
+  };
+}
+var AirtopWindowScreenshot = class {
+  data;
+  meta;
+  warnings;
+  errors;
+  /**
+   * Creates a new AirtopWindowScreenshot instance.
+   * @param screenshotData - Initial screenshot data and configuration
+   */
+  constructor(screenshotData) {
+    this.meta = screenshotData.meta;
+    this.data = screenshotData.data;
+    this.warnings = screenshotData.warnings;
+    this.errors = screenshotData.errors;
+  }
+  /**
+   * Processes the screenshots and returns them as JPG images.
+   */
+  screenshotsAsJpg() {
+    const screenshots = this.meta.screenshots;
+    if (!screenshots) {
+      return [];
+    }
+    return screenshots.map((screenshot, index) => {
+      if (!screenshot.dataUrl) {
+        return {
+          index,
+          error: new Error("Screenshot data URL not found"),
+          success: false
+        };
+      }
+      try {
+        const { mimeType, base64Data } = extractMimeAndBase64(screenshot.dataUrl);
+        const binaryData = Buffer.from(base64Data, "base64");
+        return {
+          index,
+          binaryData,
+          mimeType,
+          success: true
         };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LiveViewEventName = exports.AirtopClient = exports.AirtopTimeoutError = exports.AirtopError = exports.AirtopEnvironment = exports.Resources = exports.Airtop = void 0;
-exports.Airtop = __importStar(require("./api"));
-exports.Resources = __importStar(require("./api/resources"));
-var environments_1 = require("./environments");
-Object.defineProperty(exports, "AirtopEnvironment", { enumerable: true, get: function () { return environments_1.AirtopEnvironment; } });
-var errors_1 = require("./errors");
-Object.defineProperty(exports, "AirtopError", { enumerable: true, get: function () { return errors_1.AirtopError; } });
-Object.defineProperty(exports, "AirtopTimeoutError", { enumerable: true, get: function () { return errors_1.AirtopTimeoutError; } });
-var AirtopClient_1 = require("./wrapper/AirtopClient");
-Object.defineProperty(exports, "AirtopClient", { enumerable: true, get: function () { return AirtopClient_1.AirtopClient; } });
-var types_1 = require("./live-view/types");
-Object.defineProperty(exports, "LiveViewEventName", { enumerable: true, get: function () { return types_1.LiveViewEventName; } });
-__exportStar(require("./utils"), exports);
+      } catch (err) {
+        return {
+          index,
+          error: err instanceof Error ? err : new Error(String(err)),
+          success: false
+        };
+      }
+    });
+  }
+  /**
+   * Returns response data as a JSON object.
+   */
+  toJSON() {
+    return {
+      data: this.data,
+      meta: this.meta,
+      warnings: this.warnings,
+      errors: this.errors
+    };
+  }
+};
+
+// src/window/AirtopWindowClient.ts
+var AirtopWindowClient = class extends AirtopBase {
+  /**
+   * The browser session id
+   * @internal
+   */
+  sessionId;
+  /**
+   * The window id
+   * @internal
+   */
+  windowId;
+  /**
+   * Creates a new AirtopWindow instance.
+   * @param config - Common configuration options for the window
+   * @param sessionId - Browser session id
+   * @param windowId - Browser window id
+   */
+  constructor(config, sessionId, windowId) {
+    super(config);
+    this.log = this.log.child().withContext({
+      sessionId,
+      windowId
+    });
+    this.windowId = windowId;
+    this.sessionId = sessionId;
+  }
+  /**
+   * Gets the window ID.
+   */
+  getWindowId() {
+    return this.windowId;
+  }
+  /**
+   * Gets the browser session id associated with the window.
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Retrieves a window from a specific session.
+   * @param config - Configuration options for the window
+   * @param requestOptions - Request options
+   * @returns AirtopWindow<AirtopWindowGetInfoResponse> instance
+   */
+  async getWindowInfo(config, requestOptions = {}) {
+    const results = await this.client.windows.get(
+      this.windowId,
+      {
+        sessionId: this.sessionId,
+        ...config
+      },
+      this.resolveRequestOptions(requestOptions)
+    );
+    return new AirtopWindow(this.getCommonConfig(), this.sessionId, results);
+  }
+  /**
+   * Simulates a click on an element in the window.
+   * @param elementDescription - Description or selector of the element to click
+   * @param config - Additional configuration options for the click action
+   * @param requestOptions - Request options
+   * @returns Promise resolving to the click operation result
+   */
+  async click(elementDescription, config, requestOptions = {}) {
+    this.log.withMetadata({
+      elementDescription
+    }).info("Clicking on element");
+    return this.client.windows.click(
+      this.getWindowId(),
+      {
+        ...config,
+        elementDescription,
+        sessionId: this.sessionId
+      },
+      {
+        timeout: secondsToMilliseconds2(600),
+        ...this.resolveRequestOptions(requestOptions)
+      }
+    );
+  }
+  /**
+   * Closes the window.
+   * @returns Promise resolving when the window is closed
+   */
+  async close() {
+    this.log.info("Closing window");
+    return this.client.windows.close(this.getWindowId(), {
+      sessionId: this.sessionId
+    });
+  }
+  /**
+   * Simulates hovering over an element in the window.
+   * @param elementDescription - Description or selector of the element to hover over
+   * @param config - Additional configuration options for the hover action
+   * @param requestOptions - Request options
+   * @returns Promise resolving to the hover operation result
+   */
+  async hover(elementDescription, config, requestOptions = {}) {
+    this.log.withMetadata(config).info("Hovering over window");
+    return this.client.windows.hover(
+      this.getWindowId(),
+      {
+        elementDescription,
+        sessionId: this.sessionId,
+        ...config || {}
+      },
+      {
+        timeout: secondsToMilliseconds2(600),
+        ...this.resolveRequestOptions(requestOptions)
+      }
+    );
+  }
+  /**
+   * Loads a URL in the window.
+   * @param url - The URL to load
+   * @param config - Additional configuration options for loading the URL
+   * @param requestOptions - Request options
+   * @returns Promise resolving when the URL is loaded
+   */
+  async loadUrl(url, config, requestOptions = {}) {
+    this.log.withMetadata({
+      url
+    }).info("Loading a URL");
+    return this.client.windows.loadURL(
+      this.getWindowId(),
+      {
+        sessionId: this.sessionId,
+        url,
+        ...config
+      },
+      {
+        timeout: secondsToMilliseconds2(600),
+        ...this.resolveRequestOptions(requestOptions)
+      }
+    );
+  }
+  /**
+   * Monitors the window for changes or events.
+   * @param condition - A natural language description of the condition to monitor for in the browser window
+   * @param config - Configuration options for monitoring
+   * @param requestOptions - Request options
+   * @returns Promise resolving to the monitoring operation result
+   */
+  async monitor(condition, config, requestOptions = {}) {
+    this.log.withMetadata().info("Monitoring window");
+    return this.client.windows.monitor(
+      this.getWindowId(),
+      {
+        condition,
+        sessionId: this.sessionId,
+        ...config || {}
+      },
+      {
+        timeout: secondsToMilliseconds2(600),
+        ...this.resolveRequestOptions(requestOptions)
+      }
+    );
+  }
+  /**
+   * Performs a natural language query on the page content.
+   * @param prompt - The natural language query prompt
+   * @param config - Configuration options for the query
+   * @param requestOptions - Request options
+   * @returns Promise resolving to the query results
+   */
+  async pageQuery(prompt, config, requestOptions = {}) {
+    this.log.withMetadata({
+      prompt
+    }).info("Performing a page query");
+    const newConfig = config;
+    if (config?.configuration.outputSchema) {
+      newConfig.configuration.outputSchema = this.convertToJsonSchema(config.configuration.outputSchema);
+    }
+    return this.client.windows.pageQuery(
+      this.getWindowId(),
+      {
+        sessionId: this.sessionId,
+        prompt,
+        ...newConfig || {}
+      },
+      {
+        timeout: secondsToMilliseconds2(600),
+        ...this.resolveRequestOptions(requestOptions)
+      }
+    );
+  }
+  /**
+   * Performs paginated data extraction from the window content.
+   * @param prompt - The extraction prompt
+   * @param config - Configuration options for the extraction
+   * @param requestOptions - Request options
+   * @returns Promise resolving to the extracted data
+   */
+  async paginatedExtraction(prompt, config, requestOptions = {}) {
+    this.log.withMetadata({
+      prompt
+    }).info("Performing a paginated extraction");
+    const newConfig = config;
+    if (config?.configuration.outputSchema) {
+      newConfig.configuration.outputSchema = this.convertToJsonSchema(config.configuration.outputSchema);
+    }
+    return this.client.windows.paginatedExtraction(
+      this.getWindowId(),
+      {
+        prompt,
+        sessionId: this.sessionId,
+        ...newConfig || {}
+      },
+      {
+        timeout: secondsToMilliseconds2(600),
+        ...this.resolveRequestOptions(requestOptions)
+      }
+    );
+  }
+  /**
+   * Scrapes content from the window.
+   * @param config - Configuration options for scraping
+   * @param requestOptions - Request options
+   * @returns Promise resolving to the scraped content
+   */
+  async scrape(config, requestOptions = {}) {
+    this.log.info("Scraping window");
+    return this.client.windows.scrape(
+      this.getWindowId(),
+      {
+        sessionId: this.sessionId,
+        ...config || {}
+      },
+      {
+        timeout: secondsToMilliseconds2(600),
+        ...this.resolveRequestOptions(requestOptions)
+      }
+    );
+  }
+  /**
+   * Takes a screenshot of the window.
+   * @param config - Configuration options for the screenshot
+   * @param requestOptions - Request options
+   * @returns Promise resolving to the screenshot data
+   */
+  async screenshot(config, requestOptions = {}) {
+    this.log.info("Screenshotting window");
+    const resp = await this.client.windows.screenshot(
+      this.getWindowId(),
+      {
+        sessionId: this.sessionId,
+        ...config || {}
+      },
+      {
+        timeout: secondsToMilliseconds2(600),
+        ...this.resolveRequestOptions(requestOptions)
+      }
+    );
+    return new AirtopWindowScreenshot(resp);
+  }
+  /**
+   * Scrolls the window content.
+   * @param config - Configuration options for scrolling
+   * @param requestOptions - Request options
+   * @returns Promise resolving when the scroll operation is complete
+   */
+  async scroll(config, requestOptions = {}) {
+    this.log.info("Scrolling window");
+    return this.client.windows.scroll(
+      this.getWindowId(),
+      {
+        sessionId: this.sessionId,
+        ...config || {}
+      },
+      {
+        timeout: secondsToMilliseconds2(600),
+        ...this.resolveRequestOptions(requestOptions)
+      }
+    );
+  }
+  /**
+   * Types text into the window.
+   * @param text - The text to type
+   * @param config - Configuration options for typing
+   * @param requestOptions - Request options
+   * @returns Promise resolving when the text has been typed
+   */
+  async type(text, config, requestOptions = {}) {
+    this.log.withMetadata({
+      text
+    }).info("Typing text");
+    return this.client.windows.type(
+      this.getWindowId(),
+      {
+        sessionId: this.sessionId,
+        text,
+        ...config || {}
+      },
+      {
+        timeout: secondsToMilliseconds2(600),
+        ...this.resolveRequestOptions(requestOptions)
+      }
+    );
+  }
+};
+
+// src/window/AirtopWindow.ts
+var AirtopWindow = class extends AirtopWindowClient {
+  /**
+   * The window data containing window-specific information.
+   */
+  data;
+  /**
+   * The metadata associated with the window.
+   */
+  meta;
+  /**
+   * Warnings associated with the creation of the window.
+   * These are non-fatal issues that occurred during window creation.
+   */
+  warnings;
+  /**
+   * Errors that occurred during window creation or operation.
+   * These are fatal issues that prevented window creation.
+   */
+  errors;
+  /**
+   * Creates a new AirtopWindow instance.
+   * @param config - Common configuration options for the window
+   * @param sessionId - Browser session id
+   * @param windowData - Initial window data and configuration
+   */
+  constructor(config, sessionId, windowData) {
+    super(config, sessionId, windowData.data.windowId);
+    this.meta = windowData.meta;
+    this.data = windowData.data;
+    this.warnings = windowData.warnings;
+    this.errors = windowData.errors;
+  }
+  /**
+   * Returns response data as a JSON object.
+   */
+  toJSON() {
+    return {
+      data: this.data,
+      meta: this.meta,
+      warnings: this.warnings,
+      errors: this.errors
+    };
+  }
+};
+
+// src/session/AirtopSessionClient.ts
+var AirtopSessionClient = class extends AirtopBase {
+  /**
+   * The browser session id
+   * @internal
+   */
+  sessionId;
+  /**
+   * Creates a new AirtopSession instance.
+   * @param config - Common configuration options for the session
+   * @param sessionId - Browser session id
+   */
+  constructor(config, sessionId) {
+    super(config);
+    this.log = this.log.child().withContext({
+      sessionId
+    });
+    this.sessionId = sessionId;
+  }
+  /**
+   * Returns the browser session ID.
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Gets the state of the session using the attached session id.
+   * @param requestOptions - Request options
+   * @returns AirtopSession instance or null if not found
+   */
+  async getSessionInfo(requestOptions = {}) {
+    try {
+      const results = await this.client.sessions.get(this.sessionId, this.resolveRequestOptions(requestOptions));
+      return new AirtopSession(this.getCommonConfig(), {
+        data: results.data,
+        meta: results.meta,
+        warnings: results.warnings,
+        errors: results.errors
+      });
+    } catch (e) {
+      if (e instanceof NotFoundError) {
+        return null;
+      }
+      throw e;
+    }
+  }
+  /**
+   * Configures the session to save a profile when it terminates.
+   * @param profileName - Name of the profile to save
+   * @param requestOptions - Request options
+   */
+  async saveProfileOnTermination(profileName, requestOptions = {}) {
+    this.log.withMetadata({
+      profileName
+    }).info("Saving profile on termination");
+    await this.client.sessions.saveProfileOnTermination(
+      profileName,
+      {
+        sessionId: this.sessionId
+      },
+      this.resolveRequestOptions(requestOptions)
+    );
+  }
+  /**
+   * Waits for the session to be in a ready state.
+   * @returns The event indicating the session is ready
+   */
+  async waitForSessionReady() {
+    this.log.info("Waiting for session to be ready");
+    const sessionEvents = await this.client.sessions.getEvents(this.sessionId);
+    for await (const event of sessionEvents) {
+      this.log.withMetadata({
+        event
+      }).info("status message received");
+      const e = event;
+      if (e.event === "status" && e.status === "running") {
+        return event;
+      }
+    }
+  }
+  /**
+   * Terminates the current session.
+   * If the session is already terminated, this method will log a message and return.
+   */
+  async terminateSession() {
+    this.log.info("Terminating session");
+    await this.client.sessions.terminate(this.sessionId);
+  }
+  /**
+   * Creates a new window in the current session.
+   * @param url - The URL to load in the new window
+   * @param requestOptions - Request options
+   * @returns A new AirtopWindow<AirtopWindowCreateResponse> instance
+   */
+  async createWindow(url, requestOptions = {}) {
+    this.log.info("Creating window");
+    const results = await this.client.windows.create(
+      this.sessionId,
+      {
+        url
+      },
+      this.resolveRequestOptions(requestOptions)
+    );
+    return new AirtopWindow(this.getCommonConfig(), this.sessionId, results);
+  }
+  /**
+   * Returns a window client instance for making window-based requests for a given window id.
+   *
+   * @param windowId - The session ID to attach to the AirtopWindowClient instance
+   **/
+  withWindowId(windowId) {
+    return new AirtopWindowClient(this.getCommonConfig(), this.sessionId, windowId);
+  }
+  /**
+   * Creates a new file in the current session.
+   * @param fileName - The name of the file to create
+   * @param config - Additional configuration options for creating the file
+   * @param requestOptions - Request options
+   */
+  createFile(fileName, config = {}, requestOptions = {}) {
+    this.log.info("Creating file");
+    return this.client.files.createFile(
+      {
+        ...config,
+        fileName,
+        sessionId: this.sessionId
+      },
+      this.resolveRequestOptions(requestOptions)
+    );
+  }
+};
+
+// src/session/AirtopSession.ts
+var AirtopSession = class extends AirtopSessionClient {
+  /**
+   * The session data containing connection and state information.
+   * Includes details about the browser session and its configuration.
+   */
+  data;
+  /**
+   * The metadata associated with the session.
+   * Contains information about the request that created the session.
+   */
+  meta;
+  /**
+   * Warnings that occurred during session creation or operation.
+   * These are non-fatal issues that didn't prevent session creation.
+   */
+  warnings;
+  /**
+   * Errors that occurred during session creation or operation.
+   * These are fatal issues that prevented session creation.
+   */
+  errors;
+  /**
+   * Creates a new AirtopSession instance.
+   * @param config - Common configuration options for the session
+   * @param sessionData - Browser session data
+   */
+  constructor(config, sessionData) {
+    super(config, sessionData.data.id);
+    this.meta = sessionData.meta;
+    this.data = sessionData.data;
+    this.warnings = sessionData.warnings;
+    this.errors = sessionData.errors;
+  }
+  /**
+   * Returns response data as a JSON object.
+   */
+  toJSON() {
+    return {
+      data: this.data,
+      meta: this.meta,
+      warnings: this.warnings,
+      errors: this.errors
+    };
+  }
+};
+
+// src/AirtopClient.ts
+var version = require_package().version;
+var AirtopClient = class extends AirtopBase {
+  /**
+   * Creates a new instance of the Airtop SDK.
+   * @param config - Configuration options for the Airtop SDK
+   */
+  constructor(config) {
+    super({
+      logLevel: config?.logLevel,
+      client: new AirtopCore({
+        maxRetries: 0,
+        timeout: minutesToMilliseconds(1),
+        apiKey: config.apiKey,
+        baseURL: config?.airtopUrl,
+        logLevel: config?.logLevel || "off",
+        defaultHeaders: {
+          "x-airtop-sdk-source": "typescript",
+          "x-airtop-sdk-version": version
+        }
+      }),
+      log: config?.logger || new LogLayer({
+        errorSerializer: serializeError,
+        transport: new ConsoleTransport({
+          logger: console,
+          messageField: "message",
+          enabled: config.logLevel !== "off",
+          level: config.logLevel === "off" ? "error" : config.logLevel || "error"
+        }),
+        contextFieldName: "context",
+        metadataFieldName: "metadata"
+      }),
+      outputSchemaAdapter: config.outputSchemaAdapter
+    });
+    this.log.withPrefix("[Airtop SDK]");
+    this.client.logLevel = config.logLevel;
+    this.client.logger = {
+      debug: (message, ...rest) => {
+        processLogMessage(this.log, "debug", message, rest);
+      },
+      error: (message, ...rest) => {
+        processLogMessage(this.log, "error", message, rest);
+      },
+      info: (message, ...rest) => {
+        processLogMessage(this.log, "info", message, rest);
+      },
+      warn: (message, ...rest) => {
+        processLogMessage(this.log, "warn", message, rest);
+      }
+    };
+  }
+  /**
+   * Creates a new Airtop session.
+   * @param config - Configuration options for the session
+   * @param options - Request options
+   * @returns A new AirtopSession instance
+   */
+  async createSession(config, options = {}) {
+    const skipWaitSessionReady = config.skipWaitSessionReady ?? false;
+    delete config.skipWaitSessionReady;
+    const sessionResponse = await this.client.sessions.create(
+      {
+        configuration: config
+      },
+      options
+    );
+    const session = new AirtopSession(this.getCommonConfig(), sessionResponse);
+    if (skipWaitSessionReady) {
+      return session;
+    }
+    await session.waitForSessionReady();
+    return session;
+  }
+  /**
+   * Retrieves multiple sessions by their IDs.
+   * @param sessionIds - Array of session IDs to retrieve
+   * @param config - Configuration options for the request
+   * @param requestOptions - Request options
+   * @returns Object containing pagination info and array of AirtopSession instances
+   */
+  async getSessions(sessionIds, config, requestOptions = {}) {
+    const sessions = await this.client.sessions.list(
+      {
+        sessionIds,
+        limit: config.limit,
+        offset: config.offset,
+        status: config.status
+      },
+      this.resolveRequestOptions(requestOptions)
+    );
+    return {
+      pagination: sessions.data.pagination,
+      sessions: sessions.data.sessions.map(
+        (session) => new AirtopSession(this.getCommonConfig(), {
+          data: session
+        })
+      ),
+      errors: sessions.errors,
+      meta: sessions.meta,
+      warnings: sessions.warnings
+    };
+  }
+  /**
+   * Removes one or more profiles.
+   * @param profileNames - Name(s) of the profile(s) to remove
+   * @param requestOptions - Request options
+   */
+  async removeProfile(profileNames, requestOptions = {}) {
+    await this.client.profile.delete(
+      {
+        profileNames: Array.isArray(profileNames) ? profileNames : [profileNames]
+      },
+      this.resolveRequestOptions(requestOptions)
+    );
+  }
+  /**
+   * Retrieves a profile by name.
+   * @param profileName - Name of the profile to retrieve
+   * @param requestOptions - Request options
+   * @returns The profile
+   */
+  async getProfile(profileName, requestOptions = {}) {
+    return this.client.profile.get(profileName, this.resolveRequestOptions(requestOptions));
+  }
+  /**
+   * Renames a profile.
+   * @param sourceName - Current name of the profile
+   * @param targetName - New name for the profile
+   * @param requestOptions - Request options
+   */
+  async renameProfile(sourceName, targetName, requestOptions = {}) {
+    return this.client.profile.rename(
+      {
+        source: sourceName,
+        target: targetName
+      },
+      this.resolveRequestOptions(requestOptions)
+    );
+  }
+  /**
+   * Returns a session client instance for making session-based requests for a given session id.
+   *
+   * @param sessionId - The session ID to attach to the AirtopSessionClient instance
+   **/
+  withSessionId(sessionId) {
+    return new AirtopSessionClient(this.getCommonConfig(), sessionId);
+  }
+  /**
+   * Retrieves the status of a request.
+   * @param requestId - ID of the request to check
+   * @param requestOptions - Request options
+   * @returns Status of the request
+   */
+  async getRequestStatus(requestId, requestOptions = {}) {
+    this.log.withMetadata({
+      requestId
+    }).info("Getting request status");
+    return this.client.requests.getRequestStatus(requestId, this.resolveRequestOptions(requestOptions));
+  }
+  /**
+   * Gets a file by ID.
+   * @param fileId
+   * @param requestOptions
+   */
+  async getFile(fileId, requestOptions = {}) {
+    return this.client.files.get(fileId, this.resolveRequestOptions(requestOptions));
+  }
+  /**
+   * Lists files filtered by session IDs.
+   * @param sessionIds - Array of session IDs to retrieve files for
+   * @param config - Configuration options for the request
+   * @param requestOptions - Request options
+   * @returns Object containing pagination info and array of AirtopSession instances
+   */
+  async listFiles(sessionIds, config, requestOptions = {}) {
+    return this.client.files.list(
+      {
+        sessionIds,
+        limit: config.limit,
+        offset: config.offset
+      },
+      this.resolveRequestOptions(requestOptions)
+    );
+  }
+  /**
+   * Removes a file by ID.
+   * @param fileId - ID of the file to remove
+   * @param requestOptions - Request options
+   */
+  async removeFile(fileId, requestOptions = {}) {
+    return this.client.files.delete(fileId, this.resolveRequestOptions(requestOptions));
+  }
+  /**
+   * List all automations
+   * @param requestOptions - Request options
+   */
+  listAutomations(requestOptions = {}) {
+    return this.client.automations.list(this.resolveRequestOptions(requestOptions));
+  }
+  /**
+   * Update the description of a specific automation
+   * @param body - Request body
+   * @param requestOptions - Request options
+   */
+  updateAutomationDescription(body, requestOptions = {}) {
+    return this.client.automations.updateDescription(body, this.resolveRequestOptions(requestOptions));
+  }
+  /**
+   * Delete a specific automation
+   * @param automationID - ID of the automation to delete
+   * @param requestOptions - Request options
+   */
+  removeAutomation(automationID, requestOptions = {}) {
+    return this.client.automations.delete(automationID, this.resolveRequestOptions(requestOptions));
+  }
+};
+
+// src/plugin/AirtopPlugin.types.ts
+var AirtopPluginAugmentationType = /* @__PURE__ */ ((AirtopPluginAugmentationType2) => {
+  AirtopPluginAugmentationType2["AirtopClient"] = "AirtopClient";
+  AirtopPluginAugmentationType2["AirtopWindowClient"] = "AirtopWindowClient";
+  AirtopPluginAugmentationType2["AirtopWindow"] = "AirtopWindow";
+  AirtopPluginAugmentationType2["AirtopSessionClient"] = "AirtopSessionClient";
+  AirtopPluginAugmentationType2["AirtopSession"] = "AirtopSession";
+  AirtopPluginAugmentationType2["AirtopWindowScreenshot"] = "AirtopWindowScreenshot";
+  return AirtopPluginAugmentationType2;
+})(AirtopPluginAugmentationType || {});
+
+// src/plugin/AirtopPlugin.ts
+function registerAirtopPlugin(plugin) {
+  for (const pluginToAdd of plugin.pluginsToAdd) {
+    switch (pluginToAdd.augmentationType) {
+      case "AirtopClient" /* AirtopClient */:
+        pluginToAdd.augment(AirtopClient.prototype);
+        break;
+      case "AirtopSessionClient" /* AirtopSessionClient */:
+        pluginToAdd.augment(AirtopSessionClient.prototype);
+        break;
+      case "AirtopSession" /* AirtopSession */:
+        pluginToAdd.augment(AirtopSession.prototype);
+        break;
+      case "AirtopWindowClient" /* AirtopWindowClient */:
+        pluginToAdd.augment(AirtopWindowClient.prototype);
+        break;
+      case "AirtopWindow" /* AirtopWindow */:
+        pluginToAdd.augment(AirtopWindow.prototype);
+        break;
+      case "AirtopWindowScreenshot" /* AirtopWindowScreenshot */:
+        pluginToAdd.augment(AirtopWindowScreenshot.prototype);
+        break;
+    }
+  }
+}
+
+// src/AirtopMocks.ts
+import { Airtop as AirtopCore2 } from "@airtop/core";
+import { MockLogLayer } from "loglayer";
+import { v4 as uuidv4 } from "uuid";
+function createNoOpClient(client) {
+  return new Proxy(client, {
+    get(target, prop) {
+      const value = Reflect.get(target, prop);
+      if (typeof value === "function") {
+        return async () => ({
+          data: {},
+          meta: {},
+          warnings: [],
+          errors: []
+        });
+      }
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        return createNoOpClient(value);
+      }
+      return value;
+    }
+  });
+}
+function generateCommonAirtopConfigMock() {
+  const client = new AirtopCore2({
+    apiKey: "test-api-key"
+  });
+  return {
+    log: new MockLogLayer(),
+    client: createNoOpClient(client)
+  };
+}
+var AirtopMocks = class {
+  /**
+   * Creates an AirtopBase instance (the class used as the base for other Airtop classes) with a mock client and logger.
+   */
+  static getAirtopBaseMock(config = {}) {
+    return new AirtopBase({
+      ...generateCommonAirtopConfigMock(),
+      ...config
+    });
+  }
+  /**
+   * Creates an Airtop instance with a mock client and data.
+   */
+  static getAirtopClientMock(config = {}) {
+    const client = new AirtopClient({
+      apiKey: "test-api-key",
+      ...config
+    });
+    const mocks = generateCommonAirtopConfigMock();
+    client["log"] = mocks.log;
+    client["client"] = mocks.client;
+    return client;
+  }
+  /**
+   * Creates an AirtopSession instance with a mock client and data.
+   */
+  static getAirtopSessionMock(responseData = {}) {
+    return new AirtopSession(generateCommonAirtopConfigMock(), {
+      data: {
+        id: uuidv4(),
+        configuration: {},
+        chromedriverUrl: "http://localhost:9515",
+        status: "active"
+      },
+      meta: {},
+      warnings: [],
+      ...responseData
+    });
+  }
+  /**
+   * Creates an AirtopWindow instance with a mock client and data.
+   */
+  static getAirtopWindowMock({
+    sessionId,
+    windowData
+  } = {}) {
+    return new AirtopWindow(generateCommonAirtopConfigMock(), sessionId || uuidv4(), {
+      data: {
+        targetId: uuidv4(),
+        windowId: uuidv4(),
+        liveViewUrl: "http://localhost:4567"
+      },
+      meta: {},
+      warnings: [],
+      ...windowData || {}
+    });
+  }
+};
+export {
+  AirtopBase,
+  AirtopClient,
+  AirtopMocks,
+  AirtopPluginAugmentationType,
+  AirtopSession,
+  AirtopSessionClient,
+  AirtopWindow,
+  AirtopWindowClient,
+  AirtopWindowScreenshot,
+  registerAirtopPlugin
+};
+//# sourceMappingURL=index.js.map