@open-wa/driver-playwright 5.0.0-alpha.0

package/dist/index.d.cts

@@ -0,0 +1,118 @@
+import { ConnectOptions, DisposableHandle, DriverCapabilities, IBrowser, IDriver, IDriverContext, IElementHandle, IFrame, IPage, LaunchOptions, NavigationWaitUntil, PageEventHandler, WaitForFunctionOptions } from "@open-wa/driver-interface";
+import { Browser, CDPSession, ElementHandle, Page } from "playwright";
+
+//#region src/PlaywrightDriver.d.ts
+type PlaywrightBrowserType = 'chromium' | 'firefox' | 'webkit' | 'chrome' | 'msedge';
+interface PlaywrightLaunchOptions extends LaunchOptions {
+  browser?: PlaywrightBrowserType;
+  channel?: 'chrome' | 'chrome-beta' | 'chrome-dev' | 'chrome-canary' | 'msedge' | 'msedge-beta' | 'msedge-dev' | 'msedge-canary';
+}
+declare class PlaywrightDriver implements IDriver {
+  readonly name: "playwright";
+  version?: string;
+  readonly capabilities: DriverCapabilities;
+  private playwright;
+  private ctx?;
+  private browserType;
+  constructor(browserType?: PlaywrightBrowserType);
+  init(ctx?: IDriverContext): Promise<void>;
+  launch(options?: PlaywrightLaunchOptions): Promise<IBrowser>;
+  connect(options: ConnectOptions): Promise<IBrowser>;
+  unwrap(): any;
+  has<C extends string>(cap: C): boolean;
+  require<C extends string>(cap: C): void;
+}
+//#endregion
+//#region src/PlaywrightBrowser.d.ts
+declare class PlaywrightBrowser implements IBrowser {
+  private browser;
+  private browserType;
+  private capabilities;
+  readonly name: "playwright";
+  constructor(browser: Browser, browserType: PlaywrightBrowserType, capabilities: DriverCapabilities);
+  newPage(): Promise<IPage>;
+  pages(): Promise<IPage[]>;
+  close(): Promise<void>;
+  isConnected(): boolean;
+  versionString(): Promise<string>;
+  unwrap(): Browser;
+}
+//#endregion
+//#region src/PlaywrightPage.d.ts
+declare class PlaywrightPage implements IPage {
+  private page;
+  private capabilities;
+  readonly name: "playwright";
+  private readonly listenerWrappers;
+  private readonly requestInterceptionRoute;
+  private requestInterceptionEnabled;
+  constructor(page: Page, _browserType: PlaywrightBrowserType, capabilities: DriverCapabilities);
+  goto(url: string, options?: {
+    waitUntil?: NavigationWaitUntil;
+    timeoutMs?: number;
+  }): Promise<void>;
+  url(): string;
+  reload(): Promise<void>;
+  mainFrame(): IFrame;
+  evaluate<Arg, Ret>(fn: (arg: Arg) => Ret | Promise<Ret>, arg: Arg): Promise<Ret>;
+  evaluateScript<Ret = unknown>(script: string): Promise<Ret>;
+  addInitScript(script: string): Promise<DisposableHandle>;
+  setViewport(viewport: {
+    width: number;
+    height: number;
+  }): Promise<void>;
+  setUserAgent(ua: string): Promise<void>;
+  setRequestInterception(enabled: boolean): Promise<void>;
+  waitForSelector(selector: string, options?: {
+    timeoutMs?: number;
+  }): Promise<IElementHandle | null>;
+  waitForFunction(script: string, options?: WaitForFunctionOptions): Promise<void>;
+  waitForFunction<Arg>(fn: (arg: Arg) => boolean, arg: Arg, options?: WaitForFunctionOptions): Promise<void>;
+  $(selector: string): Promise<IElementHandle | null>;
+  $$(selector: string): Promise<IElementHandle[]>;
+  click(selector: string): Promise<void>;
+  type(selector: string, text: string, options?: {
+    delayMs?: number;
+  }): Promise<void>;
+  screenshot(options?: {
+    type?: 'png' | 'jpeg';
+    fullPage?: boolean;
+  }): Promise<Uint8Array>;
+  exposeFunction(name: string, fn: (...args: any[]) => any): Promise<void>;
+  on<K extends string>(event: K, handler: ((...args: any[]) => void | Promise<void>) | PageEventHandler<any>): DisposableHandle;
+  off<K extends string>(event: K, handler: ((...args: any[]) => void | Promise<void>) | PageEventHandler<any>): void;
+  close(): Promise<void>;
+  isClosed(): boolean;
+  has<C extends string>(cap: C): boolean;
+  require<C extends string>(cap: C): void;
+  cdp(): CDPSession;
+  setBypassServiceWorker(bypass: boolean): Promise<void>;
+  pdf(options?: {
+    path?: string;
+    format?: string;
+  }): Promise<Uint8Array>;
+  startTracing(options?: {
+    path?: string;
+    screenshots?: boolean;
+  }): Promise<void>;
+  stopTracing(): Promise<Uint8Array>;
+  unwrap(): Page;
+  private getWrapperSet;
+  private removeWrappedListener;
+  private wrapEventPayload;
+}
+//#endregion
+//#region src/PlaywrightElementHandle.d.ts
+declare class PlaywrightElementHandle implements IElementHandle {
+  private element;
+  constructor(element: ElementHandle);
+  click(): Promise<void>;
+  type(text: string): Promise<void>;
+  getAttribute(name: string): Promise<string | null>;
+  textContent(): Promise<string | null>;
+  dispose(): Promise<void>;
+  unwrap(): ElementHandle;
+}
+//#endregion
+export { PlaywrightBrowser, type PlaywrightBrowserType, PlaywrightDriver, PlaywrightElementHandle, type PlaywrightLaunchOptions, PlaywrightPage };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/PlaywrightDriver.ts","../src/PlaywrightBrowser.ts","../src/PlaywrightPage.ts","../src/PlaywrightElementHandle.ts"],"mappings":"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"}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@open-wa/driver-playwright",
+  "version": "5.0.0-alpha.0",
+  "description": "Playwright driver implementation for open-wa",
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.cjs",
+      "types": "./dist/index.d.cts"
+    }
+  },
+  "dependencies": {
+    "playwright": "^1.41.0",
+    "@open-wa/driver-interface": "5.0.0-alpha.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.1",
+    "typescript": "^6.0.3",
+    "vitest": "4.1.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/open-wa/wa-automate-nodejs.git"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts --format cjs",
+    "dev": "tsdown src/index.ts --format cjs --watch",
+    "lint": "oxlint src",
+    "test": "vitest run"
+  }
+}

package/src/PlaywrightBrowser.ts

@@ -0,0 +1,47 @@
+import { IBrowser, IPage, DriverCapabilities } from '@open-wa/driver-interface';
+import type { Browser } from 'playwright';
+import { PlaywrightPage } from './PlaywrightPage';
+import { PlaywrightBrowserType } from './PlaywrightDriver';
+
+export class PlaywrightBrowser implements IBrowser {
+    readonly name = 'playwright' as const;
+    
+    constructor(
+        private browser: Browser,
+        private browserType: PlaywrightBrowserType,
+        private capabilities: DriverCapabilities
+    ) {}
+    
+    async newPage(): Promise<IPage> {
+        const page = await this.browser.newPage();
+        return new PlaywrightPage(page, this.browserType, this.capabilities);
+    }
+    
+    async pages(): Promise<IPage[]> {
+        const contexts = this.browser.contexts();
+        const allPages: IPage[] = [];
+        
+        for (const context of contexts) {
+            const pages = context.pages();
+            allPages.push(...pages.map(p => new PlaywrightPage(p, this.browserType, this.capabilities)));
+        }
+        
+        return allPages;
+    }
+    
+    async close(): Promise<void> {
+        await this.browser.close();
+    }
+    
+    isConnected(): boolean {
+        return this.browser.isConnected();
+    }
+    
+    async versionString(): Promise<string> {
+        return this.browser.version();
+    }
+    
+    unwrap(): Browser {
+        return this.browser;
+    }
+}

package/src/PlaywrightDriver.ts

@@ -0,0 +1,114 @@
+import { IDriver, IBrowser, LaunchOptions, ConnectOptions, IDriverContext, DriverCapabilities } from '@open-wa/driver-interface';
+import { PlaywrightBrowser } from './PlaywrightBrowser';
+
+export type PlaywrightBrowserType = 'chromium' | 'firefox' | 'webkit' | 'chrome' | 'msedge';
+
+export interface PlaywrightLaunchOptions extends LaunchOptions {
+    browser?: PlaywrightBrowserType;
+    channel?: 'chrome' | 'chrome-beta' | 'chrome-dev' | 'chrome-canary' | 'msedge' | 'msedge-beta' | 'msedge-dev' | 'msedge-canary';
+}
+
+export class PlaywrightDriver implements IDriver {
+    readonly name = 'playwright' as const;
+    version?: string;
+    readonly capabilities: DriverCapabilities;
+    
+    private playwright: any;
+    private ctx?: IDriverContext;
+    private browserType: PlaywrightBrowserType;
+    
+    constructor(browserType: PlaywrightBrowserType = 'chromium') {
+        this.browserType = browserType;
+        
+        this.capabilities = {
+            cdp: browserType === 'chromium' || browserType === 'chrome' || browserType === 'msedge' 
+                ? { supported: true, notes: 'Chromium-based only' }
+                : { supported: false, reason: 'CDP only available in Chromium browsers' },
+            requestInterception: { supported: true },
+            serviceWorkerBypass: { supported: true, notes: 'Different API than Puppeteer' },
+            stealth: { supported: false, reason: 'No puppeteer-extra equivalent' },
+            pdf: browserType === 'chromium' || browserType === 'chrome' || browserType === 'msedge'
+                ? { supported: true, notes: 'Chromium-based only' }
+                : { supported: false, reason: 'PDF generation only in Chromium' },
+            tracing: { supported: true },
+            persistentContext: { supported: true },
+            browserExtensions: { supported: false, reason: 'Playwright limitation' },
+            exposeBinding: { supported: true },
+        };
+    }
+    
+    async init(ctx?: IDriverContext): Promise<void> {
+        this.ctx = ctx;
+        
+        this.playwright = await import('playwright');
+        this.version = this.playwright.version || 'unknown';
+        
+        this.ctx?.logger?.info('PlaywrightDriver initialized', { 
+            version: this.version,
+            browserType: this.browserType 
+        });
+    }
+    
+    async launch(options?: PlaywrightLaunchOptions): Promise<IBrowser> {
+        if (!this.playwright) await this.init();
+        
+        const browserType = (options as PlaywrightLaunchOptions)?.browser || this.browserType;
+        const channel = (options as PlaywrightLaunchOptions)?.channel;
+        
+        let browserEngine: any;
+        if (browserType === 'chrome' || browserType === 'msedge') {
+            browserEngine = this.playwright.chromium;
+        } else if (browserType === 'firefox') {
+            browserEngine = this.playwright.firefox;
+        } else if (browserType === 'webkit') {
+            browserEngine = this.playwright.webkit;
+        } else {
+            browserEngine = this.playwright[browserType];
+        }
+        
+        const launchOptions: any = {
+            headless: options?.headless ?? true,
+            executablePath: options?.executablePath,
+            args: options?.args,
+            timeout: options?.timeoutMs,
+        };
+        
+        if (channel) {
+            launchOptions.channel = channel;
+        }
+        
+        const browser = await browserEngine.launch(launchOptions);
+        
+        return new PlaywrightBrowser(browser, browserType, this.capabilities);
+    }
+    
+    async connect(options: ConnectOptions): Promise<IBrowser> {
+        if (!this.playwright) await this.init();
+        
+        const browser = await this.playwright.chromium.connect({
+            wsEndpoint: options.wsEndpoint,
+            timeout: options.timeoutMs,
+        });
+        
+        return new PlaywrightBrowser(browser, this.browserType, this.capabilities);
+    }
+    
+    unwrap(): any {
+        return this.playwright;
+    }
+    
+    has<C extends string>(cap: C): boolean {
+        return (this.capabilities as any)[cap]?.supported === true;
+    }
+    
+    require<C extends string>(cap: C): void {
+        if (!this.has(cap)) {
+            const capability = (this.capabilities as any)[cap];
+            throw new Error(
+                `Driver '${this.name}' does not support capability '${cap}'${
+                    capability?.reason ? `: ${capability.reason}` : ''
+                }`
+            );
+        }
+    }
+}

package/src/PlaywrightElementHandle.ts

@@ -0,0 +1,32 @@
+import { IElementHandle } from '@open-wa/driver-interface';
+import type { ElementHandle } from 'playwright';
+
+export class PlaywrightElementHandle implements IElementHandle {
+    constructor(private element: ElementHandle) {}
+    
+    async click(): Promise<void> {
+        await this.element.click();
+    }
+    
+    async type(text: string): Promise<void> {
+        await this.element.type(text);
+    }
+    
+    async getAttribute(name: string): Promise<string | null> {
+        const value = await this.element.getAttribute(name);
+        return value;
+    }
+    
+    async textContent(): Promise<string | null> {
+        const text = await this.element.textContent();
+        return text;
+    }
+    
+    async dispose(): Promise<void> {
+        await this.element.dispose();
+    }
+    
+    unwrap(): ElementHandle {
+        return this.element;
+    }
+}