cdp-client-tool 1.1.1 → 2.0.0

package/dist/index.js

@@ -1,10 +1,12 @@
 import chalk from 'chalk';
+import * as path from 'node:path';
+import { dirname, join } from 'node:path';
+import { stat, mkdir, readdir, readFile, writeFile, rm } from 'node:fs/promises';
 import axios from 'axios';
 import puppeteer from 'puppeteer-core';
-import { rm, readFile, readdir } from 'node:fs/promises';
+import * as fs from 'node:fs';
+import { Worker } from 'node:worker_threads';
 import { io } from 'socket.io-client';
-import * as path from 'node:path';
-import * as requireFromString from 'require-from-string';
 
 const raw = chalk.default ?? chalk;
 const c = {
@@ -71,7 +73,13 @@ class Logger {
         this.logMessage(LogLevel.DEBUG, message, ...args);
     }
 }
+const logger = new Logger();
 
+function sleep(timeout) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, timeout);
+    });
+}
 async function launchBrowser() {
     const debugUrl = 'http://localhost:9222';
     const { data } = await axios.get(`${debugUrl}/json/version`);
@@ -82,6 +90,27 @@ async function launchBrowser() {
     });
     return browser;
 }
+async function ensureDir(dirPath, create = true) {
+    try {
+        const stats = await stat(dirPath);
+        if (!stats.isDirectory()) {
+            throw new Error(`${dirPath} 存在但不是目录`);
+        }
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            if (create) {
+                await mkdir(dirPath, { recursive: true });
+            }
+            else {
+                throw new Error(`目录 ${dirPath} 不存在`);
+            }
+        }
+        else {
+            throw err;
+        }
+    }
+}
 
 var EVENTS;
 (function (EVENTS) {
@@ -93,7 +122,17 @@ var EVENTS;
     EVENTS["EXEC_LOCAL_SCRIPT"] = "exec_local_script";
     EVENTS["EXEC_REMOTE_SCRIPT"] = "exec_remote_script";
     EVENTS["SCRIPT_QUEUE"] = "script_queue";
+    EVENTS["INTERRUPT_SCRIPT"] = "interrupt_script";
+    EVENTS["UNDO_SCRIPT"] = "undo_script";
 })(EVENTS || (EVENTS = {}));
+var PushJobResult;
+(function (PushJobResult) {
+    PushJobResult["SUCCESS"] = "success";
+    PushJobResult["SUCCESS_IN_QUEUE"] = "success_in_queue";
+    PushJobResult["FAILED"] = "failed";
+    PushJobResult["QUEUE_FULL"] = "queue_full";
+    PushJobResult["FILE_SAVE_FAILED"] = "file_save_failed";
+})(PushJobResult || (PushJobResult = {}));
 const ALLOWED_DIRS = ['local_scripts', 'screenshots'];
 function resolveAndValidate(basePath) {
     const cwd = process.cwd();
@@ -106,227 +145,474 @@ function resolveAndValidate(basePath) {
     }
     return resolved;
 }
+async function saveScriptFile(filename, script) {
+    await ensureDir(path.resolve(process.cwd(), 'local_scripts'));
+    fs.writeFileSync(path.resolve(process.cwd(), 'local_scripts', filename), script);
+}
 
-const handlers = {
-    async [EVENTS.EXEC_REMOTE_SCRIPT]({ data, callback }) {
-        const { payload } = data;
-        const res = this.enqueueRemoteScript(payload.raw, payload.params);
-        callback(res);
-    },
-    async [EVENTS.EXEC_LOCAL_SCRIPT]({ data, callback }) {
-        const { payload } = data;
-        const res = this.enqueueLocalScript(payload.filename, payload.params);
-        callback(res);
-    },
-    async [EVENTS.WRITE_FILE]({ data, callback }) {
-        const { payload } = data;
-        const { filename, content } = payload;
-        resolveAndValidate(filename);
-        callback({ ok: true });
-    },
-    async [EVENTS.READ_DIR]({ data, callback }) {
-        const { payload } = data;
-        const dirPath = resolveAndValidate(payload.path);
-        const run = this.runCatchFunction(async () => {
-            const list = await readdir(dirPath, { withFileTypes: true });
-            return list.map(d => ({ name: d.name, type: d.isDirectory() ? 'dir' : 'file' }));
+class ScriptWorker {
+    constructor(options) {
+        this.options = options;
+    }
+    terminate() {
+        if (this.timeoutTimer) {
+            clearTimeout(this.timeoutTimer);
+            this.timeoutTimer = undefined;
+        }
+        this.worker?.terminate();
+    }
+    run() {
+        if (this.options.job.type === 'local') {
+            const { filename, params } = this.options.job;
+            this.worker = new Worker(filename, {
+                workerData: {
+                    params,
+                },
+            });
+        }
+        else {
+            const { script, params } = this.options.job;
+            this.worker = new Worker(script, {
+                eval: true,
+                workerData: {
+                    params,
+                },
+            });
+        }
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const settle = (fn) => {
+                if (settled)
+                    return;
+                settled = true;
+                fn();
+            };
+            this.timeoutTimer = setTimeout(() => {
+                this.timeoutTimer = undefined;
+                this.worker.terminate();
+                settle(() => reject(new Error('Worker timeout')));
+            }, this.options.timeout);
+            this.worker.on('error', (error) => {
+                if (this.timeoutTimer) {
+                    clearTimeout(this.timeoutTimer);
+                    this.timeoutTimer = undefined;
+                }
+                logger.error('Worker error', error);
+                settle(() => reject(error));
+            });
+            this.worker.on('exit', (code) => {
+                if (this.timeoutTimer) {
+                    clearTimeout(this.timeoutTimer);
+                    this.timeoutTimer = undefined;
+                }
+                if (code === 0) {
+                    logger.success('Worker exit', code);
+                    settle(() => resolve());
+                }
+                else {
+                    logger.error('Worker exit', code);
+                    settle(() => reject(new Error(`Worker exited with code ${code}`)));
+                }
+            });
         });
-        const entries = await run();
-        callback(entries ?? []);
-    },
-    async [EVENTS.READ_FILE]({ data, callback }) {
-        const { payload } = data;
-        const filePath = resolveAndValidate(payload.path);
-        const run = this.runCatchFunction(async () => await readFile(filePath));
-        const content = await run();
-        callback(content ?? null);
-    },
-    async [EVENTS.RM]({ data, callback }) {
-        const { payload } = data;
-        const filePath = resolveAndValidate(payload.path);
-        const run = this.runCatchFunction(async () => await rm(filePath, { force: true }));
-        await run();
-        callback({ ok: true });
-    },
-    async [EVENTS.SCRIPT_QUEUE]({ callback }) {
-        const snapshot = this.getScriptQueueSnapshot();
-        callback(snapshot);
-    },
-};
+    }
+}
 
-const defaultOptions = {
-    deviceName: 'default',
-    gateways: []
-};
-class Client {
-    constructor(options = defaultOptions) {
+class Runner {
+    constructor(ctx, options) {
+        this.ctx = ctx;
         this.options = options;
-        this.logger = new Logger();
-        this.running = false;
-        this.scriptQueue = [];
-        this.runningJob = null;
-        this.queueCapacity = 10;
+        this.queue = [];
         this.jobIdSeq = 0;
-        this.init();
+        this.queue = [];
     }
     nextJobId() {
         return `job-${Date.now()}-${this.jobIdSeq++}`;
     }
-    runCatchFunction(func) {
-        const that = this;
-        return async function (...args) {
+    getQueueLength() {
+        return this.queue.length;
+    }
+    interruptJob(jobId) {
+        const idx = this.queue.findIndex((j) => j.id === jobId);
+        if (idx >= 0) {
+            this.queue.splice(idx, 1);
+            return { ok: true };
+        }
+        if (this.worker) {
+            const job = this.worker.options?.job;
+            if (job?.id === jobId) {
+                this.worker.terminate();
+                return { ok: true };
+            }
+        }
+        return { ok: false, reason: `job not found: ${jobId}` };
+    }
+    getScriptQueueSnapshot() {
+        const running = this.worker ? this.worker.options?.job : null;
+        return {
+            running,
+            pending: [...this.queue],
+            capacity: this.options.capacity,
+        };
+    }
+    async execJob(job) {
+        if (this.queue.length >= this.options.capacity) {
+            return PushJobResult.QUEUE_FULL;
+        }
+        if (job.type === 'local' && !job.filename) {
+            job.filename = this.nextJobId();
             try {
-                return await func(...args);
+                await saveScriptFile(job.filename, job.script);
             }
             catch (error) {
-                that.logger.error('runCatchFunction error', error);
-                that.options.onError && that.options.onError(error);
+                return PushJobResult.FILE_SAVE_FAILED;
             }
-        };
+        }
+        this.queue.push(job);
+        if (!this.worker) {
+            const jobToRun = this.queue.shift();
+            if (this.last_finished_at && Date.now() - this.last_finished_at < this.options.minInterval) {
+                console.log('冷却时间');
+                await sleep(this.options.minInterval - (Date.now() - this.last_finished_at));
+            }
+            this.worker = new ScriptWorker({
+                job: jobToRun,
+                timeout: this.options.timeout,
+            });
+            try {
+                const res = await this.worker.run();
+                console.log('res 执行完了', res);
+                return PushJobResult.SUCCESS;
+            }
+            catch (e) {
+                console.log('res 执行失败', e);
+                return PushJobResult.FAILED;
+            }
+            finally {
+                this.worker = undefined;
+                this.last_finished_at = Date.now();
+                console.log('next', this.queue);
+                const next = this.queue.shift();
+                if (next) {
+                    console.log('next!', next);
+                    return this.execJob(next);
+                }
+            }
+        }
+        else {
+            return PushJobResult.SUCCESS_IN_QUEUE;
+        }
+    }
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const HANDLER_REGISTRY = Symbol("handler:registry");
+function getHandlerRegistry(instance) {
+    const ctor = instance.constructor;
+    return ctor[HANDLER_REGISTRY] ?? [];
+}
+function Handler(eventName) {
+    return function (target, propertyKey, _descriptor) {
+        const ctor = typeof target === "function" ? target : target.constructor;
+        const registry = ctor[HANDLER_REGISTRY] ?? [];
+        registry.push({ event: eventName, key: propertyKey });
+        ctor[HANDLER_REGISTRY] = registry;
+    };
+}
+
+class WsHandler {
+    constructor(ctx, options) {
+        this.ctx = ctx;
+        this.options = options;
+        this.init();
     }
-    async init() {
-        this.browser = await this.runCatchFunction(launchBrowser)();
-        this.options.onInit && this.options.onInit(this.ctx);
+    init() {
+        this.options.onInit?.(this.ctx);
         for (const gateway of this.options.gateways) {
-            const warpHandler = (fn) => {
-                return (data, callback) => {
-                    return fn.call(this, {
-                        data,
-                        callback,
-                        gateway,
-                        ctx: this.ctx
-                    });
-                };
-            };
             const socket = io(gateway.uri, {
                 ...gateway.opts,
-                query: { ...gateway.opts?.query, deviceName: this.options.deviceName },
+                query: {
+                    ...gateway.opts?.query,
+                    deviceName: this.options.deviceName ?? "default",
+                },
             });
-            socket.on('connect', () => {
-                this.logger.success(`[${gateway.name}]: socketio 连接成功`);
+            socket.on("connect", () => {
+                logger.success(`[${gateway.name}]: socketio 连接成功`);
             });
-            socket.on('disconnect', () => {
-                this.logger.warn(`[${gateway.name}]: socketio 断开连接`);
+            socket.on("disconnect", () => {
+                logger.warn(`[${gateway.name}]: socketio 断开连接`);
             });
-            socket.on('connect_error', (err) => {
-                this.logger.error(`[${gateway.name}]: connect_error 错误`, err);
+            socket.on("connect_error", (err) => {
+                logger.error(`[${gateway.name}]: connect_error 错误`, err);
             });
-            socket.on('error', (err) => {
-                this.logger.error(`[[${gateway.name}]]: socketio 错误`, err);
+            socket.on("error", (err) => {
+                logger.error(`[${gateway.name}]: socketio 错误`, err);
             });
-            for (const eventName in handlers) {
-                socket.on(eventName, warpHandler(handlers[eventName]));
-            }
-            gateway.onSocketInit && gateway.onSocketInit(socket);
+            this.attachHandlers(socket, gateway);
+            gateway.onSocketInit?.(socket);
         }
     }
-    getLocalModule(filename) {
-        const req = require;
-        return req(path.resolve(process.cwd(), 'local_scripts', filename));
-    }
-    getStringModule(moduleString) {
-        const module = requireFromString(moduleString);
-        return module;
+    attachHandlers(socket, gateway) {
+        const warpHandler = (fn) => (data, callback) => fn.call(this, { data, callback, gateway, ctx: this.ctx });
+        for (const { event, key } of getHandlerRegistry(this)) {
+            const method = this[key];
+            if (typeof method === "function") {
+                socket.on(event, warpHandler(method.bind(this)));
+            }
+        }
     }
-    get ctx() {
-        return {
-            greeting: 'hello, remote script',
-            browser: this.browser,
-            logger: this.logger
-        };
+    async readDir({ data, callback }) {
+        try {
+            const dirPath = resolveAndValidate(data.payload.path);
+            const list = await readdir(dirPath, { withFileTypes: true });
+            callback(list.map((d) => ({
+                name: d.name,
+                type: d.isDirectory() ? "dir" : "file",
+            })));
+        }
+        catch (e) {
+            logger.error("read_dir 失败", e);
+            callback([]);
+        }
     }
-    getScriptQueueSnapshot() {
-        return {
-            running: this.runningJob,
-            pending: [...this.scriptQueue],
-            capacity: this.queueCapacity,
-        };
+    async readFile({ data, callback }) {
+        try {
+            const filePath = resolveAndValidate(data.payload.path);
+            const content = await readFile(filePath);
+            callback(content);
+        }
+        catch (e) {
+            logger.error("read_file 失败", e);
+            callback(null);
+        }
     }
-    enqueueRemoteScript(raw, params) {
-        const job = {
-            id: this.nextJobId(),
-            type: 'remote',
-            description: 'remote_script',
-            params,
-            createdAt: Date.now(),
-            status: 'pending',
-        };
-        return this.enqueueJob(job, async () => {
-            const script = this.getStringModule(raw.toString());
-            const runCtx = { ...this.ctx, params: params ?? {} };
-            const run = this.runCatchFunction(async () => await script(runCtx));
-            await run();
-        });
+    async writeFile({ data, callback }) {
+        try {
+            const { filename, content, flags } = data.payload;
+            const filePath = resolveAndValidate(filename);
+            await ensureDir(dirname(filePath));
+            const buf = Buffer.isBuffer(content) ? content : typeof content === "string" ? Buffer.from(content, "utf8") : Buffer.from(content);
+            await writeFile(filePath, buf, { flag: flags ?? "w" });
+            callback({ ok: true });
+        }
+        catch (e) {
+            logger.error("write_file 失败", e);
+            callback({ ok: false });
+        }
     }
-    enqueueLocalScript(filename, params) {
-        const job = {
-            id: this.nextJobId(),
-            type: 'local',
-            filename,
-            description: filename,
-            params,
-            createdAt: Date.now(),
-            status: 'pending',
-        };
-        return this.enqueueJob(job, async () => {
-            const script = this.getLocalModule(filename);
-            const runCtx = { ...this.ctx, params: params ?? {} };
-            const run = this.runCatchFunction(async () => await script(runCtx));
-            await run();
-        });
+    async rm({ data, callback }) {
+        try {
+            const filePath = resolveAndValidate(data.payload.path);
+            await rm(filePath, { force: true });
+            callback({ ok: true });
+        }
+        catch (e) {
+            logger.error("rm 失败", e);
+            callback({ ok: false });
+        }
     }
-    enqueueJob(job, runner) {
-        const total = this.scriptQueue.length + (this.runningJob ? 1 : 0);
-        if (total >= this.queueCapacity) {
-            return {
-                status: 'overflow',
-                reason: `queue is full (${this.queueCapacity})`,
+    async execLocalScript({ data, callback }) {
+        try {
+            const { filename, params } = data.payload;
+            const base = filename.includes("/") ? filename : join("local_scripts", filename);
+            const filePath = resolveAndValidate(base);
+            const job = {
+                id: `job-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+                type: "local",
+                filename: filePath,
+                params,
             };
+            const result = await this.ctx.runner.execJob(job);
+            console.log('handler:', result);
+            callback(this.mapExecResult(result, job.id));
         }
-        job._runner = runner;
-        if (!this.runningJob) {
-            job.status = 'running';
-            job.startedAt = Date.now();
-            this.runningJob = job;
-            this.runJob(job);
-            return { status: 'executing', jobId: job.id };
+        catch (e) {
+            logger.error("exec_local_script 失败", e);
+            callback({ status: "overflow", reason: e?.message ?? "执行失败" });
         }
-        else {
-            job.status = 'pending';
-            this.scriptQueue.push(job);
-            return {
-                status: 'queued',
-                jobId: job.id,
-                position: this.scriptQueue.length,
+    }
+    async execRemoteScript({ data, callback }) {
+        try {
+            const { raw, params } = data.payload;
+            const job = {
+                id: `job-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+                type: "remote",
+                script: raw.toString("utf8"),
+                params,
             };
+            const result = await this.ctx.runner.execJob(job);
+            callback(this.mapExecResult(result, job.id));
+        }
+        catch (e) {
+            logger.error("exec_remote_script 失败", e);
+            callback({ status: "overflow", reason: e?.message ?? "执行失败" });
+        }
+    }
+    mapExecResult(result, jobId) {
+        switch (result) {
+            case PushJobResult.SUCCESS:
+                return { status: "executing", jobId };
+            case PushJobResult.SUCCESS_IN_QUEUE:
+                return {
+                    status: "queued",
+                    jobId,
+                    position: this.ctx.runner.getQueueLength(),
+                };
+            case PushJobResult.QUEUE_FULL:
+                return { status: "overflow", reason: "queue is full" };
+            case PushJobResult.FAILED:
+                return { status: "overflow", reason: "execution failed" };
+            case PushJobResult.FILE_SAVE_FAILED:
+                return { status: "overflow", reason: "file save failed" };
+            default:
+                return { status: "overflow", reason: "unknown" };
         }
     }
-    async runJob(job) {
-        const runner = job._runner;
-        if (!runner)
-            return;
+    async interruptScript({ data, callback }) {
         try {
-            await runner();
-            job.status = 'success';
+            const { jobId } = data.payload;
+            const result = this.ctx.runner.interruptJob(jobId);
+            callback(result);
         }
         catch (e) {
-            job.status = 'failed';
-            job.errorMessage = e?.message || String(e);
-            this.logger.error('脚本执行失败', e);
-        }
-        finally {
-            job.finishedAt = Date.now();
-            this.runningJob = null;
-            const next = this.scriptQueue.shift();
-            if (next) {
-                next.status = 'running';
-                next.startedAt = Date.now();
-                this.runningJob = next;
-                this.runJob(next);
-            }
+            logger.error("interrupt_script 失败", e);
+            callback({ ok: false, reason: e?.message ?? "取消失败" });
+        }
+    }
+    async undoScript({ data, callback }) {
+        try {
+            const { jobId } = data.payload;
+            const result = this.ctx.runner.interruptJob(jobId);
+            callback(result);
+        }
+        catch (e) {
+            logger.error("undo_script 失败", e);
+            callback({ ok: false, reason: e?.message ?? "撤销失败" });
+        }
+    }
+    async scriptQueue({ callback }) {
+        try {
+            const snapshot = this.ctx.runner.getScriptQueueSnapshot();
+            callback(snapshot);
         }
+        catch (e) {
+            logger.error("script_queue 失败", e);
+            callback({ running: null, pending: [], capacity: 10 });
+        }
+    }
+}
+__decorate([
+    Handler(EVENTS.READ_DIR),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], WsHandler.prototype, "readDir", null);
+__decorate([
+    Handler(EVENTS.READ_FILE),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], WsHandler.prototype, "readFile", null);
+__decorate([
+    Handler(EVENTS.WRITE_FILE),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], WsHandler.prototype, "writeFile", null);
+__decorate([
+    Handler(EVENTS.RM),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], WsHandler.prototype, "rm", null);
+__decorate([
+    Handler(EVENTS.EXEC_LOCAL_SCRIPT),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], WsHandler.prototype, "execLocalScript", null);
+__decorate([
+    Handler(EVENTS.EXEC_REMOTE_SCRIPT),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], WsHandler.prototype, "execRemoteScript", null);
+__decorate([
+    Handler(EVENTS.INTERRUPT_SCRIPT),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], WsHandler.prototype, "interruptScript", null);
+__decorate([
+    Handler(EVENTS.UNDO_SCRIPT),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], WsHandler.prototype, "undoScript", null);
+__decorate([
+    Handler(EVENTS.SCRIPT_QUEUE),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], WsHandler.prototype, "scriptQueue", null);
+
+const defaultOptions = {
+    capacity: 10,
+    timeout: 1000 * 60 * 5,
+    minInterval: 1000 * 5};
+class Client {
+    get deps() {
+        return {
+            runner: this.runner,
+            ws: this.ws,
+        };
+    }
+    constructor(options) {
+        const runner = new Runner(this.deps, {
+            capacity: options.capacity ?? defaultOptions.capacity,
+            minInterval: options.minInterval ?? defaultOptions.minInterval,
+            timeout: options.timeout ?? defaultOptions.timeout,
+        });
+        this.runner = runner;
+        const ws = new WsHandler(this.deps, {
+            gateways: options.gateways,
+            deviceName: options.deviceName,
+        });
+        this.ws = ws;
     }
 }
 
-export { Client, EVENTS, Logger };
+export { Client, EVENTS, Handler, Runner, WsHandler, launchBrowser, logger, sleep };
 //# sourceMappingURL=index.js.map