@airtop/sdk 0.1.6 → 0.1.7

package/dist/utils/batch-operate/SessionQueue.js

@@ -0,0 +1,223 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionQueue = void 0;
+const helpers_1 = require("./helpers");
+const WindowQueue_1 = require("./WindowQueue");
+const async_mutex_1 = require("async-mutex");
+class SessionQueue {
+    constructor({ maxConcurrentSessions, runEmitter, maxWindowsPerSession, initialBatches, operation, client, sessionConfig, onError, }) {
+        this.activePromises = [];
+        this.activePromisesMutex = new async_mutex_1.Mutex();
+        this.initialBatches = [];
+        this.batchQueue = [];
+        this.batchQueueMutex = new async_mutex_1.Mutex();
+        this.latestProcessingPromise = null;
+        this.processingPromisesCount = 0;
+        this.sessionPool = [];
+        this.sessionPoolMutex = new async_mutex_1.Mutex();
+        if (!Number.isInteger(maxConcurrentSessions) ||
+            maxConcurrentSessions <= 0) {
+            throw new Error("maxConcurrentSessions must be a positive integer");
+        }
+        this.maxConcurrentSessions = maxConcurrentSessions;
+        this.runEmitter = runEmitter;
+        this.maxWindowsPerSession = maxWindowsPerSession;
+        this.sessionConfig = sessionConfig;
+        this.initialBatches = initialBatches;
+        this.operation = operation;
+        this.onError = onError;
+        this.latestProcessingPromise = null;
+        this.results = [];
+        this.client = client;
+        this.isHalted = false;
+    }
+    handleHaltEvent() {
+        this.client.log("Halt event received");
+        this.isHalted = true;
+    }
+    addUrlsToBatchQueue(newBatch) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Distribute new URLs across batches
+            const newBatches = (0, helpers_1.distributeUrlsToBatches)(newBatch, this.maxConcurrentSessions);
+            this.client.log(`Adding new batches to queue: ${JSON.stringify(newBatches)}`);
+            // Add new batches to the queue
+            yield this.batchQueueMutex.runExclusive(() => {
+                this.batchQueue.push(...newBatches);
+            });
+            // Update existing processing promise
+            this.processingPromisesCount++;
+            this.latestProcessingPromise = this.processPendingBatches();
+        });
+    }
+    processInitialBatches() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.batchQueueMutex.runExclusive(() => {
+                this.batchQueue = [...this.initialBatches];
+            });
+            this.processingPromisesCount++;
+            this.runEmitter.on("halt", this.handleHaltEvent.bind(this));
+            this.latestProcessingPromise = this.processPendingBatches();
+            yield this.latestProcessingPromise;
+        });
+    }
+    waitForProcessingToComplete() {
+        return __awaiter(this, void 0, void 0, function* () {
+            while (this.processingPromisesCount > 0) {
+                yield this.latestProcessingPromise;
+            }
+            yield this.terminateAllSessions();
+            this.runEmitter.removeListener("halt", this.handleHaltEvent);
+            return this.results;
+        });
+    }
+    terminateAllSessions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const sessionId of this.sessionPool) {
+                this.safelyTerminateSession(sessionId);
+            }
+        });
+    }
+    processPendingBatches() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                while (this.batchQueue.length > 0) {
+                    // Wait for any session to complete before starting a new one
+                    let shouldContinue = false;
+                    yield this.activePromisesMutex.runExclusive(() => __awaiter(this, void 0, void 0, function* () {
+                        if (this.activePromises.length >= this.maxConcurrentSessions) {
+                            yield Promise.race(this.activePromises);
+                            shouldContinue = true;
+                        }
+                    }));
+                    if (shouldContinue)
+                        continue;
+                    let batch;
+                    yield this.batchQueueMutex.runExclusive(() => {
+                        batch = this.batchQueue.shift();
+                    });
+                    if (!batch || batch.length === 0)
+                        break;
+                    const promise = (() => __awaiter(this, void 0, void 0, function* () {
+                        if (this.isHalted) {
+                            this.client.log("Halt event received, skipping batch");
+                            return;
+                        }
+                        let sessionId;
+                        try {
+                            // Check if there's an available session in the pool
+                            yield this.sessionPoolMutex.runExclusive(() => {
+                                if (this.sessionPool.length > 0) {
+                                    sessionId = this.sessionPool.pop();
+                                }
+                            });
+                            // Otherwise, create a new session
+                            if (!sessionId) {
+                                const { data: session, warnings, errors } = yield this.client.sessions.create({
+                                    configuration: this.sessionConfig,
+                                });
+                                sessionId = session.id;
+                                this.handleErrorAndWarningResponses({ warnings, errors, sessionId, batch });
+                            }
+                            const queue = new WindowQueue_1.WindowQueue(this.maxWindowsPerSession, this.runEmitter, sessionId, this.client, this.operation, this.onError, this.isHalted);
+                            const windowResults = yield queue.processInBatches(batch);
+                            this.results.push(...windowResults);
+                            // Return the session to the pool
+                            yield this.sessionPoolMutex.runExclusive(() => {
+                                if (!sessionId) {
+                                    throw new Error("Missing sessionId, cannot return to pool");
+                                }
+                                this.sessionPool.push(sessionId);
+                            });
+                        }
+                        catch (error) {
+                            if (this.onError) {
+                                yield this.handleErrorWithCallback({ originalError: error, batch, sessionId, callback: this.onError });
+                            }
+                            else {
+                                // By default, log the error and continue
+                                const urls = batch.map((url) => url.url);
+                                this.logErrorForUrls(urls, error);
+                            }
+                            // Clean up the session in case of error
+                            if (sessionId) {
+                                this.safelyTerminateSession(sessionId);
+                            }
+                        }
+                    }))();
+                    yield this.activePromisesMutex.runExclusive(() => {
+                        this.activePromises.push(promise);
+                    });
+                    // Remove the promise when it completes
+                    promise.finally(() => __awaiter(this, void 0, void 0, function* () {
+                        yield this.activePromisesMutex.runExclusive(() => {
+                            const index = this.activePromises.indexOf(promise);
+                            if (index > -1) {
+                                this.activePromises.splice(index, 1);
+                            }
+                        });
+                    }));
+                }
+                // Wait for all remaining sessions to complete
+                yield Promise.allSettled(this.activePromises);
+            }
+            finally {
+                this.processingPromisesCount--;
+            }
+        });
+    }
+    handleErrorWithCallback({ originalError, batch, sessionId, callback, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Catch any errors in the onError callback to avoid halting the entire process
+            try {
+                yield callback({
+                    error: this.formatError(originalError),
+                    operationUrls: batch,
+                    sessionId,
+                });
+            }
+            catch (newError) {
+                this.client.error(`Error in onError callback: ${this.formatError(newError)}. Original error: ${this.formatError(originalError)}`);
+            }
+        });
+    }
+    logErrorForUrls(urls, error) {
+        const message = `Error for URLs ${JSON.stringify(urls)}: ${this.formatError(error)}`;
+        this.client.error(message);
+    }
+    safelyTerminateSession(sessionId) {
+        // Do not await since we don't want to block the main thread
+        this.client.sessions.terminate(sessionId).catch((error) => {
+            this.client.error(`Error terminating session ${sessionId}: ${this.formatError(error)}`);
+        });
+    }
+    formatError(error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+    handleErrorAndWarningResponses({ warnings, errors, sessionId, batch }) {
+        if (!warnings && !errors)
+            return;
+        const details = {
+            sessionId,
+            urls: batch,
+        };
+        if (warnings) {
+            details.warnings = warnings;
+            this.client.warn(`Received warnings creating session: ${JSON.stringify(details)}`);
+        }
+        // Log an object with the errors and the URL
+        if (errors) {
+            details.errors = errors;
+            this.client.error(`Received errors creating session: ${JSON.stringify(details)}`);
+        }
+    }
+}
+exports.SessionQueue = SessionQueue;

package/dist/utils/batch-operate/WindowQueue.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import type { AirtopClient } from "wrapper/AirtopClient";
+import type { BatchOperationError, BatchOperationInput, BatchOperationResponse, BatchOperationUrl } from "./types";
+import type { EventEmitter } from "node:events";
+export declare class WindowQueue<T> {
+    private activePromises;
+    private urlQueue;
+    private activePromisesMutex;
+    private urlQueueMutex;
+    private maxWindowsPerSession;
+    private runEmitter;
+    private sessionId;
+    private client;
+    private operation;
+    private onError?;
+    private isHalted;
+    constructor(maxWindowsPerSession: number, runEmitter: EventEmitter, sessionId: string, client: AirtopClient, operation: (input: BatchOperationInput) => Promise<BatchOperationResponse<T>>, onError?: (error: BatchOperationError) => Promise<void>, isHalted?: boolean);
+    addUrlToQueue(url: BatchOperationUrl): Promise<void>;
+    private handleHaltEvent;
+    processInBatches(urls: BatchOperationUrl[]): Promise<T[]>;
+    private handleErrorWithCallback;
+    private safelyTerminateWindow;
+    private formatError;
+    private handleErrorAndWarningResponses;
+}

package/dist/utils/batch-operate/WindowQueue.js

@@ -0,0 +1,201 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowQueue = void 0;
+const async_mutex_1 = require("async-mutex");
+class WindowQueue {
+    constructor(maxWindowsPerSession, runEmitter, sessionId, client, operation, onError, isHalted = false) {
+        this.activePromises = [];
+        this.urlQueue = [];
+        this.activePromisesMutex = new async_mutex_1.Mutex();
+        this.urlQueueMutex = new async_mutex_1.Mutex();
+        if (!Number.isInteger(maxWindowsPerSession) || maxWindowsPerSession <= 0) {
+            throw new Error("maxWindowsPerSession must be a positive integer");
+        }
+        this.maxWindowsPerSession = maxWindowsPerSession;
+        this.runEmitter = runEmitter;
+        this.sessionId = sessionId;
+        this.client = client;
+        this.operation = operation;
+        this.onError = onError;
+        this.isHalted = isHalted;
+    }
+    addUrlToQueue(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.urlQueueMutex.runExclusive(() => {
+                this.urlQueue.push(url);
+            });
+        });
+    }
+    handleHaltEvent() {
+        this.client.log("Halt event received");
+        this.isHalted = true;
+    }
+    processInBatches(urls) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = [];
+            this.runEmitter.on("halt", this.handleHaltEvent.bind(this));
+            yield this.urlQueueMutex.runExclusive(() => {
+                this.urlQueue = [...urls];
+            });
+            this.client.log(`Processing batch: ${JSON.stringify(urls)} for session ${this.sessionId}`);
+            while (this.urlQueue.length > 0) {
+                // Wait for any window to complete before starting a new one
+                let shouldContinue = false;
+                yield this.activePromisesMutex.runExclusive(() => __awaiter(this, void 0, void 0, function* () {
+                    if (this.activePromises.length >= this.maxWindowsPerSession) {
+                        yield Promise.race(this.activePromises);
+                        shouldContinue = true;
+                    }
+                }));
+                if (shouldContinue)
+                    continue;
+                let urlData;
+                yield this.urlQueueMutex.runExclusive(() => {
+                    urlData = this.urlQueue.shift(); // Take the next url from the queue
+                });
+                if (!urlData)
+                    break; // No more urls to process
+                // If we have less than the max concurrent operations, start a new one
+                const promise = (() => __awaiter(this, void 0, void 0, function* () {
+                    // Do not process any more urls if the processing has been halted
+                    if (this.isHalted) {
+                        this.client.log(`Processing halted, skipping window creation for ${urlData.url}`);
+                        return;
+                    }
+                    let windowId;
+                    let liveViewUrl;
+                    try {
+                        // Create a new window pointed to the url
+                        this.client.log(`Creating window for ${urlData.url} in session ${this.sessionId}`);
+                        const { data, errors, warnings } = yield this.client.windows.create(this.sessionId, {
+                            url: urlData.url,
+                        });
+                        windowId = data.windowId;
+                        this.handleErrorAndWarningResponses({ warnings, errors, sessionId: this.sessionId, url: urlData, operation: "window creation" });
+                        if (!windowId) {
+                            throw new Error(`WindowId not found, errors: ${JSON.stringify(errors)}`);
+                        }
+                        const { data: windowInfo, warnings: windowWarnings, errors: windowErrors } = yield this.client.windows.getWindowInfo(this.sessionId, windowId);
+                        liveViewUrl = windowInfo.liveViewUrl;
+                        this.handleErrorAndWarningResponses({ warnings: windowWarnings, errors: windowErrors, sessionId: this.sessionId, url: urlData, operation: "window info retrieval" });
+                        // Run the operation on the window
+                        const result = yield this.operation({
+                            windowId,
+                            sessionId: this.sessionId,
+                            liveViewUrl,
+                            operationUrl: urlData,
+                        });
+                        if (result) {
+                            const { shouldHaltBatch, additionalUrls, data } = result;
+                            if (data) {
+                                results.push(data);
+                            }
+                            if (shouldHaltBatch) {
+                                this.client.log("Emitting halt event");
+                                this.runEmitter.emit("halt");
+                            }
+                            if (additionalUrls && additionalUrls.length > 0) {
+                                this.client.log(`Emitting addUrls event with urls: ${JSON.stringify(additionalUrls)}`);
+                                this.runEmitter.emit("addUrls", additionalUrls);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        if (this.onError) {
+                            yield this.handleErrorWithCallback({
+                                originalError: error,
+                                url: urlData,
+                                callback: this.onError,
+                                windowId,
+                                liveViewUrl,
+                            });
+                        }
+                        else {
+                            // By default, log the error and continue
+                            const message = `Error for URL ${urlData.url}: ${this.formatError(error)}`;
+                            this.client.error(message);
+                        }
+                    }
+                    finally {
+                        if (windowId) {
+                            yield this.safelyTerminateWindow(windowId);
+                        }
+                    }
+                }))();
+                yield this.activePromisesMutex.runExclusive(() => {
+                    this.activePromises.push(promise);
+                });
+                // Remove the promise from the active list when it resolves
+                promise.finally(() => __awaiter(this, void 0, void 0, function* () {
+                    yield this.activePromisesMutex.runExclusive(() => {
+                        const index = this.activePromises.indexOf(promise);
+                        if (index > -1) {
+                            this.activePromises.splice(index, 1);
+                        }
+                    });
+                }));
+            }
+            // Wait for all processes to complete
+            yield Promise.allSettled(this.activePromises);
+            // Remove the halt listener
+            this.runEmitter.removeListener("halt", this.handleHaltEvent);
+            return results;
+        });
+    }
+    handleErrorWithCallback({ originalError, url, windowId, liveViewUrl, callback, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Catch any errors in the onError callback to avoid halting the entire process
+            try {
+                yield callback({
+                    error: this.formatError(originalError),
+                    operationUrls: [url],
+                    sessionId: this.sessionId,
+                    windowId,
+                    liveViewUrl,
+                });
+            }
+            catch (newError) {
+                this.client.error(`Error in onError callback: ${this.formatError(newError)}. Original error: ${this.formatError(originalError)}`);
+            }
+        });
+    }
+    safelyTerminateWindow(windowId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.client.windows.close(this.sessionId, windowId);
+            }
+            catch (error) {
+                this.client.error(`Error closing window ${windowId}: ${this.formatError(error)}`);
+            }
+        });
+    }
+    formatError(error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+    handleErrorAndWarningResponses({ warnings, errors, sessionId, url, operation }) {
+        if (!warnings && !errors)
+            return;
+        const details = {
+            sessionId,
+            url,
+        };
+        if (warnings) {
+            details.warnings = warnings;
+            this.client.warn(`Received warnings for ${operation}: ${JSON.stringify(details)}`);
+        }
+        if (errors) {
+            details.errors = errors;
+            this.client.error(`Received errors for ${operation}: ${JSON.stringify(details)}`);
+        }
+    }
+}
+exports.WindowQueue = WindowQueue;

package/dist/utils/batch-operate/batch-util.d.ts

@@ -0,0 +1,3 @@
+import type { AirtopClient } from "wrapper/AirtopClient";
+import type { BatchOperateConfig, BatchOperationInput, BatchOperationResponse, BatchOperationUrl } from "./types";
+export declare const batchOperate: <T>(urls: BatchOperationUrl[], operation: (input: BatchOperationInput) => Promise<BatchOperationResponse<T>>, client: AirtopClient, config?: BatchOperateConfig | undefined) => Promise<T[]>;

package/dist/utils/batch-operate/batch-util.js

@@ -0,0 +1,51 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchOperate = void 0;
+const node_events_1 = require("node:events");
+const helpers_1 = require("./helpers");
+const SessionQueue_1 = require("./SessionQueue");
+const DEFAULT_MAX_WINDOWS_PER_SESSION = 1;
+const DEFAULT_MAX_CONCURRENT_SESSIONS = 30;
+const batchOperate = (urls, operation, // operation to invoke on each url
+client, config) => __awaiter(void 0, void 0, void 0, function* () {
+    // Validate the urls before proceeding
+    if (!Array.isArray(urls)) {
+        throw new Error("Please provide a valid list of urls");
+    }
+    for (const url of urls) {
+        if (!url || typeof url !== "object" || !("url" in url)) {
+            throw new Error("Please provide a valid list of urls");
+        }
+    }
+    const runEmitter = new node_events_1.EventEmitter();
+    const { maxConcurrentSessions = DEFAULT_MAX_CONCURRENT_SESSIONS, maxWindowsPerSession = DEFAULT_MAX_WINDOWS_PER_SESSION, sessionConfig, onError, } = config !== null && config !== void 0 ? config : {};
+    // Set the maximum number of listeners to accommodate all concurrent sessions and windows
+    runEmitter.setMaxListeners(maxConcurrentSessions + (maxConcurrentSessions * maxWindowsPerSession) + 1);
+    // Split the urls into batches
+    const initialBatches = (0, helpers_1.distributeUrlsToBatches)(urls, maxConcurrentSessions);
+    const sessionQueue = new SessionQueue_1.SessionQueue({
+        maxConcurrentSessions,
+        runEmitter,
+        maxWindowsPerSession,
+        initialBatches,
+        operation,
+        client,
+        sessionConfig,
+        onError,
+    });
+    runEmitter.on("addUrls", (additionalUrls) => {
+        sessionQueue.addUrlsToBatchQueue(additionalUrls);
+    });
+    yield sessionQueue.processInitialBatches();
+    return yield sessionQueue.waitForProcessingToComplete();
+});
+exports.batchOperate = batchOperate;

package/dist/utils/batch-operate/helpers.d.ts

@@ -0,0 +1,2 @@
+import type { BatchOperationUrl } from "./types";
+export declare const distributeUrlsToBatches: (urls: BatchOperationUrl[], maxConcurrentSessions: number) => BatchOperationUrl[][];

package/dist/utils/batch-operate/helpers.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distributeUrlsToBatches = void 0;
+const distributeUrlsToBatches = (urls, maxConcurrentSessions) => {
+    if (urls.length === 0)
+        return [];
+    // Calculate optimal number of batches
+    const batchCount = Math.min(maxConcurrentSessions, urls.length);
+    const batches = Array.from({ length: batchCount }, () => []);
+    urls.forEach((url, index) => {
+        const batchIndex = index % batchCount;
+        if (!batches[batchIndex]) {
+            batches[batchIndex] = [];
+        }
+        batches[batchIndex].push(url);
+    });
+    return batches;
+};
+exports.distributeUrlsToBatches = distributeUrlsToBatches;

package/dist/utils/batch-operate/types.d.ts

@@ -0,0 +1,29 @@
+import type { AirtopSessionConfigV1 } from "wrapper/AirtopSessions";
+export declare type BatchOperateConfig = {
+    maxConcurrentSessions?: number;
+    maxWindowsPerSession?: number;
+    sessionConfig?: AirtopSessionConfigV1;
+    onError?: (error: BatchOperationError) => Promise<void>;
+};
+export declare type BatchOperationUrl = {
+    url: string;
+    context?: Record<string, unknown>;
+};
+export declare type BatchOperationInput = {
+    windowId: string;
+    sessionId: string;
+    liveViewUrl: string;
+    operationUrl: BatchOperationUrl;
+};
+export declare type BatchOperationResponse<T> = {
+    shouldHaltBatch?: boolean;
+    additionalUrls?: BatchOperationUrl[];
+    data?: T;
+};
+export declare type BatchOperationError = {
+    error: Error | string;
+    operationUrls: BatchOperationUrl[];
+    sessionId?: string;
+    windowId?: string;
+    liveViewUrl?: string;
+};

package/dist/utils/batch-operate/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./batch-operate/batch-util";
+export * from "./batch-operate/types";

package/dist/utils/index.js

@@ -0,0 +1,18 @@
+"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 __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 });
+__exportStar(require("./batch-operate/batch-util"), exports);
+__exportStar(require("./batch-operate/types"), exports);

package/dist/wrapper/AirtopClient.d.ts

@@ -1,6 +1,7 @@
 import { AirtopClient as FernClient } from '../Client';
 import { AirtopSessions } from './AirtopSessions';
 import { AirtopWindows } from './AirtopWindows';
+import { type BatchOperateConfig, type BatchOperationInput, type BatchOperationResponse, type BatchOperationUrl } from "../utils";
 declare type AugmentedOptions = FernClient.Options & {
     debug?: boolean;
 };
@@ -15,6 +16,8 @@ export declare class AirtopClient {
     get windows(): AirtopWindows;
     get profiles(): import("../api/resources/profiles/client/Client").Profiles;
     log(message: string): void;
+    warn(message: string): void;
     error(err: any): void;
+    batchOperate: <T>(urls: BatchOperationUrl[], operation: (input: BatchOperationInput) => Promise<BatchOperationResponse<T>>, config?: BatchOperateConfig | undefined) => Promise<T[]>;
 }
 export {};

package/dist/wrapper/AirtopClient.js

@@ -1,12 +1,25 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AirtopClient = void 0;
 const Client_1 = require("../Client"); // alias the Fern generated client
 const AirtopSessions_1 = require("./AirtopSessions");
 const AirtopWindows_1 = require("./AirtopWindows");
+const utils_1 = require("../utils");
 class AirtopClient {
     constructor(_options) {
         this._options = _options;
+        this.batchOperate = (urls, operation, config) => __awaiter(this, void 0, void 0, function* () {
+            return yield (0, utils_1.batchOperate)(urls, operation, this, config);
+        });
         this._client = new Client_1.AirtopClient(_options);
         this.debug = (_options === null || _options === void 0 ? void 0 : _options.debug) || false;
     }
@@ -26,6 +39,9 @@ class AirtopClient {
             console.log(message);
         }
     }
+    warn(message) {
+        console.warn(message);
+    }
     error(err) {
         console.error(err);
     }

package/index.d.ts

@@ -4,3 +4,4 @@ export { AirtopEnvironment } from "./environments";
 export { AirtopError, AirtopTimeoutError } from "./errors";
 export { AirtopClient } from './wrapper/AirtopClient';
 export { LiveViewEventName, LiveViewMessage } from './live-view/types';
+export * from './utils';

package/index.js

@@ -22,6 +22,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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"));
@@ -35,3 +38,4 @@ 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);