@allwright.dev/core 0.0.54 → 0.0.57

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.54";
+const DEFAULT_RELEASE_VERSION = "0.0.57";
 const STARTUP_TIMEOUT_MS = 20_000;
 const PING_TIMEOUT_MS = 1_000;
 const PROTO_ROOT = fileURLToPath(new URL("../proto/", import.meta.url));

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, MobileAndroidApp, Locator, LocatorInfo, MobileSurfaceNamespace, NavigateResult, Page, PageInfo, PressOptions, PressResult, ResolveConfigOptions, ResolvedAllwrightConfig, RetryConfig, ScreenshotResult, 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, ScreenshotOptions, ScreenshotResult, TextResult, WaitForSelectorOptions, WaitForSelectorResult, } from "./types.js";
 export declare const chromium: BrowserType;
 export declare const firefox: BrowserType;
 export { mobile };

package/dist/mobile.js

@@ -1,4 +1,5 @@
 import { createBrowserSessionHandle, createPageHandle, getRuntime } from "./runtime.js";
+import { writeFile } from "node:fs/promises";
 import { chainMobileSelectorForTransport, normalizeMobileSelectorForTransport } from "./mobileSelectors.js";
 function retryOptions(timeoutMs) {
     return timeoutMs ? { timeoutMs } : undefined;
@@ -45,6 +46,63 @@ class MobileAndroidAppImpl {
             }
         }
     }
+    async count(selector, options = {}) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        handle.stream.write({
+            surfaceSessionId: this.#surfaceSessionId,
+            contextSessionId: this.sessionId,
+            countElements: {
+                cssSelector: normalizeMobileSelectorForTransport(selector),
+                retryOptions: retryOptions(options.timeoutMs),
+            },
+        });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.elementCounted) {
+                return {
+                    selector: event.elementCounted.cssSelector ?? "",
+                    count: event.elementCounted.count ?? 0,
+                    note: event.elementCounted.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 counting elements`);
+            }
+        }
+    }
+    async focus(selector, options = {}) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        handle.stream.write({
+            surfaceSessionId: this.#surfaceSessionId,
+            contextSessionId: this.sessionId,
+            focusElement: {
+                cssSelector: normalizeMobileSelectorForTransport(selector),
+                retryOptions: retryOptions(options.timeoutMs),
+            },
+        });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.elementFocused) {
+                return {
+                    selector: event.elementFocused.cssSelector ?? "",
+                    note: event.elementFocused.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 focusing`);
+            }
+        }
+    }
     async fill(selector, value, options = {}) {
         const handle = await this.#getHandle();
         this.#ensureOpen(handle);
@@ -75,6 +133,73 @@ class MobileAndroidAppImpl {
             }
         }
     }
+    async press(selector, key, options = {}) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        handle.stream.write({
+            surfaceSessionId: this.#surfaceSessionId,
+            contextSessionId: this.sessionId,
+            pressKey: {
+                cssSelector: normalizeMobileSelectorForTransport(selector),
+                key,
+                text: options.text,
+                retryOptions: retryOptions(options.timeoutMs),
+            },
+        });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.keyPressed) {
+                return {
+                    selector: event.keyPressed.cssSelector ?? "",
+                    key: event.keyPressed.key ?? "",
+                    note: event.keyPressed.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 pressing key`);
+            }
+        }
+    }
+    async textContent(selector, options = {}) {
+        return this.#readText(selector, options, true);
+    }
+    async innerText(selector, options = {}) {
+        return this.#readText(selector, options, false);
+    }
+    async waitForSelector(selector, options = {}) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        handle.stream.write({
+            surfaceSessionId: this.#surfaceSessionId,
+            contextSessionId: this.sessionId,
+            waitForSelector: {
+                cssSelector: normalizeMobileSelectorForTransport(selector),
+                visible: options.visible,
+                retryOptions: retryOptions(options.timeoutMs),
+            },
+        });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.selectorWaitSatisfied) {
+                return {
+                    selector: event.selectorWaitSatisfied.cssSelector ?? "",
+                    visible: event.selectorWaitSatisfied.visible ?? false,
+                    note: event.selectorWaitSatisfied.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 waiting for selector`);
+            }
+        }
+    }
     async screenshot(options = {}) {
         const handle = await this.#getHandle();
         this.#ensureOpen(handle);
@@ -83,15 +208,20 @@ class MobileAndroidAppImpl {
             contextSessionId: this.sessionId,
             screenshot: {
                 retryOptions: retryOptions(options.timeoutMs),
+                fullPage: options.fullPage,
             },
         });
         while (true) {
             const event = await handle.queue.next();
             if (event.screenshotCaptured?.pngData) {
-                return {
+                const screenshot = {
                     pngData: event.screenshotCaptured.pngData,
                     note: event.screenshotCaptured.note ?? "",
                 };
+                if (options.path) {
+                    await writeFile(options.path, screenshot.pngData);
+                }
+                return screenshot;
             }
             if (event.error?.message) {
                 throw new Error(event.error.message);
@@ -113,6 +243,52 @@ class MobileAndroidAppImpl {
             throw new Error(`android app session ${this.sessionId} is closed`);
         }
     }
+    async #readText(selector, options, textContent) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        const transportSelector = normalizeMobileSelectorForTransport(selector);
+        handle.stream.write(textContent
+            ? {
+                surfaceSessionId: this.#surfaceSessionId,
+                contextSessionId: this.sessionId,
+                getTextContent: {
+                    cssSelector: transportSelector,
+                    retryOptions: retryOptions(options.timeoutMs),
+                },
+            }
+            : {
+                surfaceSessionId: this.#surfaceSessionId,
+                contextSessionId: this.sessionId,
+                getInnerText: {
+                    cssSelector: transportSelector,
+                    retryOptions: retryOptions(options.timeoutMs),
+                },
+            });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.textContentResolved) {
+                return {
+                    selector: event.textContentResolved.cssSelector ?? "",
+                    text: event.textContentResolved.text ?? "",
+                    note: event.textContentResolved.note ?? "",
+                };
+            }
+            if (event.innerTextResolved) {
+                return {
+                    selector: event.innerTextResolved.cssSelector ?? "",
+                    text: event.innerTextResolved.text ?? "",
+                    note: event.innerTextResolved.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 reading text`);
+            }
+        }
+    }
 }
 class MobileAndroidLocatorImpl {
     page;
@@ -127,6 +303,24 @@ class MobileAndroidLocatorImpl {
     async fill(value, options = {}) {
         return this.page.fill(this.selector, value, options);
     }
+    async count(options = {}) {
+        return this.page.count(this.selector, options);
+    }
+    async focus(options = {}) {
+        return this.page.focus(this.selector, options);
+    }
+    async press(key, options = {}) {
+        return this.page.press(this.selector, key, options);
+    }
+    async textContent(options = {}) {
+        return this.page.textContent(this.selector, options);
+    }
+    async innerText(options = {}) {
+        return this.page.innerText(this.selector, options);
+    }
+    async waitFor(options = {}) {
+        return this.page.waitForSelector(this.selector, options);
+    }
     locator(selector) {
         return new MobileAndroidLocatorImpl(this.page, chainMobileSelectorForTransport(this.selector, selector));
     }

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, ScreenshotResult, TextResult, WaitForSelectorOptions, WaitForSelectorResult } from "./types.js";
+import type { ClickResult, CommandOptions, CountResult, ElementResult, FillResult, HighlightOptions, HighlightResult, Locator, NavigateResult, Page, PageInfo, PressOptions, PressResult, RuntimeClient, ScreenshotOptions, ScreenshotResult, TextResult, WaitForSelectorOptions, WaitForSelectorResult } from "./types.js";
 export declare class PageImpl implements Page {
     #private;
     constructor(input: PageInfo & {
@@ -18,7 +18,7 @@ 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>;
+    screenshot(options?: ScreenshotOptions): Promise<ScreenshotResult>;
     close(): Promise<void>;
     ping(message?: string): Promise<string>;
     pageInfo(): PageInfo;

package/dist/page.js

@@ -1,4 +1,5 @@
 import { LocatorImpl } from "./locator.js";
+import { writeFile } from "node:fs/promises";
 import { formatActionError } from "./errors.js";
 import { normalizeSelectorForTransport } from "./selectors.js";
 import { createPageHandle } from "./runtime.js";
@@ -312,15 +313,20 @@ export class PageImpl {
             contextSessionId: this.sessionId,
             screenshot: {
                 retryOptions: options.timeoutMs ? { timeoutMs: options.timeoutMs } : undefined,
+                fullPage: options.fullPage,
             },
         });
         while (true) {
             const event = await handle.queue.next();
             if (event.screenshotCaptured?.pngData) {
-                return {
+                const screenshot = {
                     pngData: event.screenshotCaptured.pngData,
                     note: event.screenshotCaptured.note ?? "",
                 };
+                if (options.path) {
+                    await writeFile(options.path, screenshot.pngData);
+                }
+                return screenshot;
             }
             if (event.error?.message) {
                 throw formatActionError("screenshot", event.error.message);

package/dist/types.d.ts

@@ -71,6 +71,10 @@ export interface ScreenshotResult {
     pngData: Uint8Array;
     note: string;
 }
+export interface ScreenshotOptions extends CommandOptions {
+    fullPage?: boolean;
+    path?: string;
+}
 export interface BrowserInfo {
     sessionId: string;
     browserName: string;
@@ -114,7 +118,7 @@ export interface Page extends PageInfo {
     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>;
+    screenshot(options?: ScreenshotOptions): Promise<ScreenshotResult>;
     close(): Promise<void>;
     ping(message?: string): Promise<string>;
     pageInfo(): PageInfo;
@@ -136,15 +140,27 @@ export interface MobileAndroidLocator {
     readonly page: MobileAndroidApp;
     readonly selector: string;
     click(options?: CommandOptions): Promise<ClickResult>;
+    count(options?: CommandOptions): Promise<CountResult>;
+    focus(options?: CommandOptions): Promise<ElementResult>;
     fill(value: string, options?: CommandOptions): Promise<FillResult>;
+    press(key: string, options?: PressOptions): Promise<PressResult>;
+    textContent(options?: CommandOptions): Promise<TextResult>;
+    innerText(options?: CommandOptions): Promise<TextResult>;
+    waitFor(options?: WaitForSelectorOptions): Promise<WaitForSelectorResult>;
     locator(selector: string): MobileAndroidLocator;
 }
 export interface MobileAndroidApp {
     readonly sessionId: string;
     locator(selector: string): MobileAndroidLocator;
     click(selector: string, options?: CommandOptions): Promise<ClickResult>;
+    count(selector: string, options?: CommandOptions): Promise<CountResult>;
+    focus(selector: string, options?: CommandOptions): Promise<ElementResult>;
     fill(selector: string, value: string, options?: CommandOptions): Promise<FillResult>;
-    screenshot(options?: CommandOptions): Promise<ScreenshotResult>;
+    press(selector: string, key: string, options?: PressOptions): Promise<PressResult>;
+    textContent(selector: string, options?: CommandOptions): Promise<TextResult>;
+    innerText(selector: string, options?: CommandOptions): Promise<TextResult>;
+    waitForSelector(selector: string, options?: WaitForSelectorOptions): Promise<WaitForSelectorResult>;
+    screenshot(options?: ScreenshotOptions): Promise<ScreenshotResult>;
 }
 export interface MobileAndroidDevice {
     readonly sessionId: string;
@@ -582,6 +598,7 @@ export interface ScreenshotRequest {
         retryOptions?: {
             timeoutMs?: number;
         };
+        fullPage?: boolean;
     };
 }
 export interface CloseContextRequest {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allwright.dev/core",
-  "version": "0.0.54",
+  "version": "0.0.57",
   "description": "High-level TypeScript client for the allwright automation engine.",
   "license": "MIT",
   "type": "module",

package/proto/core/v1/context.proto

@@ -135,6 +135,7 @@ message WaitForSelectorCommand {
 
 message ScreenshotCommand {
   optional CommandRetryOptions retry_options = 1;
+  optional bool full_page = 2;
 }
 
 message PageNavigatedEvent {