@probolabs/playwright 0.1.1 → 0.1.3

package/dist/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../src/actions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAS,MAAM,YAAY,CAAC;AAmMzC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;CAcnB,CAAC;AAGX,MAAM,MAAM,oBAAoB,GAAG,OAAO,gBAAgB,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAC;AAE1F,eAAO,MAAM,uBAAuB,SAC5B,IAAI,UACF,oBAAoB,SACrB,MAAM,wBACS,MAAM,qBAiF7B,CAAA"}

package/dist/actions.js

@@ -0,0 +1,241 @@
+import { proboLogger } from './utils';
+// Utility functions for enhanced Playwright interactions
+async function handleNavigation(page, url, navigationTimeout = 5000, totalTimeout = 10000) {
+    let navigationCount = 0;
+    let lastNavigationTime = null;
+    const startTime = Date.now();
+    // Declare the function outside try block so it's accessible in finally
+    const onFrameNavigated = (frame) => {
+        if (frame === page.mainFrame()) {
+            navigationCount++;
+            lastNavigationTime = Date.now();
+            proboLogger.debug(`Navigation ${navigationCount} detected at ${lastNavigationTime}`);
+        }
+    };
+    try {
+        // Setup navigation tracking
+        page.on('framenavigated', onFrameNavigated);
+        await page.goto(url, {
+            waitUntil: 'domcontentloaded',
+            timeout: totalTimeout
+        });
+        // Final wait only for DOM, not network
+        if (navigationCount > 0) {
+            proboLogger.debug(`Total navigations detected: ${navigationCount}`);
+            await page.waitForLoadState('domcontentloaded');
+            // Add scroll to bottom to trigger lazy loading
+            await scrollToBottomRight(page);
+        }
+    }
+    finally {
+        page.removeListener('framenavigated', onFrameNavigated);
+        proboLogger.debug('Navigation listener removed');
+    }
+}
+async function enhancedClick(page, selector, options = {}) {
+    // Track initial scroll position
+    let initScrollY = await page.evaluate(() => window.scrollY);
+    let initScrollX = await page.evaluate(() => window.scrollX);
+    // Perform the click
+    await page.click(selector, { noWaitAfter: false, ...options });
+    // Monitor for any scrolling that might occur due to the click
+    let scrollingDetected = false;
+    while (true) {
+        const currScrollX = await page.evaluate(() => window.scrollX);
+        const currScrollY = await page.evaluate(() => window.scrollY);
+        if (currScrollY !== initScrollY || currScrollX !== initScrollX) {
+            proboLogger.debug('Click detected scrolling, waiting 50ms for stabilization...');
+            scrollingDetected = true;
+            await page.waitForTimeout(50);
+            initScrollX = currScrollX;
+            initScrollY = currScrollY;
+        }
+        else {
+            break;
+        }
+    }
+    // If scrolling occurred, reset to top
+    if (scrollingDetected) {
+        await page.evaluate(() => window.scrollTo(0, 0));
+        await page.waitForTimeout(50); // Small delay between scrolls
+    }
+}
+async function selectDropdownOption(page, selector, value) {
+    // Get the element's tag name
+    const locator = page.locator(selector);
+    const tagName = await locator.evaluate(el => el.tagName.toLowerCase());
+    if (tagName === 'select') {
+        // Handle native select element
+        proboLogger.debug('selectDropdownOption: simple select tag');
+        await page.selectOption(selector, value);
+    }
+    else { // not a native select
+        try {
+            // Look for child <select> if exists
+            const listboxSelector = locator.locator('select');
+            const count = await listboxSelector.count();
+            if (count === 1) { // delegate to child <select>
+                proboLogger.debug('Identified child element with tag select');
+                await listboxSelector.selectOption(value);
+            }
+            else {
+                // Click the original locator to expose the real listbox and options
+                proboLogger.debug('Clicking container element, looking for child element with role listbox');
+                await locator.click();
+                const listbox = locator.getByRole('listbox');
+                proboLogger.debug(`Clicking option ${value}`);
+                // Handle both string and array values
+                const values = Array.isArray(value) ? value : [value];
+                for (const val of values) {
+                    const optionSelector = listbox
+                        .getByRole('option')
+                        .getByText(new RegExp(`^${val.toLowerCase()}$`, 'i'));
+                    const optionCount = await optionSelector.count();
+                    if (optionCount !== 1) {
+                        throw new Error(`Found ${optionCount} option selectors for value: ${val}`);
+                    }
+                    await optionSelector.click();
+                }
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to select option '${value}' from custom dropdown: ${error}`);
+        }
+    }
+}
+async function getElementValue(page, selector) {
+    // TODO: Implement getting all text contents
+    proboLogger.log("TODO: Implement getting all text contents");
+    return "TODO: Implement getting all text contents";
+}
+async function waitForMutationsToSettle(page) {
+    // TODO: Implement mutation observer
+    //proboLogger.log("TODO: Implement mutation observer");
+    await page.waitForTimeout(500);
+}
+async function scrollToBottomRight(page) {
+    proboLogger.debug("Scrolling to bottom of page...");
+    // Get initial page dimensions
+    let lastHeight = await page.evaluate(() => document.documentElement.scrollHeight);
+    let lastWidth = await page.evaluate(() => document.documentElement.scrollWidth);
+    while (true) {
+        let smoothingSteps = 0;
+        // Get current scroll positions and dimensions
+        const initScrollY = await page.evaluate(() => window.scrollY);
+        const initScrollX = await page.evaluate(() => window.scrollX);
+        const maxScrollY = await page.evaluate(() => document.documentElement.scrollHeight);
+        const maxScrollX = await page.evaluate(() => document.documentElement.scrollWidth);
+        const maxClientY = await page.evaluate(() => document.documentElement.clientHeight);
+        const maxClientX = await page.evaluate(() => document.documentElement.clientWidth);
+        // Scroll both horizontally and vertically in steps
+        let currScrollX = initScrollX;
+        while (currScrollX <= (maxScrollX - maxClientX)) {
+            let currScrollY = initScrollY;
+            while (currScrollY <= (maxScrollY - maxClientY)) {
+                currScrollY += maxClientY;
+                await page.evaluate(({ x, y }) => window.scrollTo(x, y), { x: currScrollX, y: currScrollY });
+                await page.waitForTimeout(50); // Small delay between scrolls
+                smoothingSteps++;
+            }
+            currScrollX += maxClientX;
+        }
+        proboLogger.debug(`Performed ${smoothingSteps} smoothing steps while scrolling`);
+        // Check if content was lazy loaded (dimensions changed)
+        const newHeight = await page.evaluate(() => document.documentElement.scrollHeight);
+        const newWidth = await page.evaluate(() => document.documentElement.scrollWidth);
+        if (newHeight === lastHeight && newWidth === lastWidth) {
+            break;
+        }
+        proboLogger.debug("Page dimensions updated, repeating smoothing steps with new dimensions");
+        lastHeight = newHeight;
+        lastWidth = newWidth;
+    }
+    // Reset scroll position to top left
+    await page.waitForTimeout(200);
+    await page.evaluate(() => window.scrollTo(0, 0));
+    await page.waitForTimeout(50);
+}
+export const PlaywrightAction = {
+    VISIT_BASE_URL: 'VISIT_BASE_URL',
+    VISIT_URL: 'VISIT_URL',
+    CLICK: 'CLICK',
+    FILL_IN: 'FILL_IN',
+    SELECT_DROPDOWN: 'SELECT_DROPDOWN',
+    SELECT_MULTIPLE_DROPDOWN: 'SELECT_MULTIPLE_DROPDOWN',
+    CHECK_CHECKBOX: 'CHECK_CHECKBOX',
+    SELECT_RADIO: 'SELECT_RADIO',
+    TOGGLE_SWITCH: 'TOGGLE_SWITCH',
+    PRESS_KEY: 'PRESS_KEY',
+    VALIDATE_EXACT_VALUE: 'VALIDATE_EXACT_VALUE',
+    VALIDATE_CONTAINS_VALUE: 'VALIDATE_CONTAINS_VALUE',
+    VALIDATE_URL: 'VALIDATE_URL'
+};
+export const executePlaywrightAction = async (page, action, value, element_css_selector) => {
+    proboLogger.info('Executing playwright action:', { action, value, element_css_selector });
+    try {
+        switch (action) {
+            case PlaywrightAction.VISIT_BASE_URL:
+            case PlaywrightAction.VISIT_URL:
+                await handleNavigation(page, value);
+                break;
+            case PlaywrightAction.CLICK:
+                await enhancedClick(page, element_css_selector);
+                break;
+            case PlaywrightAction.FILL_IN:
+                await enhancedClick(page, element_css_selector);
+                await page.fill(element_css_selector, value);
+                break;
+            case PlaywrightAction.SELECT_DROPDOWN:
+                await selectDropdownOption(page, element_css_selector, value);
+                break;
+            case PlaywrightAction.SELECT_MULTIPLE_DROPDOWN:
+                const options = value.split(',').map(opt => opt.trim());
+                await selectDropdownOption(page, element_css_selector, options);
+                break;
+            case PlaywrightAction.CHECK_CHECKBOX:
+                const checked = value.toLowerCase() === 'true';
+                await page.setChecked(element_css_selector, checked);
+                break;
+            case PlaywrightAction.SELECT_RADIO:
+            case PlaywrightAction.TOGGLE_SWITCH:
+                await enhancedClick(page, element_css_selector);
+                break;
+            case PlaywrightAction.PRESS_KEY:
+                await page.press(element_css_selector, value);
+                break;
+            case PlaywrightAction.VALIDATE_EXACT_VALUE:
+                const exactValue = await getElementValue(page, element_css_selector);
+                if (exactValue !== value) {
+                    proboLogger.info(`Validation FAIL: expected ${value} but got ${exactValue}`);
+                    return false;
+                }
+                proboLogger.info('Validation PASS');
+                return true;
+            case PlaywrightAction.VALIDATE_CONTAINS_VALUE:
+                const containsValue = await getElementValue(page, element_css_selector);
+                if (!containsValue.includes(value)) {
+                    proboLogger.info(`Validation FAIL: expected ${value} to be contained in ${containsValue}`);
+                    return false;
+                }
+                proboLogger.info('Validation PASS');
+                return true;
+            case PlaywrightAction.VALIDATE_URL:
+                const currentUrl = page.url();
+                if (currentUrl !== value) {
+                    proboLogger.info(`Validation FAIL: expected url ${value} but got ${currentUrl}`);
+                    return false;
+                }
+                proboLogger.info('Validation PASS');
+                return true;
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+        // Wait for mutations to settle after any action
+        await waitForMutationsToSettle(page);
+        return true;
+    }
+    catch (error) {
+        proboLogger.error(`Failed to execute action ${action}:`, error);
+        throw error;
+    }
+};

package/dist/api-client.d.ts

@@ -0,0 +1,34 @@
+export interface Instruction {
+    what_to_do: string;
+    args: any;
+    result: any;
+}
+export interface CreateStepOptions {
+    stepIdFromServer: number;
+    stepPrompt: string;
+    initial_screenshot_url: string;
+    initial_html_content: string;
+    scenarioName: string;
+    use_cache: boolean;
+}
+export declare class ApiError extends Error {
+    status: number;
+    data?: any | undefined;
+    constructor(status: number, message: string, data?: any | undefined);
+    toString(): string;
+}
+export declare class ApiClient {
+    private apiUrl;
+    private token;
+    private maxRetries;
+    private initialBackoff;
+    constructor(apiUrl: string, token?: string, // Default to demo token
+    maxRetries?: number, initialBackoff?: number);
+    private handleResponse;
+    private getHeaders;
+    private withRetry;
+    createStep(options: CreateStepOptions): Promise<string>;
+    resolveNextInstruction(stepId: string, instruction: Instruction | null): Promise<any>;
+    uploadScreenshot(screenshot_bytes: Buffer): Promise<string>;
+}
+//# sourceMappingURL=api-client.d.ts.map

package/dist/api-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-client.d.ts","sourceRoot":"","sources":["../src/api-client.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,GAAG,CAAC;IACV,MAAM,EAAE,GAAG,CAAC;CACb;AAED,MAAM,WAAW,iBAAiB;IAChC,gBAAgB,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,MAAM,CAAA;IAClB,sBAAsB,EAAE,MAAM,CAAA;IAC9B,oBAAoB,EAAE,MAAM,CAAA;IAC5B,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,qBAAa,QAAS,SAAQ,KAAK;IAExB,MAAM,EAAE,MAAM;IAEd,IAAI,CAAC,EAAE,GAAG;gBAFV,MAAM,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,EACR,IAAI,CAAC,EAAE,GAAG,YAAA;IASnB,QAAQ;CAGT;AAED,qBAAa,SAAS;IAElB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,cAAc;gBAHd,MAAM,EAAE,MAAM,EACd,KAAK,GAAE,MAAmD,EAAG,wBAAwB;IACrF,UAAU,GAAE,MAAU,EACtB,cAAc,GAAE,MAAa;YAGzB,cAAc;IA+B5B,OAAO,CAAC,UAAU;YAWJ,SAAS;IAyBjB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC;IAoBvD,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,GAAG,IAAI;IAatE,gBAAgB,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAclE"}

package/dist/api-client.js

@@ -0,0 +1,125 @@
+export class ApiError extends Error {
+    constructor(status, message, data) {
+        super(message);
+        this.status = status;
+        this.data = data;
+        this.name = 'ApiError';
+        // Remove stack trace for cleaner error messages
+        this.stack = undefined;
+    }
+    toString() {
+        return `${this.message} (Status: ${this.status})`;
+    }
+}
+export class ApiClient {
+    constructor(apiUrl, token = 'b31793f81a1f58b8a153c86a5fdf4df0e5179c51', // Default to demo token
+    maxRetries = 3, initialBackoff = 1000) {
+        this.apiUrl = apiUrl;
+        this.token = token;
+        this.maxRetries = maxRetries;
+        this.initialBackoff = initialBackoff;
+    }
+    async handleResponse(response) {
+        var _a;
+        try {
+            const data = await response.json();
+            if (!response.ok) {
+                switch (response.status) {
+                    case 401:
+                        throw new ApiError(401, 'Unauthorized - Invalid or missing authentication token');
+                    case 403:
+                        throw new ApiError(403, 'Forbidden - You do not have permission to perform this action');
+                    case 400:
+                        throw new ApiError(400, 'Bad Request', data);
+                    case 404:
+                        throw new ApiError(404, 'Not Found', data);
+                    case 500:
+                        throw new ApiError(500, 'Internal Server Error', data);
+                    default:
+                        throw new ApiError(response.status, `API Error: ${data.error || 'Unknown error'}`, data);
+                }
+            }
+            return data;
+        }
+        catch (error) {
+            // Only throw the original error if it's not a network error
+            if (!((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes('fetch failed'))) {
+                throw error;
+            }
+            throw new ApiError(0, 'Network error: fetch failed');
+        }
+    }
+    getHeaders() {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        // Always include token in headers now that we have a default
+        headers['Authorization'] = `Token ${this.token}`;
+        return headers;
+    }
+    async withRetry(operation) {
+        var _a;
+        for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                // Only retry on network errors
+                if (!((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes('Network error: fetch failed'))) {
+                    throw error;
+                }
+                // On last attempt, throw the error
+                if (attempt === this.maxRetries) {
+                    throw error;
+                }
+                // Otherwise, wait and retry
+                console.log(`[probolib-LOG] Network error, retrying (${attempt}/${this.maxRetries}). Waiting ${this.initialBackoff * Math.pow(2, attempt - 1)}ms...`);
+                await new Promise(resolve => setTimeout(resolve, this.initialBackoff * Math.pow(2, attempt - 1)));
+            }
+        }
+        // TypeScript needs this, but it will never be reached
+        throw new Error('Unreachable');
+    }
+    async createStep(options) {
+        return this.withRetry(async () => {
+            const response = await fetch(`${this.apiUrl}/step-runners/`, {
+                method: 'POST',
+                headers: this.getHeaders(),
+                body: JSON.stringify({
+                    step_id: options.stepIdFromServer,
+                    scenario_name: options.scenarioName,
+                    step_prompt: options.stepPrompt,
+                    initial_screenshot: options.initial_screenshot_url,
+                    initial_html_content: options.initial_html_content,
+                    use_cache: options.use_cache,
+                }),
+            });
+            const data = await this.handleResponse(response);
+            return data.step.id;
+        });
+    }
+    async resolveNextInstruction(stepId, instruction) {
+        return this.withRetry(async () => {
+            const response = await fetch(`${this.apiUrl}/step-runners/${stepId}/run/`, {
+                method: 'POST',
+                headers: this.getHeaders(),
+                body: JSON.stringify({ executed_instruction: instruction }),
+            });
+            const data = await this.handleResponse(response);
+            return data.instruction;
+        });
+    }
+    async uploadScreenshot(screenshot_bytes) {
+        return this.withRetry(async () => {
+            const response = await fetch(`${this.apiUrl}/upload-screenshots/`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Token ${this.token}`
+                },
+                body: screenshot_bytes,
+            });
+            const data = await this.handleResponse(response);
+            return data.screenshot_url;
+        });
+    }
+}

package/dist/highlight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"highlight.d.ts","sourceRoot":"","sources":["../src/highlight.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,sCAAsC,CAAC;AAIlE,KAAK,cAAc,GAAG,OAAO,UAAU,CAAC,MAAM,OAAO,UAAU,CAAC,CAAC;AAGjE,OAAO,CAAC,MAAM,CAAC;IAEb,IAAI,eAAe,EAAE,MAAM,CAAC;IAE5B,UAAU,MAAM;QACd,SAAS,CAAC,EAAE;YACV,SAAS,EAAE;gBACT,OAAO,EAAE,CAAC,YAAY,EAAE,cAAc,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;gBAC1D,SAAS,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;aAC/B,CAAC;YACF,iBAAiB,EAAE,CAAC,QAAQ,EAAE,KAAK,CAAC;gBAAE,YAAY,EAAE,MAAM,CAAC;gBAAC,KAAK,EAAE,MAAM,CAAA;aAAE,CAAC,KAAK,IAAI,CAAC;YACtF,UAAU,EAAE,OAAO,UAAU,CAAC;SAC/B,CAAC;KACH;CACF;AAED,qBAAa,WAAW;IACV,OAAO,CAAC,iBAAiB;gBAAjB,iBAAiB,GAAE,OAAc;YAEvC,uBAAuB;IA6BxB,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,cAAc;IAsBxD,mBAAmB,CAAC,IAAI,EAAE,IAAI;IAQ9B,gBAAgB,CAAC,IAAI,EAAE,IAAI,EAAE,oBAAoB,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM;CA0B9F;AAED,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC"}

package/dist/highlight.js

@@ -0,0 +1,79 @@
+import { ElementTag } from '@probolabs/highlighter/src/constants';
+import { proboLogger } from './utils';
+export class Highlighter {
+    constructor(enableConsoleLogs = true) {
+        this.enableConsoleLogs = enableConsoleLogs;
+    }
+    async ensureHighlighterScript(page, maxRetries = 3) {
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                const scriptExists = await page.evaluate(`typeof window.ProboLabs?.highlight?.execute === 'function'`);
+                if (!scriptExists) {
+                    proboLogger.debug('Injecting highlighter script...');
+                    await page.evaluate(highlighterCode);
+                    // Verify the script was injected correctly
+                    const verified = await page.evaluate(`
+            //console.log('ProboLabs global:', window.ProboLabs);
+            typeof window.ProboLabs?.highlight?.execute === 'function'
+          `);
+                    proboLogger.debug('Script injection verified:', verified);
+                }
+                return; // Success - exit the function
+            }
+            catch (error) {
+                if (attempt === maxRetries - 1) {
+                    throw error;
+                }
+                proboLogger.debug(`Script injection attempt ${attempt + 1} failed, retrying after delay...`);
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+        }
+    }
+    async highlightElements(page, elementTag) {
+        proboLogger.debug('highlightElements called with:', elementTag);
+        await this.ensureHighlighterScript(page);
+        // Execute the highlight function and await its result
+        const result = await page.evaluate(async (tag) => {
+            var _a, _b;
+            //proboLogger.debug('Browser: Starting highlight execution with tag:', tag);
+            if (!((_b = (_a = window.ProboLabs) === null || _a === void 0 ? void 0 : _a.highlight) === null || _b === void 0 ? void 0 : _b.execute)) {
+                console.error('Browser: ProboLabs.highlight.execute is not available!');
+                return null;
+            }
+            const elements = await window.ProboLabs.highlight.execute([tag]);
+            //proboLogger.debug('Browser: Found elements:', elements);
+            return elements;
+        }, elementTag);
+        return result;
+    }
+    async unhighlightElements(page) {
+        proboLogger.debug('unhighlightElements called');
+        await this.ensureHighlighterScript(page);
+        await page.evaluate(() => {
+            var _a, _b;
+            (_b = (_a = window === null || window === void 0 ? void 0 : window.ProboLabs) === null || _a === void 0 ? void 0 : _a.highlight) === null || _b === void 0 ? void 0 : _b.unexecute();
+        });
+    }
+    async highlightElement(page, element_css_selector, element_index) {
+        await this.ensureHighlighterScript(page);
+        proboLogger.debug('Highlighting element with:', { element_css_selector, element_index });
+        await page.evaluate(({ css_selector, index }) => {
+            const proboLabs = window.ProboLabs;
+            if (!proboLabs) {
+                proboLogger.warn('ProboLabs not initialized');
+                return;
+            }
+            // Create ElementInfo object for the element
+            const elementInfo = {
+                css_selector: css_selector,
+                index: index
+            };
+            // Call highlightElements directly
+            proboLabs.highlightElements([elementInfo]);
+        }, {
+            css_selector: element_css_selector,
+            index: element_index
+        });
+    }
+}
+export { ElementTag };

package/dist/index.d.ts

@@ -0,0 +1,57 @@
+import { Page } from 'playwright';
+import { ElementTag } from '@probolabs/highlighter/src/constants';
+export { ElementTag } from '@probolabs/highlighter/src/constants';
+
+type ElementTagType = typeof ElementTag[keyof typeof ElementTag];
+declare global {
+    var highlighterCode: string;
+    interface Window {
+        ProboLabs?: {
+            highlight: {
+                execute: (elementTypes: ElementTagType[]) => Promise<any>;
+                unexecute: () => Promise<any>;
+            };
+            highlightElements: (elements: Array<{
+                css_selector: string;
+                index: string;
+            }>) => void;
+            ElementTag: typeof ElementTag;
+        };
+    }
+}
+
+declare enum ProboLogLevel {
+    DEBUG = "DEBUG",
+    INFO = "INFO",
+    LOG = "LOG",
+    WARN = "WARN",
+    ERROR = "ERROR"
+}
+
+declare const DEMO_TOKEN = "b31793f81a1f58b8a153c86a5fdf4df0e5179c51";
+
+interface ProboConfig {
+    scenarioName: string;
+    token: string;
+    apiUrl: string;
+    enableConsoleLogs?: boolean;
+    debugLevel?: ProboLogLevel;
+}
+declare class Probo {
+    private highlighter;
+    private apiClient;
+    private readonly enableConsoleLogs;
+    private readonly scenarioName;
+    constructor({ scenarioName, token, apiUrl, enableConsoleLogs, debugLevel }: ProboConfig);
+    runStep(page: Page, stepPrompt: string, stepIdFromServer?: number | null, // Make optional
+    useCache?: boolean): Promise<boolean>;
+    private _handleStepCreation;
+    private setupConsoleLogs;
+    highlightElements(page: Page, elementTag: ElementTagType): Promise<any>;
+    unhighlightElements(page: Page): Promise<void>;
+    highlightElement(page: Page, element_css_selector: string, element_index: string): Promise<void>;
+    screenshot(page: Page): Promise<string>;
+    private _handlePerformAction;
+}
+
+export { DEMO_TOKEN, Probo, ProboLogLevel };

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,sCAAsC,CAAC;AAElE,OAAO,EAAe,cAAc,EAAE,MAAM,aAAa,CAAC;AAE1D,OAAO,EAAgB,aAAa,EAAE,MAAM,SAAS,CAAC;AAEtD,eAAO,MAAM,UAAU,6CAA6C,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,CAAC;AACzB,UAAU,WAAW;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,UAAU,CAAC,EAAE,aAAa,CAAC;CAC5B;AAED,qBAAa,KAAK;IAChB,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAU;IAC5C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;gBAC1B,EACV,YAAY,EACZ,KAAK,EACL,MAAM,EACN,iBAAyB,EAC1B,EAAE,WAAW;IAQD,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,QAAQ,GAAE,OAAc,GAAI,OAAO,CAAC,OAAO,CAAC;YAgE7G,mBAAmB;IAgBjC,OAAO,CAAC,gBAAgB;IAUX,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,cAAc;IAIxD,mBAAmB,CAAC,IAAI,EAAE,IAAI;IAI9B,gBAAgB,CAAC,IAAI,EAAE,IAAI,EAAE,oBAAoB,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM;IAIhF,UAAU,CAAC,IAAI,EAAE,IAAI;YAQpB,oBAAoB;CAmCnC;AAGD,OAAO,EAAE,UAAU,EAAE,CAAC"}