cdp-client-tool 1.1.1 → 2.0.0

package/dist/Client.d.ts

@@ -1,60 +1,12 @@
-import { Browser } from "puppeteer-core";
-import { Logger } from "./logger";
+import { Runner } from "./core/Runner";
 import { ClientOptions } from "./common";
-type ScriptJobType = 'local' | 'remote';
-type ScriptJobStatus = 'pending' | 'running' | 'success' | 'failed';
-export type ScriptJob = {
-    id: string;
-    type: ScriptJobType;
-    filename?: string;
-    description?: string;
-    params?: any;
-    createdAt: number;
-    startedAt?: number;
-    finishedAt?: number;
-    status: ScriptJobStatus;
-    errorMessage?: string;
-};
-export type ExecQueueResult = {
-    status: 'executing';
-    jobId: string;
-} | {
-    status: 'queued';
-    jobId: string;
-    position: number;
-} | {
-    status: 'overflow';
-    reason: string;
-};
-export type ScriptQueueSnapshot = {
-    running: ScriptJob | null;
-    pending: ScriptJob[];
-    capacity: number;
-};
+import { WsHandler } from "./core/WsHandler";
 export declare class Client {
-    private options;
-    browser: Browser | undefined;
-    logger: Logger;
-    running: boolean;
-    private scriptQueue;
-    private runningJob;
-    private readonly queueCapacity;
-    private jobIdSeq;
-    constructor(options?: ClientOptions);
-    private nextJobId;
-    runCatchFunction(func: Function): (...args: any[]) => Promise<any>;
-    private init;
-    getLocalModule(filename: string): any;
-    getStringModule(moduleString: string): any;
-    get ctx(): {
-        greeting: string;
-        browser: Browser;
-        logger: Logger;
+    runner: Runner;
+    ws: WsHandler;
+    get deps(): {
+        runner: Runner;
+        ws: WsHandler;
     };
-    getScriptQueueSnapshot(): ScriptQueueSnapshot;
-    enqueueRemoteScript(raw: Buffer, params?: any): ExecQueueResult;
-    enqueueLocalScript(filename: string, params?: any): ExecQueueResult;
-    private enqueueJob;
-    private runJob;
+    constructor(options: ClientOptions);
 }
-export {};

package/dist/common.d.ts

@@ -1,5 +1,6 @@
 import { ManagerOptions, SocketOptions } from "socket.io-client";
-import { Client } from "./Client";
+import { Runner } from "./core/Runner";
+import { WsHandler } from "./core/WsHandler";
 export declare enum EVENTS {
     IS_FILE_EXIST = "is_file_exist",
     WRITE_FILE = "write_file",
@@ -8,7 +9,27 @@ export declare enum EVENTS {
     READ_FILE = "read_file",
     EXEC_LOCAL_SCRIPT = "exec_local_script",
     EXEC_REMOTE_SCRIPT = "exec_remote_script",
-    SCRIPT_QUEUE = "script_queue"
+    SCRIPT_QUEUE = "script_queue",
+    INTERRUPT_SCRIPT = "interrupt_script",
+    UNDO_SCRIPT = "undo_script"
+}
+export type Context = {
+    runner: Runner;
+    ws: WsHandler;
+};
+export type ScriptJob = {
+    id: string;
+    type: 'local' | 'remote';
+    filename?: string;
+    script?: string;
+    params?: any;
+};
+export declare enum PushJobResult {
+    SUCCESS = "success",
+    SUCCESS_IN_QUEUE = "success_in_queue",
+    FAILED = "failed",
+    QUEUE_FULL = "queue_full",
+    FILE_SAVE_FAILED = "file_save_failed"
 }
 export type GatewayConfig = {
     name: string;
@@ -17,11 +38,13 @@ export type GatewayConfig = {
     onSocketInit?: (socket: any) => void;
 };
 export type ClientOptions = {
-    deviceName: string;
-    onInit?: (ctx: Client['ctx']) => void;
-    onError?: (error: any) => void;
+    capacity?: number;
+    timeout?: number;
+    minInterval?: number;
     gateways: GatewayConfig[];
+    deviceName?: string;
 };
 export declare function resolveAndValidate(basePath: string): string;
 export declare function getSctiptFilePath(filename: string): void;
 export declare function getScreenshotFilePath(filename: string): void;
+export declare function saveScriptFile(filename: string, script: string): Promise<void>;

package/dist/core/Handler.decorator.d.ts

@@ -0,0 +1,69 @@
+import { EVENTS } from "../common";
+export type EventPayloads = {
+    [EVENTS.IS_FILE_EXIST]: {
+        payload: {
+            path: string;
+        };
+    };
+    [EVENTS.WRITE_FILE]: {
+        payload: {
+            filename: string;
+            content: string | Uint8Array;
+            flags?: string;
+        };
+    };
+    [EVENTS.RM]: {
+        payload: {
+            path: string;
+            recursive?: boolean;
+        };
+    };
+    [EVENTS.READ_DIR]: {
+        payload: {
+            path: string;
+        };
+    };
+    [EVENTS.READ_FILE]: {
+        payload: {
+            path: string;
+        };
+    };
+    [EVENTS.EXEC_LOCAL_SCRIPT]: {
+        payload: {
+            filename: string;
+            params?: any;
+        };
+    };
+    [EVENTS.EXEC_REMOTE_SCRIPT]: {
+        payload: {
+            raw: Buffer;
+            params?: any;
+        };
+    };
+    [EVENTS.SCRIPT_QUEUE]: {
+        payload: Record<string, never>;
+    };
+    [EVENTS.INTERRUPT_SCRIPT]: {
+        payload: {
+            jobId: string;
+        };
+    };
+    [EVENTS.UNDO_SCRIPT]: {
+        payload: {
+            jobId: string;
+        };
+    };
+};
+export type EventKey = keyof EventPayloads;
+export type HandlerContext<K extends EventKey = EventKey> = {
+    data: EventPayloads[K];
+    callback: (...args: any[]) => void;
+    gateway: import("../common").GatewayConfig;
+    ctx: import("../common").Context;
+};
+export type HandlerFor<K extends EventKey> = HandlerContext<K>;
+export declare function getHandlerRegistry(instance: object): Array<{
+    event: EventKey;
+    key: string;
+}>;
+export declare function Handler<K extends EventKey>(eventName: K): (target: object, propertyKey: string, _descriptor?: PropertyDescriptor) => void;

package/dist/core/Runner.d.ts

@@ -0,0 +1,28 @@
+import { Context, ScriptJob } from 'src/common';
+type RunnerOptions = {
+    capacity: number;
+    minInterval: number;
+    timeout: number;
+};
+export declare class Runner {
+    private readonly ctx;
+    private readonly options;
+    private queue;
+    private last_finished_at?;
+    private jobIdSeq;
+    private worker?;
+    constructor(ctx: Context, options: RunnerOptions);
+    private nextJobId;
+    getQueueLength(): number;
+    interruptJob(jobId: string): {
+        ok: boolean;
+        reason?: string;
+    };
+    getScriptQueueSnapshot(): {
+        running: any;
+        pending: ScriptJob[];
+        capacity: number;
+    };
+    execJob(job: ScriptJob): any;
+}
+export {};

package/dist/core/ScriptWorker.d.ts

@@ -0,0 +1,15 @@
+import { Worker } from 'node:worker_threads';
+import { ScriptJob } from 'src/common';
+type ScriptWorkerOptions = {
+    job: ScriptJob;
+    timeout: number;
+};
+export declare class ScriptWorker {
+    private readonly options;
+    worker: Worker;
+    private timeoutTimer?;
+    constructor(options: ScriptWorkerOptions);
+    terminate(): void;
+    run(): Promise<void>;
+}
+export {};

package/dist/core/WsHandler.d.ts

@@ -0,0 +1,25 @@
+import { Context, EVENTS, GatewayConfig } from "../common";
+import { HandlerContext } from "./Handler.decorator";
+type WsHandlerOptions = {
+    gateways: GatewayConfig[];
+    deviceName?: string;
+    onInit?: (ctx: Context) => void;
+};
+export declare class WsHandler {
+    private readonly ctx;
+    private readonly options;
+    constructor(ctx: Context, options: WsHandlerOptions);
+    init(): void;
+    private attachHandlers;
+    readDir({ data, callback }: HandlerContext<typeof EVENTS.READ_DIR>): Promise<void>;
+    readFile({ data, callback }: HandlerContext<typeof EVENTS.READ_FILE>): Promise<void>;
+    writeFile({ data, callback }: HandlerContext<typeof EVENTS.WRITE_FILE>): Promise<void>;
+    rm({ data, callback }: HandlerContext<typeof EVENTS.RM>): Promise<void>;
+    execLocalScript({ data, callback }: HandlerContext<typeof EVENTS.EXEC_LOCAL_SCRIPT>): Promise<void>;
+    execRemoteScript({ data, callback }: HandlerContext<typeof EVENTS.EXEC_REMOTE_SCRIPT>): Promise<void>;
+    private mapExecResult;
+    interruptScript({ data, callback }: HandlerContext<typeof EVENTS.INTERRUPT_SCRIPT>): Promise<void>;
+    undoScript({ data, callback }: HandlerContext<typeof EVENTS.UNDO_SCRIPT>): Promise<void>;
+    scriptQueue({ callback }: HandlerContext<typeof EVENTS.SCRIPT_QUEUE>): Promise<void>;
+}
+export {};

package/dist/core/index.d.ts

@@ -0,0 +1,3 @@
+export { Handler, getHandlerRegistry, HandlerContext, HandlerFor, EventPayloads, type EventKey, } from "./Handler.decorator";
+export { WsHandler } from "./WsHandler";
+export { Runner } from "./Runner";

package/dist/excuteFn.type.d.ts

@@ -1,4 +1,6 @@
 import { Client } from "./Client";
 export type excuteFn = (ctx: Client['ctx'] & {
     params?: any;
+    abortSignal?: AbortSignal;
+    throwIfAborted?: () => void;
 }) => Promise<void>;