screenhand 0.2.0 → 0.3.1

package/dist/src/platform/learner.js

@@ -0,0 +1,257 @@
+// Copyright (C) 2025 Clazro Technology Private Limited
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * PlatformLearner — scrape official docs, help center, shortcuts for a platform.
+ *
+ * Crawls documentation pages via CDP, extracts structured data,
+ * and saves as a reference JSON.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { writeFileAtomicSync } from "../util/atomic-write.js";
+/** Common URL patterns for platform documentation */
+export function buildDocUrls(platform, rootUrl) {
+    const base = rootUrl ?? `https://${platform}.com`;
+    const origin = base.replace(/\/$/, "");
+    return [
+        origin,
+        `${origin}/help`,
+        `${origin}/support`,
+        `${origin}/docs`,
+        `${origin}/keyboard-shortcuts`,
+        `${origin}/shortcuts`,
+        `https://help.${platform}.com`,
+        `https://support.${platform}.com`,
+        `https://docs.${platform}.com`,
+        `${origin}/developers`,
+        `${origin}/api`,
+        `${origin}/changelog`,
+        `${origin}/whats-new`,
+    ];
+}
+/** Extract keyboard shortcuts from a page */
+export async function extractShortcuts(cdpEvaluate) {
+    const result = await cdpEvaluate(`(() => {
+    const shortcuts = {};
+    // Look for common shortcut table patterns
+    const tables = document.querySelectorAll('table');
+    for (const table of tables) {
+      const rows = table.querySelectorAll('tr');
+      for (const row of rows) {
+        const cells = row.querySelectorAll('td, th');
+        if (cells.length >= 2) {
+          const text0 = (cells[0].textContent || '').trim();
+          const text1 = (cells[1].textContent || '').trim();
+          // Check if either cell contains key combos
+          if (text0.match(/[⌘⌥⇧⌃]|ctrl|cmd|alt|shift/i) || text1.match(/[⌘⌥⇧⌃]|ctrl|cmd|alt|shift/i)) {
+            shortcuts[text0] = text1;
+          }
+        }
+      }
+    }
+    // Also check kbd elements
+    const kbds = document.querySelectorAll('kbd');
+    for (const kbd of kbds) {
+      const parent = kbd.closest('li, tr, p, div');
+      if (parent) {
+        const keyText = kbd.textContent.trim();
+        const descText = parent.textContent.replace(keyText, '').trim().substring(0, 80);
+        if (keyText && descText) shortcuts[keyText] = descText;
+      }
+    }
+    return shortcuts;
+  })()`);
+    return result.result?.value ?? {};
+}
+/** Extract page content as structured text */
+export async function extractPageContent(cdpEvaluate) {
+    const result = await cdpEvaluate(`(() => {
+    const headings = Array.from(document.querySelectorAll('h1, h2, h3')).map(h => h.textContent.trim()).filter(Boolean);
+    const links = Array.from(document.querySelectorAll('a[href]')).slice(0, 100).map(a => ({
+      text: (a.textContent || '').trim().substring(0, 80),
+      href: a.href,
+    })).filter(l => l.text && l.href);
+    return {
+      title: document.title,
+      headings,
+      links,
+      text: document.body.innerText.substring(0, 8000),
+    };
+  })()`);
+    return result.result?.value ?? { title: "", headings: [], links: [], text: "" };
+}
+/** Extract interactive element selectors from a page */
+export async function extractSelectors(cdpEvaluate) {
+    const result = await cdpEvaluate(`(() => {
+    const selectors = {};
+    const elements = document.querySelectorAll('[data-testid], [aria-label], [role="button"], [role="tab"], [role="menuitem"]');
+    for (const el of Array.from(elements).slice(0, 50)) {
+      const testId = el.getAttribute('data-testid');
+      const label = el.getAttribute('aria-label');
+      const key = testId || label || el.textContent?.trim().substring(0, 30) || '';
+      if (!key) continue;
+
+      let selector = '';
+      if (testId) selector = '[data-testid="' + testId + '"]';
+      else if (el.id) selector = '#' + el.id;
+      else if (label) selector = '[aria-label="' + label + '"]';
+
+      if (selector) selectors[key] = selector;
+    }
+    return selectors;
+  })()`);
+    return result.result?.value ?? {};
+}
+/** Crawl a page via CDP: navigate, wait, extract */
+export async function crawlPage(cdpClient, url, timeoutMs = 10000) {
+    try {
+        // Navigate
+        await cdpClient.Page.navigate({ url });
+        // Wait for load
+        await new Promise((resolve) => {
+            const timer = setTimeout(resolve, timeoutMs);
+            cdpClient.Page.loadEventFired().then(() => { clearTimeout(timer); resolve(); }).catch(() => { clearTimeout(timer); resolve(); });
+        });
+        // Extra wait for SPA content
+        await new Promise(r => setTimeout(r, 2000));
+        const evaluate = async (expr) => {
+            return cdpClient.Runtime.evaluate({ expression: expr, returnByValue: true, awaitPromise: true });
+        };
+        const content = await extractPageContent(evaluate);
+        const shortcuts = await extractShortcuts(evaluate);
+        const selectors = await extractSelectors(evaluate);
+        return { success: true, content, shortcuts, selectors };
+    }
+    catch (err) {
+        return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+/** Compile crawl results into a learn result */
+export function compileLearnResult(platform, crawledPages) {
+    const allShortcuts = {};
+    const allSelectors = {};
+    const features = [];
+    const tips = [];
+    const sourceUrls = [];
+    const flows = {};
+    const apiEndpoints = [];
+    const knownLimitations = [];
+    for (const page of crawledPages) {
+        sourceUrls.push(page.url);
+        if (page.shortcuts) {
+            Object.assign(allShortcuts, page.shortcuts);
+        }
+        if (page.selectors && Object.keys(page.selectors).length > 0) {
+            const pageName = page.content?.title?.replace(/[^a-zA-Z0-9]/g, "_").substring(0, 30) ?? "page";
+            allSelectors[pageName] = page.selectors;
+        }
+        if (page.content) {
+            // Extract features from headings
+            for (const h of page.content.headings) {
+                if (h.length > 3 && h.length < 80)
+                    features.push(h);
+            }
+            // Look for API-related links
+            for (const link of page.content.links) {
+                if (/api|developer|endpoint|sdk|integration/i.test(link.text)) {
+                    apiEndpoints.push(`${link.text}: ${link.href}`);
+                }
+            }
+            // Extract flows from numbered step sequences (e.g. "1. Click..." "2. Enter..." "3. Submit...")
+            const contentLines = page.content.text.split("\n");
+            let currentFlow = null;
+            for (let i = 0; i < contentLines.length; i++) {
+                const line = contentLines[i].trim();
+                const stepMatch = line.match(/^(\d+)[.)]\s+(.+)/);
+                if (stepMatch) {
+                    const stepNum = parseInt(stepMatch[1], 10);
+                    const stepText = stepMatch[2].trim();
+                    if (stepNum === 1 && stepText.length > 5) {
+                        // Start a new flow — use the preceding heading as the name
+                        const heading = i > 0 ? contentLines.slice(Math.max(0, i - 3), i).find(l => l.trim().length > 3 && !l.trim().match(/^\d/)) : null;
+                        const flowName = (heading?.trim() ?? `flow_${Object.keys(flows).length + 1}`).replace(/[^a-zA-Z0-9_ ]/g, "").substring(0, 50).trim();
+                        currentFlow = { name: flowName, steps: [stepText] };
+                    }
+                    else if (currentFlow && stepNum > 1) {
+                        currentFlow.steps.push(stepText);
+                    }
+                }
+                else if (currentFlow && currentFlow.steps.length >= 2) {
+                    // End of step sequence — save the flow
+                    const key = currentFlow.name.toLowerCase().replace(/\s+/g, "_");
+                    if (!flows[key]) {
+                        flows[key] = { description: currentFlow.name, steps: currentFlow.steps };
+                    }
+                    currentFlow = null;
+                }
+                else if (line.length > 0 && !line.match(/^\d/)) {
+                    currentFlow = null;
+                }
+            }
+            // Save any trailing flow
+            if (currentFlow && currentFlow.steps.length >= 2) {
+                const key = currentFlow.name.toLowerCase().replace(/\s+/g, "_");
+                if (!flows[key]) {
+                    flows[key] = { description: currentFlow.name, steps: currentFlow.steps };
+                }
+            }
+            // Look for limitation/known-issue mentions
+            const text = page.content.text.toLowerCase();
+            if (text.includes("limitation") || text.includes("known issue") || text.includes("not supported")) {
+                const lines = page.content.text.split("\n");
+                for (const line of lines) {
+                    if (/limitation|known issue|not supported|doesn't support|won't work/i.test(line)) {
+                        knownLimitations.push(line.trim().substring(0, 200));
+                    }
+                }
+            }
+        }
+    }
+    return {
+        platform,
+        learnedAt: new Date().toISOString(),
+        sourceUrls,
+        shortcuts: allShortcuts,
+        features: [...new Set(features)].slice(0, 50),
+        selectors: allSelectors,
+        flows,
+        apiEndpoints: [...new Set(apiEndpoints)].slice(0, 20),
+        knownLimitations: [...new Set(knownLimitations)].slice(0, 20),
+        tips,
+    };
+}
+/** Save learn result as a reference JSON */
+export function saveLearnResult(referencesDir, result) {
+    if (!fs.existsSync(referencesDir)) {
+        fs.mkdirSync(referencesDir, { recursive: true });
+    }
+    const filePath = path.join(referencesDir, `${result.platform}-learned.json`);
+    const reference = {
+        id: `${result.platform}-learned`,
+        name: `${result.platform} — Auto-Learned from Docs`,
+        description: `Scraped ${result.sourceUrls.length} documentation pages. Found ${Object.keys(result.shortcuts).length} shortcuts, ${result.features.length} features.`,
+        platform: result.platform,
+        bundleId: result.bundleId ?? null,
+        version: "1.0.0",
+        tags: [result.platform, "auto-learned"],
+        successCount: 0,
+        failCount: 0,
+        urls: Object.fromEntries(result.sourceUrls.map((u, i) => [`doc_${i}`, u])),
+        selectors: result.selectors,
+        shortcuts: result.shortcuts,
+        flows: result.flows,
+        detection: {},
+        errors: [],
+        policyNotes: {},
+        _meta: {
+            learnedAt: result.learnedAt,
+            sourceUrls: result.sourceUrls,
+            features: result.features,
+            apiEndpoints: result.apiEndpoints,
+            knownLimitations: result.knownLimitations,
+            tips: result.tips,
+        },
+    };
+    writeFileAtomicSync(filePath, JSON.stringify(reference, null, 2));
+    return filePath;
+}

package/dist/src/playbook/engine.js

@@ -14,13 +14,25 @@
 //
 // You should have received a copy of the GNU Affero General Public License
 // along with ScreenHand. If not, see <https://www.gnu.org/licenses/>.
+import { readObserverState, getObserverPopup } from "../observer/state.js";
 const DEFAULT_VERIFY_TIMEOUT = 5000;
 const STEP_DELAY_MS = 300;
 export class PlaybookEngine {
     runtime;
+    cdpConnect;
+    /** Enable observer-based popup checks before each step */
+    popupCheckEnabled = false;
     constructor(runtime) {
         this.runtime = runtime;
     }
+    /** Enable/disable pre-step popup detection via observer daemon */
+    setPopupCheck(enabled) {
+        this.popupCheckEnabled = enabled;
+    }
+    /** Set CDP connection factory for browser_js and cdp_key_event actions. Factory accepts optional port override. */
+    setCDPConnect(factory) {
+        this.cdpConnect = factory;
+    }
     /**
      * Execute a playbook against a live session.
      * Returns result with success/failure and which step broke.
@@ -29,9 +41,20 @@ export class PlaybookEngine {
         const start = Date.now();
         let stepsCompleted = 0;
         for (let i = 0; i < playbook.steps.length; i++) {
-            const step = playbook.steps[i];
+            let step = options.vars ? this.substituteVars(playbook.steps[i], options.vars) : playbook.steps[i];
             try {
-                const result = await this.executeStep(sessionId, step);
+                // Pre-step: check for popups via observer (if enabled, non-blocking)
+                if (this.popupCheckEnabled) {
+                    await this.dismissPopupIfPresent(sessionId);
+                }
+                // OCR-based locate: resolve locateByOcr to coordinates before execution
+                if (step.locateByOcr) {
+                    const coords = this.resolveOcrTarget(step.locateByOcr, step.offsetX ?? 0, step.offsetY ?? 0);
+                    if (coords) {
+                        step = { ...step, target: { x: coords.x, y: coords.y } };
+                    }
+                }
+                const result = await this.executeStep(sessionId, step, playbook.cdpPort);
                 stepsCompleted++;
                 if (options.onStep) {
                     options.onStep(i, step, result);
@@ -85,7 +108,7 @@ export class PlaybookEngine {
     /**
      * Execute a single playbook step.
      */
-    async executeStep(sessionId, step) {
+    async executeStep(sessionId, step, cdpPort) {
         const target = this.resolveTarget(step.target);
         switch (step.action) {
             case "navigate": {
@@ -105,14 +128,21 @@ export class PlaybookEngine {
                 return `Pressed ${JSON.stringify(step.target)}`;
             }
             case "type_into": {
-                if (!target)
-                    throw new Error("type_into step missing target");
                 if (!step.text)
                     throw new Error("type_into step missing text");
-                const r = await this.runtime.typeInto({ sessionId, target, text: step.text });
-                if (!r.ok)
-                    throw new Error(r.error.message);
-                return `Typed "${step.text}" into ${JSON.stringify(step.target)}`;
+                if (target) {
+                    const r = await this.runtime.typeInto({ sessionId, target, text: step.text });
+                    if (!r.ok)
+                        throw new Error(r.error.message);
+                    return `Typed "${step.text}" into ${JSON.stringify(step.target)}`;
+                }
+                // No target — type into focused element character by character via key events
+                for (const char of step.text) {
+                    const r = await this.runtime.keyCombo({ sessionId, keys: [char] });
+                    if (!r.ok)
+                        throw new Error(r.error?.message ?? "key event failed");
+                }
+                return `Typed "${step.text}" into focused element`;
             }
             case "extract": {
                 if (!target)
@@ -126,13 +156,22 @@ export class PlaybookEngine {
                     throw new Error(r.error.message);
                 return `Extracted: ${JSON.stringify(r.data).slice(0, 200)}`;
             }
+            case "key":
             case "key_combo": {
                 if (!step.keys || step.keys.length === 0)
-                    throw new Error("key_combo step missing keys");
+                    throw new Error(`${step.action} step missing keys`);
                 const r = await this.runtime.keyCombo({ sessionId, keys: step.keys });
                 if (!r.ok)
                     throw new Error(r.error.message);
-                return `Key combo: ${step.keys.join("+")}`;
+                return `${step.action === "key" ? "Key" : "Key combo"}: ${step.keys.join("+")}`;
+            }
+            case "menu_click": {
+                if (!step.menuPath || step.menuPath.length === 0)
+                    throw new Error("menu_click step missing menuPath");
+                const r = await this.runtime.menuClick({ sessionId, menuPath: step.menuPath });
+                if (!r.ok)
+                    throw new Error(r.error.message);
+                return `Menu click: ${step.menuPath.join(" > ")}`;
             }
             case "scroll": {
                 const input = {
@@ -156,10 +195,115 @@ export class PlaybookEngine {
                     throw new Error(r.error.message);
                 return `Screenshot taken`;
             }
+            case "browser_js": {
+                if (!step.code)
+                    throw new Error("browser_js step missing code");
+                if (!this.cdpConnect)
+                    throw new Error("browser_js requires CDP — call setCDPConnect() first");
+                const client = await this.cdpConnect(cdpPort);
+                try {
+                    const result = await client.Runtime.evaluate({
+                        expression: step.code,
+                        awaitPromise: true,
+                        returnByValue: true,
+                    });
+                    if (result.exceptionDetails) {
+                        throw new Error(`JS Error: ${result.exceptionDetails.text ?? result.exceptionDetails.exception?.description ?? "unknown"}`);
+                    }
+                    const val = result.result?.value;
+                    return `browser_js: ${typeof val === "object" ? JSON.stringify(val) : String(val ?? "undefined")}`;
+                }
+                finally {
+                    await client.close();
+                }
+            }
+            case "browser_click":
+            case "browser_human_click": {
+                const selector = this.getBrowserSelector(step);
+                if (!this.cdpConnect)
+                    throw new Error(`${step.action} requires CDP — call setCDPConnect() first`);
+                const client = await this.cdpConnect(cdpPort);
+                try {
+                    const point = await this.resolveBrowserClickPoint(client, selector);
+                    await this.dispatchMouseClick(client, point.x, point.y);
+                    return `${step.action}: clicked ${selector}`;
+                }
+                finally {
+                    await client.close();
+                }
+            }
+            case "browser_type": {
+                const selector = this.getBrowserSelector(step);
+                if (!step.text)
+                    throw new Error("browser_type step missing text");
+                if (!this.cdpConnect)
+                    throw new Error("browser_type requires CDP — call setCDPConnect() first");
+                const client = await this.cdpConnect(cdpPort);
+                try {
+                    await this.focusBrowserElement(client, selector);
+                    const shouldClear = step.text !== undefined;
+                    if (shouldClear) {
+                        await this.dispatchSelectAll(client);
+                        await this.dispatchKey(client, "Backspace", "Backspace");
+                        await sleep(50);
+                    }
+                    for (const char of step.text) {
+                        await this.dispatchTextChar(client, char);
+                        await sleep(50);
+                    }
+                    return `browser_type: typed ${step.text.length} chars into ${selector}`;
+                }
+                finally {
+                    await client.close();
+                }
+            }
+            case "cdp_key_event": {
+                if (!step.keyEvent)
+                    throw new Error("cdp_key_event step missing keyEvent");
+                if (!this.cdpConnect)
+                    throw new Error("cdp_key_event requires CDP — call setCDPConnect() first");
+                const client = await this.cdpConnect(cdpPort);
+                try {
+                    const { key, code, modifiers, windowsVirtualKeyCode } = step.keyEvent;
+                    const baseParams = { key, code, modifiers: modifiers ?? 0, windowsVirtualKeyCode: windowsVirtualKeyCode ?? 0, nativeVirtualKeyCode: windowsVirtualKeyCode ?? 0 };
+                    await client.Input.dispatchKeyEvent({ type: "keyDown", ...baseParams });
+                    await client.Input.dispatchKeyEvent({ type: "keyUp", ...baseParams });
+                    return `cdp_key_event: ${modifiers ? `mod${modifiers}+` : ""}${key}`;
+                }
+                finally {
+                    await client.close();
+                }
+            }
             default:
                 throw new Error(`Unknown action: ${step.action}`);
         }
     }
+    /**
+     * Substitute {VAR_NAME} placeholders in step string fields with actual values.
+     */
+    substituteVars(step, vars) {
+        const sub = (s) => {
+            let result = s;
+            for (const [key, val] of Object.entries(vars)) {
+                result = result.replaceAll(`{${key}}`, val);
+            }
+            return result;
+        };
+        const result = { ...step };
+        if (result.code)
+            result.code = sub(result.code);
+        if (result.text)
+            result.text = sub(result.text);
+        if (result.url)
+            result.url = sub(result.url);
+        if (result.description)
+            result.description = sub(result.description);
+        if (result.verify)
+            result.verify = sub(result.verify);
+        if (result.menuPath)
+            result.menuPath = result.menuPath.map(sub);
+        return result;
+    }
     /**
      * Verify a step's postcondition via CSS selector check.
      */
@@ -174,6 +318,85 @@ export class PlaybookEngine {
         });
         return r.ok && r.data.matched;
     }
+    /**
+     * Dismiss a popup detected by the observer daemon.
+     * Reads observer state, if popup found, sends the appropriate dismiss action.
+     * Non-fatal — if observer isn't running or no popup, silently returns.
+     */
+    async dismissPopupIfPresent(sessionId) {
+        let popup;
+        try {
+            popup = getObserverPopup();
+        }
+        catch {
+            return; // Observer not running or state unreadable
+        }
+        if (!popup)
+            return;
+        try {
+            switch (popup.dismissAction) {
+                case "press_escape":
+                    await this.runtime.keyCombo({ sessionId, keys: ["escape"] });
+                    break;
+                case "click_ok":
+                case "click_cancel":
+                case "click_close":
+                case "click_allow":
+                case "click_deny": {
+                    // Map action to button text
+                    const buttonMap = {
+                        click_ok: "OK",
+                        click_cancel: "Cancel",
+                        click_close: "Close",
+                        click_allow: "Allow",
+                        click_deny: "Don't Allow",
+                    };
+                    const buttonText = buttonMap[popup.dismissAction] ?? "OK";
+                    // Try to click the button by text
+                    await this.runtime.press({ sessionId, target: { type: "text", value: buttonText } });
+                    break;
+                }
+                case "unknown":
+                    break; // Don't auto-dismiss unknown popups
+            }
+            // Wait briefly for popup to close
+            await sleep(500);
+        }
+        catch {
+            // Popup dismiss failed — non-fatal, continue with step
+        }
+    }
+    /**
+     * Resolve an OCR text target to screen coordinates using observer state.
+     * Returns center coordinates of the matched text + offsets, or null if not found.
+     */
+    resolveOcrTarget(searchText, offsetX, offsetY) {
+        let state;
+        try {
+            state = readObserverState();
+        }
+        catch {
+            return null;
+        }
+        if (!state?.running || !state.lastFrame?.ocrText)
+            return null;
+        // Simple text search in OCR output
+        // The native OCR (vision.ocr) returns bounding boxes when available.
+        // For now we use a fallback: if the observer has the text, we know
+        // the element is visible. The caller should provide approximate
+        // coordinates via offsetX/offsetY relative to a known anchor.
+        const ocrText = state.lastFrame.ocrText;
+        if (!ocrText.toLowerCase().includes(searchText.toLowerCase())) {
+            return null; // Text not found on screen
+        }
+        // Text found — return offset coordinates (caller provides absolute offsets
+        // or relative to screen center as a basic heuristic)
+        if (offsetX !== 0 || offsetY !== 0) {
+            return { x: offsetX, y: offsetY };
+        }
+        // No explicit coordinates — can't determine position from plain OCR text alone
+        return null;
+    }
     /**
      * Convert playbook target format to runtime Target format.
      */
@@ -195,6 +418,68 @@ export class PlaybookEngine {
         }
         return undefined;
     }
+    getBrowserSelector(step) {
+        if (typeof step.target === "string")
+            return step.target;
+        if (step.target && "selector" in step.target)
+            return step.target.selector;
+        if (step.verify)
+            return step.verify;
+        throw new Error(`${step.action} step missing selector target`);
+    }
+    async focusBrowserElement(client, selector) {
+        const result = await client.Runtime.evaluate({
+            expression: `(() => {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (!(el instanceof HTMLElement)) return { ok: false, reason: "Element not found: ${selector.replace(/"/g, '\\"')}" };
+        el.scrollIntoView({ block: "center" });
+        el.focus();
+        return { ok: true };
+      })()`,
+            returnByValue: true,
+        });
+        const value = result.result?.value;
+        if (!value?.ok) {
+            throw new Error(value?.reason || `Element not found: ${selector}`);
+        }
+    }
+    async resolveBrowserClickPoint(client, selector) {
+        const result = await client.Runtime.evaluate({
+            expression: `(() => {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (!(el instanceof HTMLElement)) return { ok: false, reason: "Element not found: ${selector.replace(/"/g, '\\"')}" };
+        el.scrollIntoView({ block: "center" });
+        const r = el.getBoundingClientRect();
+        return { ok: true, x: r.x + r.width / 2, y: r.y + r.height / 2 };
+      })()`,
+            returnByValue: true,
+        });
+        const value = result.result?.value;
+        if (!value?.ok) {
+            throw new Error(value?.reason || `Element not found: ${selector}`);
+        }
+        return { x: value.x, y: value.y };
+    }
+    async dispatchMouseClick(client, x, y) {
+        await client.Input.dispatchMouseEvent({ type: "mouseMoved", x, y });
+        await sleep(40);
+        await client.Input.dispatchMouseEvent({ type: "mousePressed", x, y, button: "left", clickCount: 1 });
+        await sleep(40);
+        await client.Input.dispatchMouseEvent({ type: "mouseReleased", x, y, button: "left", clickCount: 1 });
+    }
+    async dispatchSelectAll(client) {
+        const metaModifier = process.platform === "darwin" ? 4 : 2;
+        await client.Input.dispatchKeyEvent({ type: "keyDown", key: "a", code: "KeyA", modifiers: metaModifier });
+        await client.Input.dispatchKeyEvent({ type: "keyUp", key: "a", code: "KeyA", modifiers: metaModifier });
+    }
+    async dispatchKey(client, key, code) {
+        await client.Input.dispatchKeyEvent({ type: "keyDown", key, code });
+        await client.Input.dispatchKeyEvent({ type: "keyUp", key, code });
+    }
+    async dispatchTextChar(client, char) {
+        await client.Input.dispatchKeyEvent({ type: "keyDown", text: char, key: char, unmodifiedText: char });
+        await client.Input.dispatchKeyEvent({ type: "keyUp", text: char, key: char, unmodifiedText: char });
+    }
 }
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));