@ddwang/magnitude-core 0.3.1-ddwang.2 → 0.3.1-ddwang.21

package/dist/web/tabs.js

@@ -1,293 +0,0 @@
-// Keeps track of current tab, enables describing open tabs, and switching between open tabs
-import logger from "@/logger";
-import EventEmitter from "eventemitter3";
-import { retryOnErrorIsSuccess } from "@/common";
-export class TabManager {
-    context;
-    activePage;
-    options;
-    pollInterval;
-    events;
-    constructor(context, options = {}) {
-        this.context = context;
-        this.options = {
-            switchOnActivity: true,
-            ...options
-        };
-        this.events = new EventEmitter();
-        // Track new pages
-        this.context.on('page', this.onPageCreated.bind(this));
-    }
-    async initialize() {
-        // Initialize existing pages and tracking
-        await this.initializeExistingPages();
-    }
-    async initializeExistingPages() {
-        const pages = this.context.pages();
-        logger.debug(`initializeExistingPages: found ${pages.length} existing pages`);
-        // Set up existing pages
-        for (const page of pages) {
-            logger.debug(`Setting up page: ${page.url()}`);
-            await this.onPageCreated(page);
-        }
-        // Start polling for activity if enabled
-        if (this.options.switchOnActivity) {
-            logger.debug('Starting activity polling');
-            this.startActivityPolling();
-        }
-    }
-    async onPageCreated(page) {
-        logger.debug(`onPageCreated called for: ${page.url()}`);
-        // If this is the only page or no active page set, make it active
-        if (!this.activePage || this.context.pages().length === 1) {
-            this.setActivePage(page);
-        }
-        // Only set up tracking if switchOnActivity is enabled
-        if (this.options.switchOnActivity) {
-            // Set up activity tracking immediately
-            await this.setupPageTracking(page);
-            // Re-inject tracking after navigation
-            page.on('load', async () => {
-                await this.setupPageTracking(page);
-                // If this is the active page and it navigated from about:blank, re-emit tabChanged
-                if (this.activePage === page && page.url() !== 'about:blank') {
-                    logger.debug(`Re-emitting tabChanged after navigation to: ${page.url()}`);
-                    this.events.emit('tabChanged', page);
-                }
-            });
-            // Also inject on DOMContentLoaded for faster setup
-            page.on('domcontentloaded', async () => {
-                await this.setupPageTracking(page);
-            });
-        }
-        // Don't automatically switch to new tabs - let the user decide
-        // This prevents unwanted switches when links open in new tabs
-        // Clean up when page closes
-        page.on('close', () => {
-            if (this.activePage === page) {
-                const pages = this.context.pages();
-                if (pages.length > 0) {
-                    this.setActivePage(pages[0]);
-                }
-            }
-        });
-        // Start polling if this is the first page and switchOnActivity is enabled
-        if (this.context.pages().length === 1 && this.options.switchOnActivity && !this.pollInterval) {
-            logger.debug('Starting activity polling from onPageCreated (first page)');
-            this.startActivityPolling();
-        }
-    }
-    async setupPageTracking(page) {
-        // Inject the tracking script with retries
-        await retryOnErrorIsSuccess(async () => {
-            const currentUrl = page.url();
-            logger.debug(`Setting up tracking for: ${currentUrl}`);
-            // Inject activity tracking
-            await page.evaluate(() => {
-                // Initialize activity tracking storage
-                if (!window.__tabActivityTime) {
-                    window.__tabActivityTime = 0;
-                }
-                // Set initial activity time to NOW since we're setting up tracking
-                // This ensures the initial page is considered active
-                window.__tabActivityTime = Date.now();
-                // Track any user interaction
-                const recordActivity = () => {
-                    window.__tabActivityTime = Date.now();
-                };
-                // Remove any existing listeners to avoid duplicates
-                const listeners = window.__tabListeners;
-                if (listeners) {
-                    listeners.forEach((l) => {
-                        document.removeEventListener(l.event, l.handler, true);
-                        window.removeEventListener(l.event, l.handler, true);
-                    });
-                }
-                // Store references to our listeners
-                const newListeners = [];
-                // Helper to add tracked event listener
-                const addTrackedListener = (target, event, handler) => {
-                    target.addEventListener(event, handler, true);
-                    newListeners.push({ event, handler });
-                };
-                // Throttled mouse move handler
-                let lastMouseMoveTime = 0;
-                const throttledMouseMove = () => {
-                    const now = Date.now();
-                    if (now - lastMouseMoveTime > 500) {
-                        lastMouseMoveTime = now;
-                        recordActivity();
-                    }
-                };
-                // Mouse events
-                addTrackedListener(document, 'mousedown', recordActivity);
-                addTrackedListener(document, 'click', recordActivity);
-                addTrackedListener(document, 'mousemove', throttledMouseMove);
-                addTrackedListener(document, 'mouseenter', recordActivity);
-                // Keyboard events
-                addTrackedListener(document, 'keydown', recordActivity);
-                // Focus events
-                addTrackedListener(window, 'focus', recordActivity);
-                // Scroll events
-                let lastScrollTime = 0;
-                const throttledScroll = () => {
-                    const now = Date.now();
-                    if (now - lastScrollTime > 500) {
-                        lastScrollTime = now;
-                        recordActivity();
-                    }
-                };
-                addTrackedListener(document, 'scroll', throttledScroll);
-                // Visibility change
-                addTrackedListener(document, 'visibilitychange', () => {
-                    if (!document.hidden) {
-                        recordActivity();
-                    }
-                });
-                // Store listeners for cleanup
-                window.__tabListeners = newListeners;
-            });
-        }, { mode: 'retry_all', delayMs: 200, retryLimit: 5 });
-    }
-    startActivityPolling() {
-        // Poll for activity every 200ms
-        this.pollInterval = setInterval(async () => {
-            const pages = this.context.pages();
-            let mostRecentPage = null;
-            let mostRecentTime = 0;
-            // Find the page with the most recent activity
-            for (const page of pages) {
-                if (page.isClosed())
-                    continue;
-                try {
-                    const lastActivity = await page.evaluate(() => {
-                        // Initialize if it doesn't exist (defensive programming)
-                        if (typeof window.__tabActivityTime === 'undefined') {
-                            window.__tabActivityTime = 0;
-                            // If tracking wasn't set up, return -1 as a signal
-                            if (!window.__tabListeners) {
-                                return -1;
-                            }
-                        }
-                        return window.__tabActivityTime;
-                    });
-                    // If tracking isn't set up (-1), inject it now
-                    if (lastActivity === -1) {
-                        logger.debug(`Tracking not set up for ${page.url()}, injecting now...`);
-                        await this.setupPageTracking(page);
-                        continue; // Skip this page for this polling cycle
-                    }
-                    if (lastActivity > mostRecentTime) {
-                        mostRecentTime = lastActivity;
-                        mostRecentPage = page;
-                    }
-                }
-                catch (e) {
-                    // Page might be navigating
-                }
-            }
-            // Switch to the most recently active page if it's different and activity is recent
-            if (mostRecentPage &&
-                mostRecentPage !== this.activePage &&
-                mostRecentTime > Date.now() - 1000) { // Activity within last second
-                logger.trace(`Activity detected on ${mostRecentPage.url()}, switching...`);
-                this.setActivePage(mostRecentPage);
-            }
-        }, 200);
-    }
-    setActivePage(page) {
-        const isInitialPage = !this.activePage;
-        if (this.activePage === page && !isInitialPage) {
-            return;
-        }
-        logger.debug(`Active tab changed to: ${page.url()}`);
-        this.activePage = page;
-        this.events.emit('tabChanged', page);
-        page.removeAllListeners('framenavigated');
-        page.on('framenavigated', async (frame) => {
-            if (frame === page.mainFrame()) {
-                // const url = frame.url();
-                // await logNavigation(url);
-            }
-        });
-    }
-    async switchTab(index) {
-        const pages = this.context.pages();
-        if (index < 0 || index >= pages.length) {
-            throw new Error(`Invalid tab index: ${index}`);
-        }
-        const page = pages[index];
-        logger.debug(`Switching to tab ${index} (${page.url()})`);
-        await page.bringToFront();
-        this.setActivePage(page);
-    }
-    getActivePage() {
-        return this.activePage;
-    }
-    getPages() {
-        return this.context.pages();
-    }
-    async retrieveState() {
-        let activeIndex = -1;
-        let tabs = [];
-        for (const [i, page] of this.context.pages().entries()) {
-            if (page === this.activePage) {
-                activeIndex = i;
-            }
-            let title;
-            try {
-                title = await page.title();
-            }
-            catch {
-                logger.warn('Could not load page title while retrieving tab state');
-                title = '(could not load title)';
-            }
-            const url = page.url();
-            tabs.push({ title, url });
-        }
-        return {
-            activeTab: activeIndex,
-            tabs: tabs
-        };
-    }
-    async debugVisibilityStates() {
-        const states = await Promise.all(this.context.pages().map(async (page, i) => {
-            try {
-                const hasFocus = await page.evaluate(() => ({
-                    hasFocus: document.hasFocus(),
-                    hidden: document.hidden,
-                    visibilityState: document.visibilityState
-                }));
-                return { index: i, url: page.url(), ...hasFocus };
-            }
-            catch {
-                return { index: i, url: page.url(), error: true };
-            }
-        }));
-        return states;
-    }
-    async debugFocusStates() {
-        const states = await Promise.all(this.context.pages().map(async (page, i) => {
-            try {
-                const state = await page.evaluate(() => ({
-                    hasFocus: document.hasFocus(),
-                    isVisible: document.visibilityState === 'visible',
-                    isHidden: document.hidden,
-                    url: window.location.href
-                }));
-                return { index: i, ...state };
-            }
-            catch {
-                return { index: i, url: page.url(), error: true };
-            }
-        }));
-        console.log('Focus states:', states);
-        return states;
-    }
-    // Clean up
-    destroy() {
-        if (this.pollInterval) {
-            clearInterval(this.pollInterval);
-        }
-    }
-}

package/dist/web/transformer.d.ts

@@ -1,7 +0,0 @@
-import type { Page } from 'playwright';
-export declare class DOMTransformer {
-    private initializedPages;
-    constructor();
-    setActivePage(newPage: Page): void;
-    setupScriptForPage(targetPage: Page): Promise<void>;
-}

package/dist/web/transformer.js

@@ -1,41 +0,0 @@
-import getShadowDOMInputAdapterScript from './scripts/shadowDOMInputAdapter';
-import logger from '@/logger';
-export class DOMTransformer {
-    initializedPages = new WeakSet(); // Track pages for which 'load' listener is set
-    constructor() { }
-    setActivePage(newPage) {
-        // Only add the 'load' listener if we haven't done so for this specific Page object instance.
-        if (!this.initializedPages.has(newPage)) {
-            newPage.on('load', async () => {
-                // Pass 'newPage' (the page that triggered the 'load' event) to setupScriptForPage.
-                await this.setupScriptForPage(newPage);
-            });
-            this.initializedPages.add(newPage); // Mark this Page object as having its 'load' listener set up.
-        }
-    }
-    async setupScriptForPage(targetPage) {
-        try {
-            // Check if a marker for the script already exists on the page for this load cycle.
-            const scriptAlreadyInjected = await targetPage.evaluate(() => {
-                return window.__magnitudeShadowDOMAdapterInjected === true;
-            }).catch(() => false); // If evaluate fails (e.g., page closed), assume not injected.
-            if (scriptAlreadyInjected) {
-                logger.trace('Select manager script already present on this page load.');
-                return;
-            }
-            // Get the script as a string from the separate file
-            const scriptFnString = getShadowDOMInputAdapterScript();
-            // Evaluate the script function in the browser and set the marker.
-            // We need to wrap it in a self-executing function
-            await targetPage.evaluate(`
-                (${scriptFnString})();
-                window.__magnitudeShadowDOMAdapterInjected = true;
-            `);
-            logger.trace(`Script injected into page: ${targetPage.url()}`);
-        }
-        catch (error) {
-            const url = targetPage.isClosed() ? '[closed page]' : targetPage.url();
-            logger.warn(`Error injecting script into ${url}: ${error.message}`);
-        }
-    }
-}

package/dist/web/types.d.ts

@@ -1,37 +0,0 @@
-export type Base64Image = `data:image/${'jpeg' | 'png' | 'gif'};base64,${string}`;
-export type WebAction = NavigateWebAction | ClickWebAction | HoverWebAction | TypeWebAction | ScrollWebAction | SwitchTabWebAction;
-export interface NavigateWebAction {
-    variant: 'load';
-    url: string;
-}
-export interface ClickWebAction {
-    variant: 'click';
-    x: number;
-    y: number;
-}
-export interface HoverWebAction {
-    variant: 'hover';
-    x: number;
-    y: number;
-}
-export interface TypeWebAction {
-    variant: 'type';
-    x: number;
-    y: number;
-    content: string;
-}
-export interface ScrollWebAction {
-    variant: 'scroll';
-    x: number;
-    y: number;
-    deltaX: number;
-    deltaY: number;
-}
-export type SwitchTabWebAction = {
-    variant: 'tab';
-    index: number;
-};
-export interface PixelCoordinate {
-    x: number;
-    y: number;
-}

package/dist/web/types.js

@@ -1,2 +0,0 @@
-export {};
-// for back-compat, not all implemented yet

package/dist/web/util.d.ts

@@ -1,3 +0,0 @@
-export type KeypressIndicator = '<enter>' | '<tab>';
-export declare function parseTypeContent(content: string): (string | KeypressIndicator)[];
-export declare function renderMinimalAccessibilityTree(node: any): string;

package/dist/web/util.js

@@ -1,81 +0,0 @@
-export function parseTypeContent(content) {
-    // Parse content sequence potentially with special indicators <enter> or <tab> into components
-    const regex = /<enter>|<tab>/g;
-    const result = [];
-    let lastIndex = 0;
-    content.replace(regex, (match, offset) => {
-        // Grab the text before the match and trim surrounding whitespace
-        const text = content.slice(lastIndex, offset).trim();
-        if (text)
-            result.push(text);
-        // Add the matched special indicator
-        result.push(match);
-        lastIndex = offset + match.length;
-        return match;
-    });
-    // Add any remaining text after the last match
-    const remaining = content.slice(lastIndex).trim();
-    if (remaining)
-        result.push(remaining);
-    return result;
-}
-export function renderMinimalAccessibilityTree(node) {
-    // Escapes newlines for safe inline printing, and trims whitespace.
-    const sanitize = (text) => {
-        return String(text).trim().replace(/\n/g, '\\n');
-    };
-    // Inner recursive function to handle state like indentation
-    function recursiveFlatten(node, indent) {
-        const isTextLike = (n) => n && (n.role === 'StaticText' || n.role === 'text') && n.name && n.name.trim();
-        let childrenOutput = '';
-        if (node.children) {
-            const newChildren = [];
-            let currentTextBuffer = [];
-            for (const child of node.children) {
-                if (isTextLike(child)) {
-                    currentTextBuffer.push(sanitize(child.name));
-                }
-                else {
-                    if (currentTextBuffer.length > 0) {
-                        newChildren.push({ role: 'coalesced-text', name: currentTextBuffer.join(' ') });
-                        currentTextBuffer = [];
-                    }
-                    newChildren.push(child);
-                }
-            }
-            if (currentTextBuffer.length > 0) {
-                newChildren.push({ role: 'coalesced-text', name: currentTextBuffer.join(' ') });
-            }
-            for (const child of newChildren) {
-                if (child.role === 'coalesced-text') {
-                    childrenOutput += `${indent}  ${child.name}\n`;
-                }
-                else {
-                    childrenOutput += recursiveFlatten(child, indent + '  ');
-                }
-            }
-        }
-        const isBoringContainer = (node.role === 'generic' || node.role === 'div') && !node.name;
-        if (isBoringContainer) {
-            return childrenOutput;
-        }
-        let line = '';
-        if (node.role && !['StaticText', 'text', 'RootWebArea'].includes(node.role)) {
-            line = `${indent}[${node.role}]`;
-            if (node.name && sanitize(node.name)) {
-                line += ` ${sanitize(node.name)}`;
-            }
-            if (node.value !== undefined && sanitize(node.value)) {
-                line += ` (value: ${sanitize(node.value)})`;
-            }
-            if (node.checked !== undefined)
-                line += ` (checked: ${node.checked})`;
-            if (node.disabled)
-                line += ` (disabled)`;
-            line += '\n';
-        }
-        return line + childrenOutput;
-    }
-    const rawFlattened = recursiveFlatten(node, '');
-    return rawFlattened.split('\n').filter(line => line.trim() !== '').join('\n');
-}

package/dist/web/visualizer/cursor.d.ts

@@ -1,16 +0,0 @@
-import { Page } from "playwright";
-export declare class CursorVisual {
-    /**
-     * Manages the visual indicator for actions on a page
-     */
-    private page;
-    private visualElementId;
-    private lastPosition;
-    constructor();
-    setActivePage(page: Page): Promise<void>;
-    move(x: number, y: number): Promise<void>;
-    setupOnPage(): Promise<void>;
-    private _drawVisual;
-    hide(): Promise<void>;
-    show(): Promise<void>;
-}

package/dist/web/visualizer/cursor.js

@@ -1,153 +0,0 @@
-import { retryOnErrorIsSuccess } from "@/common";
-import logger from "@/logger";
-import { operationSleep } from '@/common/operation';
-export class CursorVisual {
-    /**
-     * Manages the visual indicator for actions on a page
-     */
-    page;
-    visualElementId = 'action-visual-indicator';
-    lastPosition = null;
-    constructor() {
-        //this.page = page;
-    }
-    async setActivePage(page) {
-        this.page = page;
-        page.on('load', async () => {
-            await retryOnErrorIsSuccess(this.setupOnPage.bind(this), { mode: 'retry_all', delayMs: 200, retryLimit: 10 });
-        });
-        await retryOnErrorIsSuccess(this.setupOnPage.bind(this), { mode: 'retry_all', delayMs: 200, retryLimit: 5 });
-    }
-    async move(x, y) {
-        // Store the position
-        this.lastPosition = { x, y };
-        // Create or update the mouse pointer visual, showing the click effect
-        await this._drawVisual(x, y, false);
-        // The pointer visual takes 0.3s on the transition, but awaiting script evaluation does not wait for this to complete.
-        // So we wait 300ms manually.
-        await operationSleep(300);
-    }
-    async setupOnPage() {
-        if (this.lastPosition) {
-            // Redraw the visual without the click effect
-            await this._drawVisual(this.lastPosition.x, this.lastPosition.y, false);
-        }
-    }
-    // Internal method to handle the actual drawing logic
-    async _drawVisual(x, y, showClickEffect) {
-        try {
-            await this.page.evaluate(({ x, y, id, showClickEffect }) => {
-                // Use viewport coordinates directly (no scroll adjustment for fixed positioning)
-                const viewportX = x;
-                const viewportY = y;
-                // Document coordinates for the click effect circle (which uses absolute positioning)
-                const docX = x + window.scrollX;
-                const docY = y + window.scrollY;
-                // --- Create Expanding/Fading Circle (Optional) ---
-                if (showClickEffect) {
-                    const circle = document.createElement('div');
-                    circle.style.position = 'absolute';
-                    circle.style.left = `${docX}px`;
-                    circle.style.top = `${docY}px`;
-                    circle.style.borderRadius = '50%';
-                    circle.style.backgroundColor = '#026aa1'; // Blue color
-                    circle.style.width = '0px';
-                    circle.style.height = '0px';
-                    circle.style.transform = 'translate(-50%, -50%)'; // Center on (x, y)
-                    circle.style.pointerEvents = 'none';
-                    circle.style.zIndex = '9998'; // Below the pointer
-                    circle.style.opacity = '0.7'; // Initial opacity
-                    document.body.appendChild(circle);
-                    // Animate the circle
-                    const animation = circle.animate([
-                        { width: '0px', height: '0px', opacity: 0.7 }, // Start state
-                        { width: '50px', height: '50px', opacity: 0 } // End state
-                    ], {
-                        duration: 500, // 500ms duration
-                        easing: 'ease-out'
-                    });
-                    // Remove circle after animation
-                    animation.onfinish = () => {
-                        circle.remove();
-                    };
-                }
-                // --- Pointer Logic (Always runs) ---
-                // Check if the visual indicator already exists
-                let pointerElement = document.getElementById(id);
-                // If it doesn't exist, create it with all necessary styling
-                if (!pointerElement) {
-                    pointerElement = document.createElement('div');
-                    pointerElement.id = id;
-                    pointerElement.style.position = 'fixed'; // Use fixed positioning for viewport-relative
-                    pointerElement.style.width = '32px';
-                    pointerElement.style.height = '32px';
-                    pointerElement.style.zIndex = '2147483647'; // Max z-index
-                    pointerElement.style.pointerEvents = 'none'; // Don't interfere with actual clicks
-                    // Notice that transition is 300ms
-                    pointerElement.style.transition = 'left 0.3s cubic-bezier(0.25, 0.1, 0.25, 1), top 0.3s cubic-bezier(0.25, 0.1, 0.25, 1)';
-                    // Create SVG using DOM methods to avoid Trusted Types issues
-                    const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-                    svg.setAttribute('width', '32');
-                    svg.setAttribute('height', '32');
-                    svg.setAttribute('viewBox', '0 0 113.50408 99.837555');
-                    const g = document.createElementNS('http://www.w3.org/2000/svg', 'g');
-                    g.setAttribute('transform', 'translate(-413.10686,-501.19661)');
-                    const path1 = document.createElementNS('http://www.w3.org/2000/svg', 'path');
-                    path1.setAttribute('style', 'fill:#026aa1;fill-opacity:1;stroke:#000000;stroke-width:0');
-                    path1.setAttribute('d', 'm 416.1069,504.1966 52.47697,93.83813 8.33253,-57.61019 z');
-                    const path2 = document.createElementNS('http://www.w3.org/2000/svg', 'path');
-                    path2.setAttribute('style', 'fill:#0384c7;fill-opacity:1;stroke:#000000;stroke-width:0');
-                    path2.setAttribute('d', 'm 416.1069,504.1966 60.8095,36.22794 46.69517,-34.75524 z');
-                    const path3 = document.createElementNS('http://www.w3.org/2000/svg', 'path');
-                    path3.setAttribute('style', 'fill:#0384c7;fill-opacity:0;stroke:#000000;stroke-width:6;stroke-linecap:round;stroke-linejoin:round');
-                    path3.setAttribute('d', 'm 416.1069,504.19658 52.47698,93.83813 8.33252,-57.61019 46.69517,-34.75521 -107.50467,-1.47273');
-                    g.appendChild(path1);
-                    g.appendChild(path2);
-                    g.appendChild(path3);
-                    svg.appendChild(g);
-                    pointerElement.appendChild(svg);
-                    document.body.appendChild(pointerElement);
-                }
-                //pointerElement.style.display = 'none';
-                // Update position - use viewport coordinates for fixed positioning
-                // Set the top-left corner to (viewportX, viewportY) and then translate by (-1px, -3px)
-                // to align the pointer tip (approx. at 1.27, 4.17 within the SVG) with the click point.
-                pointerElement.style.left = `${viewportX}px`;
-                pointerElement.style.top = `${viewportY}px`;
-                pointerElement.style.transform = 'translate(-1px, -3px)';
-            }, { x, y, id: this.visualElementId, showClickEffect });
-        }
-        catch (error) {
-            // For example when:
-            // TypeError: Failed to set the 'innerHTML' property on 'Element': This document requires 'TrustedHTML' assignment.
-            logger.trace(`Failed to draw visual: ${error.message}`);
-        }
-    }
-    async hide() {
-        try {
-            await this.page.evaluate((id) => {
-                const element = document.getElementById(id);
-                if (element) {
-                    element.style.display = 'none';
-                }
-            }, this.visualElementId);
-        }
-        catch {
-            logger.trace(`Failed to hide pointer`);
-        }
-    }
-    async show() {
-        try {
-            await this.page.evaluate((id) => {
-                const element = document.getElementById(id);
-                if (element) {
-                    // Revert to the default display value (usually 'block' for a div)
-                    element.style.display = '';
-                }
-            }, this.visualElementId);
-        }
-        catch {
-            logger.trace(`Failed to show pointer`);
-        }
-    }
-}

package/dist/web/visualizer/index.d.ts

@@ -1,22 +0,0 @@
-import { BrowserContext, Page } from "playwright";
-export interface ActionVisualizerOptions {
-    showCursor?: boolean;
-    showHoverCircle?: boolean;
-    showClickRipple?: boolean;
-    showDragLine?: boolean;
-    showTypeEffects?: boolean;
-}
-export declare class ActionVisualizer {
-    private options;
-    private context;
-    private page;
-    private cursor;
-    private mouseEffects;
-    private typeEffects;
-    constructor(context: BrowserContext, options: ActionVisualizerOptions);
-    setup(): Promise<void>;
-    setActivePage(page: Page): Promise<void>;
-    moveVirtualCursor(x: number, y: number): Promise<void>;
-    hideAll(): Promise<void>;
-    showAll(): Promise<void>;
-}