monomind 1.10.30 → 1.10.31

package/packages/@monomind/cli/dist/src/browser/console-log.js

@@ -0,0 +1,55 @@
+let consoleMessages = [];
+let pageErrors = [];
+export function setupConsoleCapture(client, sessionId) {
+    client.on('Runtime.consoleAPICalled', (params, sid) => {
+        if (sid !== sessionId)
+            return;
+        const args = params.args ?? [];
+        const text = args.map((a) => a.description ?? String(a.value ?? '')).join(' ');
+        consoleMessages.push({
+            type: params.type ?? 'log',
+            text,
+            timestamp: Date.now(),
+        });
+    });
+    client.on('Log.entryAdded', (params, sid) => {
+        if (sid !== sessionId)
+            return;
+        const entry = params.entry;
+        consoleMessages.push({
+            type: entry.level ?? 'log',
+            text: entry.text ?? '',
+            timestamp: Date.now(),
+            url: entry.url,
+            lineNumber: entry.lineNumber,
+        });
+    });
+    client.on('Runtime.exceptionThrown', (params, sid) => {
+        if (sid !== sessionId)
+            return;
+        const detail = params.exceptionDetails;
+        pageErrors.push({
+            text: detail.text ?? 'Unknown error',
+            url: detail.url,
+            lineNumber: detail.lineNumber,
+            columnNumber: detail.columnNumber,
+            timestamp: Date.now(),
+        });
+    });
+}
+export async function enableConsoleCapture(client, sessionId) {
+    await client.send('Log.enable', {}, sessionId);
+}
+export function getConsoleMessages() {
+    return [...consoleMessages];
+}
+export function clearConsoleMessages() {
+    consoleMessages = [];
+}
+export function getPageErrors() {
+    return [...pageErrors];
+}
+export function clearPageErrors() {
+    pageErrors = [];
+}
+//# sourceMappingURL=console-log.js.map

package/packages/@monomind/cli/dist/src/browser/dialog.d.ts

@@ -0,0 +1,11 @@
+import type { CdpClient } from './cdp.js';
+export interface DialogInfo {
+    type: 'alert' | 'confirm' | 'prompt' | 'beforeunload';
+    message: string;
+    defaultPrompt?: string;
+}
+export declare function setupDialogAutoHandling(client: CdpClient, sessionId: string, autoAccept?: boolean): void;
+export declare function acceptDialog(client: CdpClient, sessionId: string, text?: string): Promise<void>;
+export declare function dismissDialog(client: CdpClient, sessionId: string): Promise<void>;
+export declare function getDialogStatus(): DialogInfo | null;
+//# sourceMappingURL=dialog.d.ts.map

package/packages/@monomind/cli/dist/src/browser/dialog.js

@@ -0,0 +1,36 @@
+let pendingDialog = null;
+export function setupDialogAutoHandling(client, sessionId, autoAccept = true) {
+    client.on('Page.javascriptDialogOpening', async (params, sid) => {
+        if (sid !== sessionId)
+            return;
+        const info = {
+            type: params.type,
+            message: params.message,
+            defaultPrompt: params.defaultPrompt,
+        };
+        pendingDialog = info;
+        if (autoAccept && (info.type === 'alert' || info.type === 'beforeunload')) {
+            await client.send('Page.handleJavaScriptDialog', { accept: true }, sessionId);
+            pendingDialog = null;
+        }
+    });
+    client.on('Page.javascriptDialogClosed', (_, sid) => {
+        if (sid === sessionId)
+            pendingDialog = null;
+    });
+}
+export async function acceptDialog(client, sessionId, text) {
+    await client.send('Page.handleJavaScriptDialog', {
+        accept: true,
+        promptText: text,
+    }, sessionId);
+    pendingDialog = null;
+}
+export async function dismissDialog(client, sessionId) {
+    await client.send('Page.handleJavaScriptDialog', { accept: false }, sessionId);
+    pendingDialog = null;
+}
+export function getDialogStatus() {
+    return pendingDialog;
+}
+//# sourceMappingURL=dialog.js.map

package/packages/@monomind/cli/dist/src/browser/emulation.d.ts

@@ -0,0 +1,15 @@
+import type { CdpClient } from './cdp.js';
+export interface DeviceProfile {
+    width: number;
+    height: number;
+    deviceScaleFactor: number;
+    mobile: boolean;
+    userAgent: string;
+}
+export declare function emulateDevice(client: CdpClient, sessionId: string, deviceName: string): Promise<void>;
+export declare function setGeolocation(client: CdpClient, sessionId: string, latitude: number, longitude: number, accuracy?: number): Promise<void>;
+export declare function setOfflineMode(client: CdpClient, sessionId: string, offline: boolean): Promise<void>;
+export declare function setColorScheme(client: CdpClient, sessionId: string, scheme: 'dark' | 'light' | 'no-preference'): Promise<void>;
+export declare function setBasicAuth(client: CdpClient, sessionId: string, username: string, password: string): Promise<void>;
+export declare function listDevices(): string[];
+//# sourceMappingURL=emulation.d.ts.map

package/packages/@monomind/cli/dist/src/browser/emulation.js

@@ -0,0 +1,62 @@
+const DEVICES = {
+    'iPhone 14': {
+        width: 390, height: 844, deviceScaleFactor: 3, mobile: true,
+        userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1',
+    },
+    'iPhone SE': {
+        width: 375, height: 667, deviceScaleFactor: 2, mobile: true,
+        userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 15_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.0 Mobile/15E148 Safari/604.1',
+    },
+    'iPad': {
+        width: 768, height: 1024, deviceScaleFactor: 2, mobile: true,
+        userAgent: 'Mozilla/5.0 (iPad; CPU OS 15_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.0 Mobile/15E148 Safari/604.1',
+    },
+    'Galaxy S21': {
+        width: 360, height: 800, deviceScaleFactor: 3, mobile: true,
+        userAgent: 'Mozilla/5.0 (Linux; Android 11; SM-G991B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.101 Mobile Safari/537.36',
+    },
+    'Pixel 5': {
+        width: 393, height: 851, deviceScaleFactor: 2.75, mobile: true,
+        userAgent: 'Mozilla/5.0 (Linux; Android 11; Pixel 5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.101 Mobile Safari/537.36',
+    },
+};
+export async function emulateDevice(client, sessionId, deviceName) {
+    const device = DEVICES[deviceName];
+    if (!device) {
+        throw new Error(`Unknown device: "${deviceName}". Available: ${Object.keys(DEVICES).join(', ')}`);
+    }
+    await client.send('Emulation.setDeviceMetricsOverride', {
+        width: device.width,
+        height: device.height,
+        deviceScaleFactor: device.deviceScaleFactor,
+        mobile: device.mobile,
+    }, sessionId);
+    await client.send('Emulation.setUserAgentOverride', { userAgent: device.userAgent }, sessionId);
+    await client.send('Emulation.setTouchEmulationEnabled', { enabled: device.mobile }, sessionId);
+}
+export async function setGeolocation(client, sessionId, latitude, longitude, accuracy = 100) {
+    await client.send('Emulation.setGeolocationOverride', { latitude, longitude, accuracy }, sessionId);
+}
+export async function setOfflineMode(client, sessionId, offline) {
+    await client.send('Network.emulateNetworkConditions', {
+        offline,
+        latency: 0,
+        downloadThroughput: -1,
+        uploadThroughput: -1,
+    }, sessionId);
+}
+export async function setColorScheme(client, sessionId, scheme) {
+    await client.send('Emulation.setEmulatedMedia', {
+        features: [{ name: 'prefers-color-scheme', value: scheme }],
+    }, sessionId);
+}
+export async function setBasicAuth(client, sessionId, username, password) {
+    const encoded = Buffer.from(`${username}:${password}`).toString('base64');
+    await client.send('Network.setExtraHTTPHeaders', {
+        headers: { Authorization: `Basic ${encoded}` },
+    }, sessionId);
+}
+export function listDevices() {
+    return Object.keys(DEVICES);
+}
+//# sourceMappingURL=emulation.js.map

package/packages/@monomind/cli/dist/src/browser/find.d.ts

@@ -0,0 +1,21 @@
+import type { CdpClient } from './cdp.js';
+import type { ElementRef } from './types.js';
+export type FindAction = 'click' | 'fill' | 'type' | 'hover' | 'focus' | 'check' | 'uncheck' | 'text';
+export interface FindOptions {
+    name?: string;
+    exact?: boolean;
+    nth?: number;
+    first?: boolean;
+    last?: boolean;
+}
+export declare function findBySelector(client: CdpClient, sessionId: string, selector: string, options?: FindOptions): Promise<string | null>;
+export declare function findByRole(client: CdpClient, sessionId: string, refs: Map<string, ElementRef>, role: string, options?: FindOptions): Promise<ElementRef | null>;
+export declare function findByText(client: CdpClient, sessionId: string, refs: Map<string, ElementRef>, text: string, options?: FindOptions): Promise<ElementRef | null>;
+export declare function findByLabel(client: CdpClient, sessionId: string, refs: Map<string, ElementRef>, label: string, options?: FindOptions): Promise<ElementRef | null>;
+export declare function findByTestId(client: CdpClient, sessionId: string, testId: string): Promise<string | null>;
+export declare function isVisible(client: CdpClient, sessionId: string, ref: ElementRef): Promise<boolean>;
+export declare function isEnabled(client: CdpClient, sessionId: string, ref: ElementRef): Promise<boolean>;
+export declare function isChecked(client: CdpClient, sessionId: string, ref: ElementRef): Promise<boolean>;
+export declare function scrollIntoView(client: CdpClient, sessionId: string, ref: ElementRef): Promise<void>;
+export declare function highlightElement(client: CdpClient, sessionId: string, ref: ElementRef): Promise<void>;
+//# sourceMappingURL=find.d.ts.map

package/packages/@monomind/cli/dist/src/browser/find.js

@@ -0,0 +1,118 @@
+import { evaluateJs } from './actions.js';
+import { getObjectIdForRef } from './snapshot.js';
+export async function findBySelector(client, sessionId, selector, options = {}) {
+    let expr;
+    if (options.nth !== undefined) {
+        expr = `document.querySelectorAll(${JSON.stringify(selector)})[${options.nth - 1}]?.outerHTML ?? null`;
+    }
+    else if (options.last) {
+        expr = `Array.from(document.querySelectorAll(${JSON.stringify(selector)})).at(-1)?.outerHTML ?? null`;
+    }
+    else {
+        expr = `document.querySelector(${JSON.stringify(selector)})?.outerHTML ?? null`;
+    }
+    return evaluateJs(client, sessionId, expr);
+}
+export async function findByRole(client, sessionId, refs, role, options = {}) {
+    const lowerRole = role.toLowerCase();
+    const candidates = [...refs.values()].filter((r) => r.role.toLowerCase() === lowerRole);
+    let matches = candidates;
+    if (options.name) {
+        const nameLower = options.name.toLowerCase();
+        matches = options.exact
+            ? candidates.filter((r) => r.name.toLowerCase() === nameLower)
+            : candidates.filter((r) => r.name.toLowerCase().includes(nameLower));
+    }
+    if (matches.length === 0)
+        return null;
+    if (options.nth !== undefined)
+        return matches[options.nth - 1] ?? null;
+    if (options.last)
+        return matches[matches.length - 1];
+    return matches[0];
+}
+export async function findByText(client, sessionId, refs, text, options = {}) {
+    const lower = text.toLowerCase();
+    const candidates = [...refs.values()].filter((r) => options.exact ? r.name.toLowerCase() === lower : r.name.toLowerCase().includes(lower));
+    if (options.nth !== undefined)
+        return candidates[options.nth - 1] ?? null;
+    if (options.last)
+        return candidates[candidates.length - 1];
+    return candidates[0] ?? null;
+}
+export async function findByLabel(client, sessionId, refs, label, options = {}) {
+    return findByText(client, sessionId, refs, label, options);
+}
+export async function findByTestId(client, sessionId, testId) {
+    const selectors = [
+        `[data-testid="${testId}"]`,
+        `[data-test-id="${testId}"]`,
+        `[data-test="${testId}"]`,
+    ];
+    for (const sel of selectors) {
+        const result = await evaluateJs(client, sessionId, `!!document.querySelector(${JSON.stringify(sel)})`);
+        if (result)
+            return sel;
+    }
+    return null;
+}
+export async function isVisible(client, sessionId, ref) {
+    const objectId = await getObjectIdForRef(client, sessionId, ref);
+    if (!objectId)
+        return false;
+    const result = await client.send('Runtime.callFunctionOn', {
+        functionDeclaration: `function() {
+      const rect = this.getBoundingClientRect();
+      const style = window.getComputedStyle(this);
+      return rect.width > 0 && rect.height > 0 &&
+             style.display !== 'none' &&
+             style.visibility !== 'hidden' &&
+             style.opacity !== '0';
+    }`,
+        objectId,
+        returnByValue: true,
+    }, sessionId);
+    return result.result?.value ?? false;
+}
+export async function isEnabled(client, sessionId, ref) {
+    return !ref.disabled;
+}
+export async function isChecked(client, sessionId, ref) {
+    const objectId = await getObjectIdForRef(client, sessionId, ref);
+    if (!objectId)
+        return false;
+    const result = await client.send('Runtime.callFunctionOn', {
+        functionDeclaration: 'function() { return !!this.checked; }',
+        objectId,
+        returnByValue: true,
+    }, sessionId);
+    return result.result?.value ?? false;
+}
+export async function scrollIntoView(client, sessionId, ref) {
+    const objectId = await getObjectIdForRef(client, sessionId, ref);
+    if (!objectId)
+        throw new Error(`Cannot scroll: ref @${ref.ref} not found in DOM`);
+    await client.send('Runtime.callFunctionOn', {
+        functionDeclaration: 'function() { this.scrollIntoView({ behavior: "smooth", block: "center" }); }',
+        objectId,
+    }, sessionId);
+}
+export async function highlightElement(client, sessionId, ref) {
+    const objectId = await getObjectIdForRef(client, sessionId, ref);
+    if (!objectId)
+        return;
+    await client.send('Runtime.callFunctionOn', {
+        functionDeclaration: `function() {
+      const prev = this.style.outline;
+      const prevBg = this.style.backgroundColor;
+      this.style.outline = '3px solid #ff5722';
+      this.style.backgroundColor = 'rgba(255, 87, 34, 0.1)';
+      setTimeout(() => {
+        this.style.outline = prev;
+        this.style.backgroundColor = prevBg;
+      }, 2000);
+    }`,
+        objectId,
+    }, sessionId);
+}
+//# sourceMappingURL=find.js.map

package/packages/@monomind/cli/dist/src/browser/index.d.ts

@@ -8,4 +8,11 @@ export * from './network.js';
 export * from './screenshot.js';
 export * from './session.js';
 export * from './tabs.js';
+export * from './dialog.js';
+export * from './console-log.js';
+export * from './storage.js';
+export * from './find.js';
+export * from './pdf.js';
+export * from './emulation.js';
+export * from './batch.js';
 //# sourceMappingURL=index.d.ts.map

package/packages/@monomind/cli/dist/src/browser/index.js

@@ -8,4 +8,11 @@ export * from './network.js';
 export * from './screenshot.js';
 export * from './session.js';
 export * from './tabs.js';
+export * from './dialog.js';
+export * from './console-log.js';
+export * from './storage.js';
+export * from './find.js';
+export * from './pdf.js';
+export * from './emulation.js';
+export * from './batch.js';
 //# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/browser/pdf.d.ts

@@ -0,0 +1,15 @@
+import type { CdpClient } from './cdp.js';
+export interface PdfOptions {
+    path?: string;
+    landscape?: boolean;
+    paperWidth?: number;
+    paperHeight?: number;
+    marginTop?: number;
+    marginBottom?: number;
+    marginLeft?: number;
+    marginRight?: number;
+    printBackground?: boolean;
+    scale?: number;
+}
+export declare function capturePdf(client: CdpClient, sessionId: string, options?: PdfOptions): Promise<string>;
+//# sourceMappingURL=pdf.d.ts.map

package/packages/@monomind/cli/dist/src/browser/pdf.js

@@ -0,0 +1,27 @@
+import { writeFile } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+export async function capturePdf(client, sessionId, options = {}) {
+    const params = {
+        landscape: options.landscape ?? false,
+        printBackground: options.printBackground ?? true,
+        scale: options.scale ?? 1,
+    };
+    if (options.paperWidth)
+        params.paperWidth = options.paperWidth;
+    if (options.paperHeight)
+        params.paperHeight = options.paperHeight;
+    if (options.marginTop !== undefined)
+        params.marginTop = options.marginTop;
+    if (options.marginBottom !== undefined)
+        params.marginBottom = options.marginBottom;
+    if (options.marginLeft !== undefined)
+        params.marginLeft = options.marginLeft;
+    if (options.marginRight !== undefined)
+        params.marginRight = options.marginRight;
+    const result = await client.send('Page.printToPDF', params, sessionId);
+    const outputPath = options.path ?? join(tmpdir(), `monomind-pdf-${Date.now()}.pdf`);
+    await writeFile(outputPath, Buffer.from(result.data, 'base64'));
+    return outputPath;
+}
+//# sourceMappingURL=pdf.js.map

package/packages/@monomind/cli/dist/src/browser/storage.d.ts

@@ -0,0 +1,11 @@
+import type { CdpClient } from './cdp.js';
+export declare function getLocalStorageKey(client: CdpClient, sessionId: string, key: string): Promise<string | null>;
+export declare function setLocalStorageKey(client: CdpClient, sessionId: string, key: string, value: string): Promise<void>;
+export declare function removeLocalStorageKey(client: CdpClient, sessionId: string, key: string): Promise<void>;
+export declare function clearLocalStorage(client: CdpClient, sessionId: string): Promise<void>;
+export declare function getAllLocalStorage(client: CdpClient, sessionId: string): Promise<Record<string, string>>;
+export declare function getSessionStorageKey(client: CdpClient, sessionId: string, key: string): Promise<string | null>;
+export declare function setSessionStorageKey(client: CdpClient, sessionId: string, key: string, value: string): Promise<void>;
+export declare function clearSessionStorage(client: CdpClient, sessionId: string): Promise<void>;
+export declare function getAllSessionStorage(client: CdpClient, sessionId: string): Promise<Record<string, string>>;
+//# sourceMappingURL=storage.d.ts.map

package/packages/@monomind/cli/dist/src/browser/storage.js

@@ -0,0 +1,43 @@
+import { evaluateJs } from './actions.js';
+export async function getLocalStorageKey(client, sessionId, key) {
+    const result = await evaluateJs(client, sessionId, `localStorage.getItem(${JSON.stringify(key)})`);
+    return result;
+}
+export async function setLocalStorageKey(client, sessionId, key, value) {
+    await evaluateJs(client, sessionId, `localStorage.setItem(${JSON.stringify(key)}, ${JSON.stringify(value)})`);
+}
+export async function removeLocalStorageKey(client, sessionId, key) {
+    await evaluateJs(client, sessionId, `localStorage.removeItem(${JSON.stringify(key)})`);
+}
+export async function clearLocalStorage(client, sessionId) {
+    await evaluateJs(client, sessionId, 'localStorage.clear()');
+}
+export async function getAllLocalStorage(client, sessionId) {
+    const result = await evaluateJs(client, sessionId, 'JSON.stringify(Object.fromEntries(Object.entries(localStorage)))');
+    try {
+        return JSON.parse(result);
+    }
+    catch {
+        return {};
+    }
+}
+export async function getSessionStorageKey(client, sessionId, key) {
+    const result = await evaluateJs(client, sessionId, `sessionStorage.getItem(${JSON.stringify(key)})`);
+    return result;
+}
+export async function setSessionStorageKey(client, sessionId, key, value) {
+    await evaluateJs(client, sessionId, `sessionStorage.setItem(${JSON.stringify(key)}, ${JSON.stringify(value)})`);
+}
+export async function clearSessionStorage(client, sessionId) {
+    await evaluateJs(client, sessionId, 'sessionStorage.clear()');
+}
+export async function getAllSessionStorage(client, sessionId) {
+    const result = await evaluateJs(client, sessionId, 'JSON.stringify(Object.fromEntries(Object.entries(sessionStorage)))');
+    try {
+        return JSON.parse(result);
+    }
+    catch {
+        return {};
+    }
+}
+//# sourceMappingURL=storage.js.map