@airtop/sdk 0.1.40 → 0.1.41-beta0

package/dist/wrapper/AirtopSessions.js

@@ -326,5 +326,108 @@ class AirtopSessions extends Client_1.Sessions {
             });
         });
     }
+    /**
+     * Waits for a file upload to become available to a session.
+     *
+     * @param sessionId - The session id for the file upload.
+     * @param fileId - The file id for the file upload.
+     * @param timeoutSeconds - The timeout in seconds.
+     * @returns The event for the file upload.
+     */
+    waitForUploadAvailable(sessionId_1, fileId_1) {
+        return __awaiter(this, arguments, void 0, function* (sessionId, fileId, timeoutSeconds = 300) {
+            // Create a promise that resolves to null after the timeout
+            const timeoutPromise = new Promise((resolve) => {
+                setTimeout(() => resolve(null), timeoutSeconds * 1000);
+            });
+            // Create a promise for the event processing
+            const processEventsPromise = (() => __awaiter(this, void 0, void 0, function* () {
+                var _a, e_4, _b, _c;
+                const sessionEvents = yield this.events(sessionId, { all: true }, { timeoutInSeconds: timeoutSeconds });
+                try {
+                    for (var _d = true, sessionEvents_4 = __asyncValues(sessionEvents), sessionEvents_4_1; sessionEvents_4_1 = yield sessionEvents_4.next(), _a = sessionEvents_4_1.done, !_a; _d = true) {
+                        _c = sessionEvents_4_1.value;
+                        _d = false;
+                        const event = _c;
+                        const e = event;
+                        if (e.event === 'file_upload_status') {
+                            this.log(`file_upload_status message received:\n${JSON.stringify(event, null, 2)}`);
+                            if (e.status === 'available' && e.fileId === fileId) {
+                                return event;
+                            }
+                        }
+                    }
+                }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = sessionEvents_4.return)) yield _b.call(sessionEvents_4);
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                }
+                return null;
+            }))();
+            // Race the timeout against the event processing
+            return Promise.race([timeoutPromise, processEventsPromise]);
+        });
+    }
+    /**
+     * Captcha event listener
+     * Defaults to looking back 5 seconds in the event stream for the captcha event to be available.
+     * Use `lookbackSeconds` to control this behavior.
+     *
+     * @param {string} sessionId - The ID of the session to monitor
+     * @param {function} callback - The callback function to be called when a captcha event is received
+     * @param {Object} configuration - The optional configuration parameters for the function
+     * @param {number} [configuration.lookbackSeconds=5] - The number of seconds to look back for prior events. Default `5`. 0 means no lookback.
+     * @param {Sessions.RequestOptions} [requestOptions] - Optional request configuration including timeout
+     * @returns {function} - A function to stop listening for captcha events
+     */
+    onCaptchaEvent(sessionId, callback, configuration, requestOptions) {
+        let lastCallbackPromise = Promise.resolve();
+        const abortController = new AbortController();
+        const startTime = new Date();
+        const { lookbackSeconds = 5 } = configuration || {};
+        const timeoutSeconds = (requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.timeoutInSeconds) || 60;
+        (() => __awaiter(this, void 0, void 0, function* () {
+            var _a, e_5, _b, _c;
+            const sessionEvents = yield this.events(sessionId, { all: lookbackSeconds >= 0 }, Object.assign(Object.assign({ timeoutInSeconds: timeoutSeconds }, requestOptions), { abortSignal: abortController.signal }));
+            try {
+                for (var _d = true, sessionEvents_5 = __asyncValues(sessionEvents), sessionEvents_5_1; sessionEvents_5_1 = yield sessionEvents_5.next(), _a = sessionEvents_5_1.done, !_a; _d = true) {
+                    _c = sessionEvents_5_1.value;
+                    _d = false;
+                    const event = _c;
+                    const e = event;
+                    if (e.event === 'captcha-event') {
+                        this.log(`captcha-event message received:\n${JSON.stringify(event, null, 2)}`);
+                        const msg = e;
+                        const eventTime = Date.parse(e.eventTime);
+                        const thresholdTime = startTime.getTime() - lookbackSeconds * 1000;
+                        if (eventTime < thresholdTime) {
+                            this.log('skipping captcha event because its timestamp is earlier than lookbackSeconds');
+                            continue;
+                        }
+                        lastCallbackPromise = lastCallbackPromise
+                            .then(() => callback(msg))
+                            .catch(error => this.log(`Error in captcha callback: ${error}`));
+                    }
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = sessionEvents_5.return)) yield _b.call(sessionEvents_5);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+        }))().catch(error => {
+            if (error.name !== 'AbortError') {
+                this.log(`Error in event processing: ${error}`);
+            }
+        });
+        return () => {
+            abortController.abort();
+        };
+    }
 }
 exports.AirtopSessions = AirtopSessions;

package/dist/wrapper/AirtopWindows.d.ts

@@ -17,10 +17,16 @@ declare namespace seleniumWebdriver {
 import type * as Airtop from '../api';
 import { type Windows, Windows as WindowsClass, type Windows as WindowsNamespace } from '../api/resources/windows/client/Client';
 import * as core from '../core';
+import type { AirtopClient } from './AirtopClient';
+type UploadAndFillFileInputConfiguration = Airtop.SessionFileInputHandlerRequestBody & {
+    uploadFilePath: string;
+};
 export declare class AirtopWindows extends WindowsClass {
+    readonly _client: AirtopClient;
     readonly _options: WindowsNamespace.Options;
     private apiKeySupplier;
-    constructor(_options: WindowsNamespace.Options, apiKeySupplier: core.Supplier<core.BearerToken | undefined>);
+    private readonly mainClient;
+    constructor(_client: AirtopClient, _options: WindowsNamespace.Options, apiKeySupplier: core.Supplier<core.BearerToken | undefined>);
     /**
      * @param {string} sessionId - The session id for the window.
      * @param {string} windowId - The Airtop window id of the browser window to target with an Airtop AI prompt.
@@ -176,5 +182,23 @@ export declare class AirtopWindows extends WindowsClass {
     monitor(sessionId: string, windowId: string, request: Airtop.SessionMonitorHandlerRequestBody, requestOptions?: Windows.RequestOptions): Promise<Airtop.AiPromptResponse>;
     private executeSeleniumCDPCommand;
     getWindowInfoForSeleniumDriver(session: Airtop.ExternalSessionWithConnectionInfo, driver: seleniumWebdriver.WebDriver, request?: Airtop.GetWindowInfoRequest, requestOptions?: WindowsNamespace.RequestOptions): Promise<Airtop.WindowResponse>;
+    /**
+     * Upload a file, push the file to a session, and fill a file input field in a window.
+     * After this operation, the file input will be ready to be submitted.
+     *
+     * @param sessionId - The session id for the window.
+     * @param windowId - The window id of the browser window.
+     * @param {UploadAndFillFileInputConfiguration} configuration
+     * @param configuration.uploadFilePath - The path to the local file to upload.
+     * @param configuration.elementDescription - A natural language description of the file input to
+     *   interact with (e.g. 'the file input', 'file upload selection box'). The interaction will be
+     *   aborted if the target element cannot be found.
+     * @see Airtop.SessionFileInputHandlerRequestBody - For additional micro-interaction configuration options.
+     * @returns The file id and the ai response.
+     */
+    uploadFileAndSelectInput(sessionId: string, windowId: string, configuration: UploadAndFillFileInputConfiguration): Promise<{
+        fileId: string;
+        aiResponse: Airtop.AiPromptResponse;
+    }>;
 }
 export {};

package/dist/wrapper/AirtopWindows.js

@@ -49,11 +49,14 @@ exports.AirtopWindows = void 0;
 const node_fetch_1 = __importDefault(require("node-fetch"));
 const Client_1 = require("../api/resources/windows/client/Client");
 const core = __importStar(require("../core"));
+const utils_1 = require("../utils");
 class AirtopWindows extends Client_1.Windows {
-    constructor(_options, apiKeySupplier) {
+    constructor(_client, _options, apiKeySupplier) {
         super(_options);
+        this._client = _client;
         this._options = _options;
         this.apiKeySupplier = apiKeySupplier;
+        this.mainClient = _client;
     }
     /**
      * @param {string} sessionId - The session id for the window.
@@ -329,5 +332,24 @@ class AirtopWindows extends Client_1.Windows {
             return yield this.getWindowInfo(session.id, targetId, request, requestOptions);
         });
     }
+    /**
+     * Upload a file, push the file to a session, and fill a file input field in a window.
+     * After this operation, the file input will be ready to be submitted.
+     *
+     * @param sessionId - The session id for the window.
+     * @param windowId - The window id of the browser window.
+     * @param {UploadAndFillFileInputConfiguration} configuration
+     * @param configuration.uploadFilePath - The path to the local file to upload.
+     * @param configuration.elementDescription - A natural language description of the file input to
+     *   interact with (e.g. 'the file input', 'file upload selection box'). The interaction will be
+     *   aborted if the target element cannot be found.
+     * @see Airtop.SessionFileInputHandlerRequestBody - For additional micro-interaction configuration options.
+     * @returns The file id and the ai response.
+     */
+    uploadFileAndSelectInput(sessionId, windowId, configuration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, utils_1.uploadFileAndSelectInput)({ client: this.mainClient, sessionId, windowId, configuration });
+        });
+    }
 }
 exports.AirtopWindows = AirtopWindows;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@airtop/sdk",
-    "version": "0.1.40",
+    "version": "0.1.41-beta0",
     "private": false,
     "repository": "https://github.com/airtop-ai/airtop-node-sdk",
     "main": "./index.js",