@sqaitech/webdriver 0.30.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present Bytedance, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/es/index.mjs

@@ -0,0 +1,293 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { DEFAULT_WDA_PORT } from "@sqaitech/shared/constants";
+import { getDebug } from "@sqaitech/shared/logger";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class BaseServiceManager {
+    async restart() {
+        if (this.isRunning()) await this.stop();
+        await this.start();
+    }
+    getEndpoint() {
+        return `http://${this.host}:${this.port}`;
+    }
+    getPort() {
+        return this.port;
+    }
+    getHost() {
+        return this.host;
+    }
+    constructor(port, host = 'localhost'){
+        _define_property(this, "port", void 0);
+        _define_property(this, "host", void 0);
+        this.port = port;
+        this.host = host;
+    }
+}
+function WDAManager_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const execAsync = promisify(exec);
+const debugWDA = getDebug('webdriver:wda-manager');
+class WDAManager extends BaseServiceManager {
+    static getInstance(port = DEFAULT_WDA_PORT, host) {
+        const key = `${host || 'localhost'}:${port}`;
+        if (!WDAManager.instances.has(key)) WDAManager.instances.set(key, new WDAManager({
+            port,
+            host
+        }));
+        return WDAManager.instances.get(key);
+    }
+    async start() {
+        if (this.isStarted) return void debugWDA(`WDA already started on ${this.config.host}:${this.config.port}`);
+        try {
+            if (await this.isWDARunning()) {
+                debugWDA(`WDA already running on port ${this.config.port}`);
+                this.isStarted = true;
+                return;
+            }
+            await this.startWDA();
+            await this.waitForWDA();
+            this.isStarted = true;
+            debugWDA(`WDA started successfully on ${this.config.host}:${this.config.port}`);
+        } catch (error) {
+            debugWDA(`Failed to start WDA: ${error}`);
+            throw new Error(`Failed to start WebDriverAgent: ${error}`);
+        }
+    }
+    async stop() {
+        if (!this.isStarted) return;
+        try {
+            this.isStarted = false;
+            debugWDA(`WDA stopped on ${this.config.host}:${this.config.port}`);
+        } catch (error) {
+            debugWDA(`Error stopping WDA: ${error}`);
+        }
+    }
+    isRunning() {
+        return this.isStarted;
+    }
+    async startWDA() {
+        await this.checkWDAPreparation();
+        debugWDA('WebDriverAgent verification completed');
+    }
+    async checkWDAPreparation() {
+        if (await this.isWDARunning()) return void debugWDA(`WebDriverAgent is already running on port ${this.config.port}`);
+        throw new Error(`WebDriverAgent is not running on ${this.config.host}:${this.config.port}. Please start WebDriverAgent manually:
+
+\u{1F527} Setup Instructions:
+1. Install WebDriverAgent: npm install appium-webdriveragent
+2. Build and run WebDriverAgent:
+   - For simulators: Use Xcode to run WebDriverAgentRunner on your target simulator
+   - For real devices: Build WebDriverAgentRunner and install on your device
+3. Ensure WebDriverAgent is listening on ${this.config.host}:${this.config.port}
+
+\u{1F4A1} Alternative: You can also specify a different host/port where WebDriverAgent is running.`);
+    }
+    async isWDARunning() {
+        try {
+            const url = `http://${this.config.host}:${this.config.port}/status`;
+            const response = await fetch(url);
+            if (!response.ok) return false;
+            const responseText = await response.text();
+            return responseText.includes('sessionId');
+        } catch (error) {
+            return false;
+        }
+    }
+    async waitForWDA(timeout = 30000) {
+        const startTime = Date.now();
+        while(Date.now() - startTime < timeout){
+            if (await this.isWDARunning()) return;
+            await new Promise((resolve)=>setTimeout(resolve, 1000));
+        }
+        throw new Error(`WebDriverAgent did not start within ${timeout}ms`);
+    }
+    async killWDAProcesses() {
+        try {
+            await execAsync('pkill -f "xcodebuild.*WebDriverAgent"').catch(()=>{});
+            await execAsync('pkill -f "WebDriverAgentRunner"').catch(()=>{});
+            debugWDA('Killed WDA processes');
+        } catch (error) {}
+    }
+    constructor(config){
+        super(config.port, config.host), WDAManager_define_property(this, "config", void 0), WDAManager_define_property(this, "isStarted", false);
+        this.config = {
+            bundleId: 'com.apple.WebDriverAgentRunner.xctrunner',
+            usePrebuiltWDA: true,
+            host: 'localhost',
+            ...config,
+            port: config.port || DEFAULT_WDA_PORT
+        };
+    }
+}
+WDAManager_define_property(WDAManager, "instances", new Map());
+function request_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const debugRequest = getDebug('webdriver:request');
+class WebDriverRequestError extends Error {
+    constructor(message, status, response){
+        super(message), request_define_property(this, "status", void 0), request_define_property(this, "response", void 0), this.status = status, this.response = response;
+        this.name = 'WebDriverRequestError';
+    }
+}
+async function makeWebDriverRequest(baseUrl, method, endpoint, data, timeout = 30000) {
+    const url = `${baseUrl}${endpoint}`;
+    debugRequest(`${method} ${url}${data ? ` with data: ${JSON.stringify(data)}` : ''}`);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(()=>controller.abort(), timeout);
+    try {
+        const response = await fetch(url, {
+            method,
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json'
+            },
+            body: data ? JSON.stringify(data) : void 0,
+            signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        let responseData;
+        const contentType = response.headers.get('content-type');
+        if (null == contentType ? void 0 : contentType.includes('application/json')) responseData = await response.json();
+        else {
+            const textData = await response.text();
+            responseData = textData;
+        }
+        if (!response.ok) {
+            const errorMessage = (null == responseData ? void 0 : responseData.error) || (null == responseData ? void 0 : responseData.message) || `HTTP ${response.status}`;
+            throw new WebDriverRequestError(`WebDriver request failed: ${errorMessage}`, response.status, responseData);
+        }
+        return responseData;
+    } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof WebDriverRequestError) throw error;
+        if (error instanceof Error && 'AbortError' === error.name) throw new WebDriverRequestError(`Request timeout after ${timeout}ms`);
+        debugRequest(`Request failed: ${error}`);
+        throw new WebDriverRequestError(`Request failed: ${error}`);
+    }
+}
+function WebDriverClient_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const debugClient = getDebug('webdriver:client');
+class WebDriverClient {
+    get sessionInfo() {
+        if (!this.sessionId) return null;
+        return {
+            sessionId: this.sessionId,
+            capabilities: {}
+        };
+    }
+    async createSession(capabilities) {
+        try {
+            var _response_value, _response_value1;
+            const response = await this.makeRequest('POST', '/session', {
+                capabilities: {
+                    alwaysMatch: {
+                        ...capabilities
+                    }
+                }
+            });
+            this.sessionId = response.sessionId || (null == (_response_value = response.value) ? void 0 : _response_value.sessionId);
+            if (!this.sessionId) throw new Error('Failed to get session ID from response');
+            debugClient(`Created session: ${this.sessionId}`);
+            return {
+                sessionId: this.sessionId,
+                capabilities: response.capabilities || (null == (_response_value1 = response.value) ? void 0 : _response_value1.capabilities) || {}
+            };
+        } catch (error) {
+            debugClient(`Failed to create session: ${error}`);
+            throw error;
+        }
+    }
+    async deleteSession() {
+        if (!this.sessionId) return void debugClient('No active session to delete');
+        try {
+            await this.makeRequest('DELETE', `/session/${this.sessionId}`);
+            debugClient(`Deleted session: ${this.sessionId}`);
+            this.sessionId = null;
+        } catch (error) {
+            debugClient(`Failed to delete session: ${error}`);
+            this.sessionId = null;
+        }
+    }
+    async takeScreenshot() {
+        this.ensureSession();
+        const response = await this.makeRequest('GET', `/session/${this.sessionId}/screenshot`);
+        return response.value || response;
+    }
+    async getWindowSize() {
+        this.ensureSession();
+        const response = await this.makeRequest('GET', `/session/${this.sessionId}/window/rect`);
+        const rect = response.value || response;
+        return {
+            width: rect.width,
+            height: rect.height
+        };
+    }
+    async getDeviceInfo() {
+        try {
+            const statusResponse = await this.makeRequest('GET', '/status');
+            if (null == statusResponse ? void 0 : statusResponse.device) return {
+                udid: statusResponse.device.udid || statusResponse.device.identifier || '',
+                name: statusResponse.device.name || '',
+                model: statusResponse.device.model || statusResponse.device.productName || ''
+            };
+            return null;
+        } catch (error) {
+            debugClient(`Failed to get device info: ${error}`);
+            return null;
+        }
+    }
+    async makeRequest(method, endpoint, data) {
+        return makeWebDriverRequest(this.baseUrl, method, endpoint, data, this.timeout);
+    }
+    ensureSession() {
+        if (!this.sessionId) throw new Error('No active WebDriver session. Call createSession() first.');
+    }
+    constructor(options = {}){
+        WebDriverClient_define_property(this, "baseUrl", void 0);
+        WebDriverClient_define_property(this, "sessionId", null);
+        WebDriverClient_define_property(this, "port", void 0);
+        WebDriverClient_define_property(this, "host", void 0);
+        WebDriverClient_define_property(this, "timeout", void 0);
+        this.port = options.port || DEFAULT_WDA_PORT;
+        this.host = options.host || 'localhost';
+        this.timeout = options.timeout || 30000;
+        this.baseUrl = `http://${this.host}:${this.port}`;
+        debugClient(`Initialized WebDriver client on ${this.host}:${this.port}`);
+    }
+}
+export { BaseServiceManager, WDAManager, WebDriverClient, WebDriverRequestError, makeWebDriverRequest };

package/dist/lib/index.js

@@ -0,0 +1,339 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    WebDriverRequestError: ()=>WebDriverRequestError,
+    WDAManager: ()=>WDAManager,
+    WebDriverClient: ()=>WebDriverClient,
+    BaseServiceManager: ()=>BaseServiceManager,
+    makeWebDriverRequest: ()=>makeWebDriverRequest
+});
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class BaseServiceManager {
+    async restart() {
+        if (this.isRunning()) await this.stop();
+        await this.start();
+    }
+    getEndpoint() {
+        return `http://${this.host}:${this.port}`;
+    }
+    getPort() {
+        return this.port;
+    }
+    getHost() {
+        return this.host;
+    }
+    constructor(port, host = 'localhost'){
+        _define_property(this, "port", void 0);
+        _define_property(this, "host", void 0);
+        this.port = port;
+        this.host = host;
+    }
+}
+const external_node_child_process_namespaceObject = require("node:child_process");
+const external_node_util_namespaceObject = require("node:util");
+const constants_namespaceObject = require("@sqaitech/shared/constants");
+const logger_namespaceObject = require("@sqaitech/shared/logger");
+function WDAManager_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const execAsync = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_namespaceObject.exec);
+const debugWDA = (0, logger_namespaceObject.getDebug)('webdriver:wda-manager');
+class WDAManager extends BaseServiceManager {
+    static getInstance(port = constants_namespaceObject.DEFAULT_WDA_PORT, host) {
+        const key = `${host || 'localhost'}:${port}`;
+        if (!WDAManager.instances.has(key)) WDAManager.instances.set(key, new WDAManager({
+            port,
+            host
+        }));
+        return WDAManager.instances.get(key);
+    }
+    async start() {
+        if (this.isStarted) return void debugWDA(`WDA already started on ${this.config.host}:${this.config.port}`);
+        try {
+            if (await this.isWDARunning()) {
+                debugWDA(`WDA already running on port ${this.config.port}`);
+                this.isStarted = true;
+                return;
+            }
+            await this.startWDA();
+            await this.waitForWDA();
+            this.isStarted = true;
+            debugWDA(`WDA started successfully on ${this.config.host}:${this.config.port}`);
+        } catch (error) {
+            debugWDA(`Failed to start WDA: ${error}`);
+            throw new Error(`Failed to start WebDriverAgent: ${error}`);
+        }
+    }
+    async stop() {
+        if (!this.isStarted) return;
+        try {
+            this.isStarted = false;
+            debugWDA(`WDA stopped on ${this.config.host}:${this.config.port}`);
+        } catch (error) {
+            debugWDA(`Error stopping WDA: ${error}`);
+        }
+    }
+    isRunning() {
+        return this.isStarted;
+    }
+    async startWDA() {
+        await this.checkWDAPreparation();
+        debugWDA('WebDriverAgent verification completed');
+    }
+    async checkWDAPreparation() {
+        if (await this.isWDARunning()) return void debugWDA(`WebDriverAgent is already running on port ${this.config.port}`);
+        throw new Error(`WebDriverAgent is not running on ${this.config.host}:${this.config.port}. Please start WebDriverAgent manually:
+
+\u{1F527} Setup Instructions:
+1. Install WebDriverAgent: npm install appium-webdriveragent
+2. Build and run WebDriverAgent:
+   - For simulators: Use Xcode to run WebDriverAgentRunner on your target simulator
+   - For real devices: Build WebDriverAgentRunner and install on your device
+3. Ensure WebDriverAgent is listening on ${this.config.host}:${this.config.port}
+
+\u{1F4A1} Alternative: You can also specify a different host/port where WebDriverAgent is running.`);
+    }
+    async isWDARunning() {
+        try {
+            const url = `http://${this.config.host}:${this.config.port}/status`;
+            const response = await fetch(url);
+            if (!response.ok) return false;
+            const responseText = await response.text();
+            return responseText.includes('sessionId');
+        } catch (error) {
+            return false;
+        }
+    }
+    async waitForWDA(timeout = 30000) {
+        const startTime = Date.now();
+        while(Date.now() - startTime < timeout){
+            if (await this.isWDARunning()) return;
+            await new Promise((resolve)=>setTimeout(resolve, 1000));
+        }
+        throw new Error(`WebDriverAgent did not start within ${timeout}ms`);
+    }
+    async killWDAProcesses() {
+        try {
+            await execAsync('pkill -f "xcodebuild.*WebDriverAgent"').catch(()=>{});
+            await execAsync('pkill -f "WebDriverAgentRunner"').catch(()=>{});
+            debugWDA('Killed WDA processes');
+        } catch (error) {}
+    }
+    constructor(config){
+        super(config.port, config.host), WDAManager_define_property(this, "config", void 0), WDAManager_define_property(this, "isStarted", false);
+        this.config = {
+            bundleId: 'com.apple.WebDriverAgentRunner.xctrunner',
+            usePrebuiltWDA: true,
+            host: 'localhost',
+            ...config,
+            port: config.port || constants_namespaceObject.DEFAULT_WDA_PORT
+        };
+    }
+}
+WDAManager_define_property(WDAManager, "instances", new Map());
+function request_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const debugRequest = (0, logger_namespaceObject.getDebug)('webdriver:request');
+class WebDriverRequestError extends Error {
+    constructor(message, status, response){
+        super(message), request_define_property(this, "status", void 0), request_define_property(this, "response", void 0), this.status = status, this.response = response;
+        this.name = 'WebDriverRequestError';
+    }
+}
+async function makeWebDriverRequest(baseUrl, method, endpoint, data, timeout = 30000) {
+    const url = `${baseUrl}${endpoint}`;
+    debugRequest(`${method} ${url}${data ? ` with data: ${JSON.stringify(data)}` : ''}`);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(()=>controller.abort(), timeout);
+    try {
+        const response = await fetch(url, {
+            method,
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json'
+            },
+            body: data ? JSON.stringify(data) : void 0,
+            signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        let responseData;
+        const contentType = response.headers.get('content-type');
+        if (null == contentType ? void 0 : contentType.includes('application/json')) responseData = await response.json();
+        else {
+            const textData = await response.text();
+            responseData = textData;
+        }
+        if (!response.ok) {
+            const errorMessage = (null == responseData ? void 0 : responseData.error) || (null == responseData ? void 0 : responseData.message) || `HTTP ${response.status}`;
+            throw new WebDriverRequestError(`WebDriver request failed: ${errorMessage}`, response.status, responseData);
+        }
+        return responseData;
+    } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof WebDriverRequestError) throw error;
+        if (error instanceof Error && 'AbortError' === error.name) throw new WebDriverRequestError(`Request timeout after ${timeout}ms`);
+        debugRequest(`Request failed: ${error}`);
+        throw new WebDriverRequestError(`Request failed: ${error}`);
+    }
+}
+function WebDriverClient_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const debugClient = (0, logger_namespaceObject.getDebug)('webdriver:client');
+class WebDriverClient {
+    get sessionInfo() {
+        if (!this.sessionId) return null;
+        return {
+            sessionId: this.sessionId,
+            capabilities: {}
+        };
+    }
+    async createSession(capabilities) {
+        try {
+            var _response_value, _response_value1;
+            const response = await this.makeRequest('POST', '/session', {
+                capabilities: {
+                    alwaysMatch: {
+                        ...capabilities
+                    }
+                }
+            });
+            this.sessionId = response.sessionId || (null == (_response_value = response.value) ? void 0 : _response_value.sessionId);
+            if (!this.sessionId) throw new Error('Failed to get session ID from response');
+            debugClient(`Created session: ${this.sessionId}`);
+            return {
+                sessionId: this.sessionId,
+                capabilities: response.capabilities || (null == (_response_value1 = response.value) ? void 0 : _response_value1.capabilities) || {}
+            };
+        } catch (error) {
+            debugClient(`Failed to create session: ${error}`);
+            throw error;
+        }
+    }
+    async deleteSession() {
+        if (!this.sessionId) return void debugClient('No active session to delete');
+        try {
+            await this.makeRequest('DELETE', `/session/${this.sessionId}`);
+            debugClient(`Deleted session: ${this.sessionId}`);
+            this.sessionId = null;
+        } catch (error) {
+            debugClient(`Failed to delete session: ${error}`);
+            this.sessionId = null;
+        }
+    }
+    async takeScreenshot() {
+        this.ensureSession();
+        const response = await this.makeRequest('GET', `/session/${this.sessionId}/screenshot`);
+        return response.value || response;
+    }
+    async getWindowSize() {
+        this.ensureSession();
+        const response = await this.makeRequest('GET', `/session/${this.sessionId}/window/rect`);
+        const rect = response.value || response;
+        return {
+            width: rect.width,
+            height: rect.height
+        };
+    }
+    async getDeviceInfo() {
+        try {
+            const statusResponse = await this.makeRequest('GET', '/status');
+            if (null == statusResponse ? void 0 : statusResponse.device) return {
+                udid: statusResponse.device.udid || statusResponse.device.identifier || '',
+                name: statusResponse.device.name || '',
+                model: statusResponse.device.model || statusResponse.device.productName || ''
+            };
+            return null;
+        } catch (error) {
+            debugClient(`Failed to get device info: ${error}`);
+            return null;
+        }
+    }
+    async makeRequest(method, endpoint, data) {
+        return makeWebDriverRequest(this.baseUrl, method, endpoint, data, this.timeout);
+    }
+    ensureSession() {
+        if (!this.sessionId) throw new Error('No active WebDriver session. Call createSession() first.');
+    }
+    constructor(options = {}){
+        WebDriverClient_define_property(this, "baseUrl", void 0);
+        WebDriverClient_define_property(this, "sessionId", null);
+        WebDriverClient_define_property(this, "port", void 0);
+        WebDriverClient_define_property(this, "host", void 0);
+        WebDriverClient_define_property(this, "timeout", void 0);
+        this.port = options.port || constants_namespaceObject.DEFAULT_WDA_PORT;
+        this.host = options.host || 'localhost';
+        this.timeout = options.timeout || 30000;
+        this.baseUrl = `http://${this.host}:${this.port}`;
+        debugClient(`Initialized WebDriver client on ${this.host}:${this.port}`);
+    }
+}
+exports.BaseServiceManager = __webpack_exports__.BaseServiceManager;
+exports.WDAManager = __webpack_exports__.WDAManager;
+exports.WebDriverClient = __webpack_exports__.WebDriverClient;
+exports.WebDriverRequestError = __webpack_exports__.WebDriverRequestError;
+exports.makeWebDriverRequest = __webpack_exports__.makeWebDriverRequest;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "BaseServiceManager",
+    "WDAManager",
+    "WebDriverClient",
+    "WebDriverRequestError",
+    "makeWebDriverRequest"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/types/index.d.ts

@@ -0,0 +1,122 @@
+import { WEBDRIVER_ELEMENT_ID_KEY } from '@sqaitech/shared/constants';
+
+export declare abstract class BaseServiceManager implements WebDriverServiceManager {
+    protected port: number;
+    protected host: string;
+    constructor(port: number, host?: string);
+    abstract start(): Promise<void>;
+    abstract stop(): Promise<void>;
+    abstract isRunning(): boolean;
+    restart(): Promise<void>;
+    getEndpoint(): string;
+    getPort(): number;
+    getHost(): string;
+}
+
+export declare interface DeviceInfo {
+    udid: string;
+    name: string;
+    model: string;
+}
+
+export declare function makeWebDriverRequest(baseUrl: string, method: string, endpoint: string, data?: any, timeout?: number): Promise<any>;
+
+export declare interface Point {
+    x: number;
+    y: number;
+}
+
+export declare interface Size {
+    width: number;
+    height: number;
+}
+
+export declare interface WDAConfig {
+    port: number;
+    host?: string;
+    wdaPath?: string;
+    bundleId?: string;
+    usePrebuiltWDA?: boolean;
+}
+
+export declare interface WDAElement {
+    ELEMENT: string;
+    [WEBDRIVER_ELEMENT_ID_KEY]: string;
+}
+
+export declare interface WDAElementInfo {
+    type: string;
+    name: string;
+    label: string;
+    value: string;
+    rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    enabled: boolean;
+    visible: boolean;
+}
+
+export declare class WDAManager extends BaseServiceManager {
+    private static instances;
+    private config;
+    private isStarted;
+    private constructor();
+    static getInstance(port?: number, host?: string): WDAManager;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    private startWDA;
+    private checkWDAPreparation;
+    private isWDARunning;
+    private waitForWDA;
+    private killWDAProcesses;
+}
+
+export declare interface WDASession {
+    sessionId: string;
+    capabilities: Record<string, any>;
+}
+
+export declare class WebDriverClient {
+    protected baseUrl: string;
+    protected sessionId: string | null;
+    protected port: number;
+    protected host: string;
+    protected timeout: number;
+    constructor(options?: WebDriverOptions);
+    get sessionInfo(): WDASession | null;
+    createSession(capabilities?: any): Promise<WDASession>;
+    deleteSession(): Promise<void>;
+    takeScreenshot(): Promise<string>;
+    getWindowSize(): Promise<Size>;
+    getDeviceInfo(): Promise<DeviceInfo | null>;
+    protected makeRequest(method: string, endpoint: string, data?: any): Promise<any>;
+    protected ensureSession(): void;
+}
+
+export declare interface WebDriverOptions {
+    port?: number;
+    host?: string;
+    timeout?: number;
+}
+
+export declare class WebDriverRequestError extends Error {
+    status?: number | undefined;
+    response?: any | undefined;
+    constructor(message: string, status?: number | undefined, response?: any | undefined);
+}
+
+export declare interface WebDriverServiceManager {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    restart(): Promise<void>;
+    isRunning(): boolean;
+    getEndpoint(): string;
+    getPort(): number;
+    getHost(): string;
+}
+
+export { }

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@sqaitech/webdriver",
+  "version": "0.30.10",
+  "description": "WebDriver protocol implementation for SQAI automation",
+  "main": "dist/lib/index.js",
+  "module": "dist/es/index.mjs",
+  "types": "dist/types/index.d.ts",
+  "dependencies": {
+    "node-fetch": "^3.3.2",
+    "@sqaitech/shared": "0.30.10"
+  },
+  "devDependencies": {
+    "@rslib/core": "^0.11.2",
+    "@types/node": "^18.0.0",
+    "typescript": "^5.8.3",
+    "vitest": "3.0.5"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/es/index.mjs",
+      "require": "./dist/lib/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "webdriver",
+    "automation",
+    "ios",
+    "mobile"
+  ],
+  "scripts": {
+    "build": "rslib build",
+    "dev": "rslib build --watch",
+    "test": "vitest",
+    "lint": "biome check .",
+    "lint:fix": "biome check . --write"
+  }
+}