@allwright.dev/core 0.0.52 → 0.0.54

package/README.md

@@ -13,11 +13,14 @@ import { firefox } from "@allwright.dev/core";
 
 const browser = await firefox.launch();
 const page = browser.page();
-await page.goto("https://example.com");
+await page.goto("https://themoderninternet.vercel.app");
+await page.click(
+  "xpath=//div[contains(@class,'card')][.//h2[normalize-space()='Form Inputs']]//button[normalize-space()='Visit page']",
+);
 await browser.close();
 ```
 
-A small runnable example also lives in [examples/basic.ts](./examples/basic.ts), and the fuller end-to-end playground lives in [examples/playground.ts](./examples/playground.ts).
+Runnable examples live in [examples/web-basic.ts](./examples/web-basic.ts) and [examples/android-basic.ts](./examples/android-basic.ts).
 
 Shared config files are stack-agnostic and can live in `allwright.config.yaml` or `allwright.config.json`.
 The shared schema lives at the repo root in `allwright.schema.json`.

package/dist/bootstrap.d.ts

@@ -1,4 +1,2 @@
 export declare function ensureRuntimeReady(serverAddr: string): Promise<string>;
 export declare function shutdownManagedServer(): Promise<void>;
-export declare function ensurePluginsInstalled(pluginIds: string[]): Promise<void>;
-export declare function invokePlugin<TResponse>(pluginId: string, request: unknown): Promise<TResponse>;

package/dist/bootstrap.js

@@ -12,7 +12,7 @@ const ALLWRIGHT_HOME_ENV_VAR = "ALLWRIGHT_HOME";
 const ALLWRIGHT_REPOSITORY_ENV_VAR = "ALLWRIGHT_REPOSITORY";
 const ALLWRIGHT_VERSION_ENV_VAR = "ALLWRIGHT_VERSION";
 const DEFAULT_RELEASE_REPOSITORY = "allwright-dev/allwright";
-const DEFAULT_RELEASE_VERSION = "0.0.52";
+const DEFAULT_RELEASE_VERSION = "0.0.54";
 const STARTUP_TIMEOUT_MS = 20_000;
 const PING_TIMEOUT_MS = 1_000;
 const PROTO_ROOT = fileURLToPath(new URL("../proto/", import.meta.url));
@@ -168,65 +168,6 @@ async function installCli() {
     fs.rmSync(assetPath, { force: true });
     return cliPath;
 }
-export async function ensurePluginsInstalled(pluginIds) {
-    const expectedVersion = expectedRuntimeVersion();
-    const cliPath = await ensureCliAvailable(expectedVersion);
-    ensurePluginsInstalledWithCli(cliPath, expectedVersion, pluginIds);
-}
-export async function invokePlugin(pluginId, request) {
-    const expectedVersion = expectedRuntimeVersion();
-    const cliPath = await ensureCliAvailable(expectedVersion);
-    const requestJson = JSON.stringify(request);
-    const result = spawnSync(cliPath, ["plugin", "invoke", pluginId, "--request-json", requestJson], {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    if (result.error) {
-        throw new Error(`failed to invoke allwright ${pluginId} plugin with ${cliPath}: ${result.error.message}`);
-    }
-    if (result.status !== 0) {
-        const details = [result.stdout, result.stderr]
-            .map((value) => value?.trim())
-            .filter((value) => !!value)
-            .join("\n");
-        throw new Error(details
-            ? `allwright ${pluginId} plugin invocation failed:\n${details}`
-            : `allwright ${pluginId} plugin invocation failed`);
-    }
-    try {
-        return JSON.parse(result.stdout);
-    }
-    catch (error) {
-        throw new Error(`failed to decode allwright ${pluginId} plugin response: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-function ensurePluginsInstalledWithCli(cliPath, expectedVersion, pluginIds) {
-    for (const pluginId of new Set(pluginIds.map((value) => value.trim()).filter(Boolean))) {
-        const pluginPath = path.join(allwrightHome(), "plugins", pluginId, "lib", pluginLibraryFilename(pluginId));
-        if (isFile(pluginPath) && installedPluginVersion(pluginId) === expectedVersion) {
-            continue;
-        }
-        const result = spawnSync(cliPath, ["plugin", "install", pluginId, "--version", expectedVersion], {
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        if (result.error) {
-            throw new Error(`failed to install allwright ${pluginId} plugin with ${cliPath}: ${result.error.message}`);
-        }
-        if (result.status !== 0 || !isFile(pluginPath)) {
-            const details = [result.stdout, result.stderr]
-                .map((value) => value?.trim())
-                .filter((value) => !!value)
-                .join("\n");
-            throw new Error(details
-                ? `allwright attempted to install the \`${pluginId}\` plugin automatically, but the install did not complete successfully:\n${details}`
-                : `allwright attempted to install the \`${pluginId}\` plugin automatically, but the install did not complete successfully`);
-        }
-        if (installedPluginVersion(pluginId) !== expectedVersion) {
-            throw new Error(`allwright attempted to install the \`${pluginId}\` plugin automatically, but version ${expectedVersion} is still not active`);
-        }
-    }
-}
 async function resolveReleaseTag() {
     const version = process.env[ALLWRIGHT_VERSION_ENV_VAR]?.trim() || DEFAULT_RELEASE_VERSION;
     if (version !== "latest") {
@@ -325,23 +266,6 @@ function isLocalServerAddr(serverAddr) {
     const host = parseServerHost(serverAddr);
     return host === "127.0.0.1" || host === "localhost" || host === "::1";
 }
-function installedPluginVersion(pluginId) {
-    const manifestPath = path.join(allwrightHome(), "plugins.txt");
-    if (!isFile(manifestPath)) {
-        return null;
-    }
-    for (const line of fs.readFileSync(manifestPath, "utf8").split(/\r?\n/)) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith("#")) {
-            continue;
-        }
-        const [id, , version] = trimmed.split("\t", 3);
-        if (id === pluginId && version) {
-            return normalizeReleaseVersion(version);
-        }
-    }
-    return null;
-}
 async function allocateManagedServerAddr(serverAddr) {
     const host = localBindingHost(serverAddr);
     const port = await new Promise((resolve, reject) => {
@@ -454,26 +378,6 @@ function findExtractedCli(extractRoot) {
     }
     return null;
 }
-function pluginLibraryFilename(pluginId) {
-    const stem = pluginLibraryStem(pluginId);
-    if (process.platform === "darwin") {
-        return `lib${stem}.dylib`;
-    }
-    if (process.platform === "win32") {
-        return `${stem}.dll`;
-    }
-    return `lib${stem}.so`;
-}
-function pluginLibraryStem(pluginId) {
-    switch (pluginId) {
-        case "web":
-            return "allwright_surface_web";
-        case "mobile-android":
-            return "allwright_surface_mobile_android";
-        default:
-            throw new Error(`automatic install is not supported for allwright plugin \`${pluginId}\``);
-    }
-}
 function autoInstallEnabled() {
     const raw = process.env[ALLWRIGHT_AUTO_INSTALL_ENV_VAR]?.trim().toLowerCase();
     return raw !== "0" && raw !== "false" && raw !== "no";

package/dist/browser.js

@@ -33,7 +33,7 @@ export class BrowserImpl {
         this.launchNote = browserInfo.launchNote;
         this.cdpWebSocketURL = browserInfo.cdpWebSocketURL;
         this.userDataDir = browserInfo.userDataDir;
-        this.#initialPage = this.#createPage(state.launched.initialTabSessionId ?? "");
+        this.#initialPage = this.#createPage(state.launched.initialPageSessionId ?? "");
     }
     sessionId;
     browserName;
@@ -52,17 +52,17 @@ export class BrowserImpl {
     async newPage(options = {}) {
         this.#ensureOpen();
         this.#stream.write({
-            openTab: {
+            openContext: {
                 retryOptions: options.timeoutMs ? { timeoutMs: options.timeoutMs } : undefined,
             },
         });
         while (true) {
             const event = await this.#queue.next();
-            if (event.tabOpened?.tabSessionId) {
-                return this.#createPage(event.tabOpened.tabSessionId);
+            if (event.contextOpened?.contextSessionId) {
+                return this.#createPage(event.contextOpened.contextSessionId);
             }
             if (event.error?.message) {
-                throw formatActionError("open tab", event.error.message);
+                throw formatActionError("open page", event.error.message);
             }
         }
     }
@@ -77,6 +77,9 @@ export class BrowserImpl {
             const event = await this.#queue.next();
             if (event.closed) {
                 this.#closed = true;
+                for (const page of this.#pages.values()) {
+                    page.dispose();
+                }
                 this.#stream.end();
                 return;
             }

package/dist/index.d.ts

@@ -5,7 +5,7 @@ import { PageImpl } from "./page.js";
 import { setServerAddr, shutdown } from "./runtime.js";
 import type { Browser, BrowserKind, BrowserType, LaunchOptions, Page, ResolveConfigOptions, ResolvedAllwrightConfig } from "./types.js";
 export { findConfigFile, loadConfigFile, resolveConfig, setServerAddr, shutdown };
-export type { AllwrightConfig, Browser, BrowserInfo, BrowserKind, BrowserType, ClickResult, CommandOptions, CountResult, ElementResult, FillResult, HighlightOptions, HighlightResult, LaunchOptions, MobileAndroidConnectOptions, MobileAndroidDevice, MobileAndroidLaunchOptions, MobileAndroidLocator, MobileAndroidPage, Locator, LocatorInfo, MobileSurfaceNamespace, NavigateResult, Page, PageInfo, PressOptions, PressResult, ResolveConfigOptions, ResolvedAllwrightConfig, RetryConfig, TextResult, WaitForSelectorOptions, WaitForSelectorResult, } from "./types.js";
+export type { AllwrightConfig, Browser, BrowserInfo, BrowserKind, BrowserType, ClickResult, CommandOptions, CountResult, ElementResult, FillResult, HighlightOptions, HighlightResult, LaunchOptions, MobileAndroidConnectOptions, MobileAndroidDevice, MobileAndroidLaunchOptions, MobileAndroidLocator, MobileAndroidApp, Locator, LocatorInfo, MobileSurfaceNamespace, NavigateResult, Page, PageInfo, PressOptions, PressResult, ResolveConfigOptions, ResolvedAllwrightConfig, RetryConfig, ScreenshotResult, TextResult, WaitForSelectorOptions, WaitForSelectorResult, } from "./types.js";
 export declare const chromium: BrowserType;
 export declare const firefox: BrowserType;
 export { mobile };

package/dist/mobile.js

@@ -1,59 +1,117 @@
-import { invokePlugin } from "./bootstrap.js";
+import { createBrowserSessionHandle, createPageHandle, getRuntime } from "./runtime.js";
 import { chainMobileSelectorForTransport, normalizeMobileSelectorForTransport } from "./mobileSelectors.js";
-function timeoutMsOf(options) {
-    return options?.timeoutMs;
+function retryOptions(timeoutMs) {
+    return timeoutMs ? { timeoutMs } : undefined;
 }
-async function invokeAndroidExpected(commandName, request) {
-    const envelope = await invokePlugin("mobile-android", request);
-    if (!envelope.ok) {
-        throw new Error(envelope.error ?? `mobile-android plugin ${commandName} failed`);
-    }
-    if (envelope.result === undefined) {
-        throw new Error(`mobile-android plugin ${commandName} returned no result`);
-    }
-    return envelope.result;
-}
-class MobileAndroidPageImpl {
-    browserSession;
-    pageSession;
-    constructor(browserSession, pageSession) {
-        this.browserSession = browserSession;
-        this.pageSession = pageSession;
-    }
-    get sessionId() {
-        return this.pageSession.page_id;
+class MobileAndroidAppImpl {
+    sessionId;
+    #runtime;
+    #surfaceSessionId;
+    #handlePromise = null;
+    constructor(runtime, surfaceSessionId, sessionId) {
+        this.sessionId = sessionId;
+        this.#runtime = runtime;
+        this.#surfaceSessionId = surfaceSessionId;
     }
     locator(selector) {
         return new MobileAndroidLocatorImpl(this, normalizeMobileSelectorForTransport(selector));
     }
     async click(selector, options = {}) {
-        const result = await invokeAndroidExpected("click", {
-            command: "click_element",
-            browser_session: this.browserSession,
-            page_session: this.pageSession,
-            selector: normalizeMobileSelectorForTransport(selector),
-            timeout_ms: timeoutMsOf(options),
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        handle.stream.write({
+            surfaceSessionId: this.#surfaceSessionId,
+            contextSessionId: this.sessionId,
+            clickElement: {
+                cssSelector: normalizeMobileSelectorForTransport(selector),
+                retryOptions: retryOptions(options.timeoutMs),
+            },
         });
-        return {
-            selector: result.selector,
-            note: result.note,
-            bidiSessionId: result.session_id,
-        };
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.elementClicked) {
+                return {
+                    selector: event.elementClicked.cssSelector ?? "",
+                    note: event.elementClicked.note ?? "",
+                    bidiSessionId: event.elementClicked.bidiSessionId ?? "",
+                };
+            }
+            if (event.error?.message) {
+                throw new Error(event.error.message);
+            }
+            if (event.closed) {
+                handle.closed = true;
+                throw new Error(`android app session ${this.sessionId} closed while clicking`);
+            }
+        }
     }
     async fill(selector, value, options = {}) {
-        const result = await invokeAndroidExpected("fill", {
-            command: "fill_element",
-            browser_session: this.browserSession,
-            page_session: this.pageSession,
-            selector: normalizeMobileSelectorForTransport(selector),
-            value,
-            timeout_ms: timeoutMsOf(options),
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        handle.stream.write({
+            surfaceSessionId: this.#surfaceSessionId,
+            contextSessionId: this.sessionId,
+            fillElement: {
+                cssSelector: normalizeMobileSelectorForTransport(selector),
+                value,
+                retryOptions: retryOptions(options.timeoutMs),
+            },
         });
-        return {
-            selector: result.selector,
-            value: result.value,
-            note: result.note,
-        };
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.elementFilled) {
+                return {
+                    selector: event.elementFilled.cssSelector ?? "",
+                    value: event.elementFilled.value ?? "",
+                    note: event.elementFilled.note ?? "",
+                };
+            }
+            if (event.error?.message) {
+                throw new Error(event.error.message);
+            }
+            if (event.closed) {
+                handle.closed = true;
+                throw new Error(`android app session ${this.sessionId} closed while filling`);
+            }
+        }
+    }
+    async screenshot(options = {}) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        handle.stream.write({
+            surfaceSessionId: this.#surfaceSessionId,
+            contextSessionId: this.sessionId,
+            screenshot: {
+                retryOptions: retryOptions(options.timeoutMs),
+            },
+        });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.screenshotCaptured?.pngData) {
+                return {
+                    pngData: event.screenshotCaptured.pngData,
+                    note: event.screenshotCaptured.note ?? "",
+                };
+            }
+            if (event.error?.message) {
+                throw new Error(event.error.message);
+            }
+            if (event.closed) {
+                handle.closed = true;
+                throw new Error(`android app session ${this.sessionId} closed while capturing screenshot`);
+            }
+        }
+    }
+    async #getHandle() {
+        if (!this.#handlePromise) {
+            this.#handlePromise = createPageHandle(this.#runtime);
+        }
+        return this.#handlePromise;
+    }
+    #ensureOpen(handle) {
+        if (handle.closed) {
+            throw new Error(`android app session ${this.sessionId} is closed`);
+        }
     }
 }
 class MobileAndroidLocatorImpl {
@@ -74,48 +132,81 @@ class MobileAndroidLocatorImpl {
     }
 }
 class MobileAndroidDeviceImpl {
-    connectInfoRaw;
-    #initialPage;
-    constructor(connectInfoRaw) {
-        this.connectInfoRaw = connectInfoRaw;
-        this.#initialPage = new MobileAndroidPageImpl(this.connectInfoRaw.browser_session, this.connectInfoRaw.initial_page.page_session);
-    }
-    get sessionId() {
-        return this.connectInfoRaw.browser_session.automation.session_id;
-    }
-    page() {
-        return this.#initialPage;
-    }
-    initialPage() {
-        return this.#initialPage;
+    sessionId;
+    surfaceSessionId;
+    runtime;
+    #stream;
+    #queue;
+    #closed = false;
+    #currentApp;
+    constructor(sessionId, surfaceSessionId, runtime, stream, queue, initialAppSessionId) {
+        this.sessionId = sessionId;
+        this.surfaceSessionId = surfaceSessionId;
+        this.runtime = runtime;
+        this.#stream = stream;
+        this.#queue = queue;
+        this.#currentApp = new MobileAndroidAppImpl(runtime, surfaceSessionId, initialAppSessionId);
+    }
+    app() {
+        return this.#currentApp;
+    }
+    initialApp() {
+        return this.#currentApp;
     }
     async launch(options = {}) {
-        const page = await invokeAndroidExpected("launch", {
-            command: "launch_app",
-            browser_session: this.connectInfoRaw.browser_session,
-            options: {
-                apk_path: options.apkPath,
-                app_id: options.appId,
-                launch_activity: options.launchActivity,
-                stop_before_launch: options.stopBeforeLaunch ?? false,
-                timeout_ms: timeoutMsOf(options),
+        this.#ensureOpen();
+        this.#stream.write({
+            launchApp: {
+                apkPath: options.apkPath,
+                appId: options.appId,
+                launchActivity: options.launchActivity,
+                stopBeforeLaunch: options.stopBeforeLaunch ?? false,
+                retryOptions: retryOptions(options.timeoutMs),
             },
         });
-        this.#initialPage = new MobileAndroidPageImpl(this.connectInfoRaw.browser_session, page.page_session);
-        return this.#initialPage;
+        while (true) {
+            const event = await this.#queue.next();
+            if (event.appLaunched?.appSessionId) {
+                this.#currentApp = new MobileAndroidAppImpl(this.runtime, this.surfaceSessionId, event.appLaunched.appSessionId);
+                return this.#currentApp;
+            }
+            if (event.error?.message) {
+                throw new Error(event.error.message);
+            }
+            if (event.closed) {
+                this.#closed = true;
+                throw new Error(`android device session ${this.sessionId} closed while launching app`);
+            }
+        }
+    }
+    #ensureOpen() {
+        if (this.#closed) {
+            throw new Error(`android device session ${this.sessionId} is closed`);
+        }
     }
 }
 class MobileAndroidSurfaceImpl {
     async connect(options = {}) {
-        const connectInfo = await invokeAndroidExpected("connect", {
-            command: "connect",
-            platform: "android",
-            device: options.device,
-            adb_endpoint: options.adbEndpoint,
-            preserve_app_state: options.preserveAppState ?? false,
-            timeout_ms: timeoutMsOf(options),
+        const runtime = await getRuntime();
+        const { stream, queue } = await createBrowserSessionHandle(runtime);
+        stream.write({
+            connectMobile: {
+                platform: 1,
+                device: options.device,
+                adbEndpoint: options.adbEndpoint,
+                preserveAppState: options.preserveAppState ?? false,
+                retryOptions: retryOptions(options.timeoutMs),
+            },
         });
-        return new MobileAndroidDeviceImpl(connectInfo);
+        while (true) {
+            const event = await queue.next();
+            if (event.mobileConnected?.initialAppSessionId) {
+                return new MobileAndroidDeviceImpl(event.mobileConnected.deviceSessionId ?? event.sessionId ?? "", event.sessionId ?? "", runtime, stream, queue, event.mobileConnected.initialAppSessionId);
+            }
+            if (event.error?.message) {
+                throw new Error(event.error.message);
+            }
+        }
     }
 }
 export const mobile = {

package/dist/page.d.ts

@@ -1,4 +1,4 @@
-import type { ClickResult, CommandOptions, CountResult, ElementResult, FillResult, HighlightOptions, HighlightResult, Locator, NavigateResult, Page, PageInfo, PressOptions, PressResult, RuntimeClient, TextResult, WaitForSelectorOptions, WaitForSelectorResult } from "./types.js";
+import type { ClickResult, CommandOptions, CountResult, ElementResult, FillResult, HighlightOptions, HighlightResult, Locator, NavigateResult, Page, PageInfo, PressOptions, PressResult, RuntimeClient, ScreenshotResult, TextResult, WaitForSelectorOptions, WaitForSelectorResult } from "./types.js";
 export declare class PageImpl implements Page {
     #private;
     constructor(input: PageInfo & {
@@ -18,8 +18,10 @@ export declare class PageImpl implements Page {
     textContent(selector: string, options?: CommandOptions): Promise<TextResult>;
     innerText(selector: string, options?: CommandOptions): Promise<TextResult>;
     waitForSelector(selector: string, options?: WaitForSelectorOptions): Promise<WaitForSelectorResult>;
+    screenshot(options?: CommandOptions): Promise<ScreenshotResult>;
     close(): Promise<void>;
     ping(message?: string): Promise<string>;
     pageInfo(): PageInfo;
     navigate(url: string, options?: CommandOptions): Promise<NavigateResult>;
+    dispose(): void;
 }