@probolabs/playwright 1.0.8 → 1.0.11

package/dist/index.d.ts

@@ -240,6 +240,71 @@ declare class NavTracker {
     static resetInstance(): void;
 }
 
+interface MailinatorMessage {
+    id: string;
+    subject: string;
+    from: string;
+    origfrom?: string;
+    to: string;
+    time: number;
+    seconds_ago: number;
+    domain?: string;
+    source?: string;
+    parts?: Array<{
+        headers: Record<string, string>;
+        body: string;
+    }>;
+    textBody?: string;
+    htmlBody?: string;
+}
+/**
+ * OTP utility class for working with Mailinator API
+ */
+declare class OTP {
+    /**
+     * Fetches the last messages from Mailinator for a specific inbox
+     * @param inbox - The inbox name to check (without @domain)
+     * @param since - Unix timestamp to fetch messages since (optional)
+     * @returns Promise<MailinatorMessage[]> - Array of messages
+     */
+    static fetchLastMessages(inbox: string, since?: number): Promise<MailinatorMessage[]>;
+    /**
+     * Fetches a specific message by ID
+     * @param messageId - The message ID
+     * @returns Promise<MailinatorMessage> - The message details
+     */
+    static fetchMessage(messageId: string): Promise<MailinatorMessage>;
+    /**
+     * Extracts OTP codes from message content
+     * @param message - The message to extract OTP from
+     * @returns string | null - The OTP code or null if not found
+     */
+    static extractOTPFromMessage(message: MailinatorMessage): string | null;
+    /**
+     * Gets the text content from a message for debugging/display purposes
+     * @param message - The message to extract text from
+     * @returns string - The text content of the message
+     */
+    static getMessageTextContent(message: MailinatorMessage): string;
+    /**
+     * Fetches messages from all inboxes in the domain
+     * @param limit - Number of messages to fetch (default: 50)
+     * @param sort - Sort order: 'ascending' or 'descending' (default: 'descending')
+     * @param full - Whether to fetch full message content (default: false)
+     * @returns Promise<MailinatorMessage[]> - Array of messages from all inboxes
+     */
+    static fetchAllInboxMessages(limit?: number, sort?: 'ascending' | 'descending', full?: boolean): Promise<MailinatorMessage[]>;
+    /**
+     * Waits for an OTP to arrive in the inbox and extracts it
+     * @param inbox - The inbox name to monitor (optional - if not provided, searches all inboxes)
+     * @param timeout - Maximum time to wait in milliseconds (default: 30000)
+     * @param checkInterval - How often to check in milliseconds (default: 1000)
+     * @param checkRecentMessagesSinceMs - When > 0, check messages from the last X milliseconds and return the most recent OTP (default: 0)
+     * @returns Promise<string | null> - The extracted OTP code or null if timeout/no OTP found
+     */
+    static waitForOTP(inbox?: string, timeout?: number, checkInterval?: number, checkRecentMessagesSinceMs?: number): Promise<string | null>;
+}
+
 /**
  * Configuration options for Probo client
  */
@@ -284,5 +349,5 @@ declare class Probo {
     askAIHelper(page: Page, question: string): Promise<ServerResponse>;
 }
 
-export { Highlighter, NavTracker, Probo, ProboPlaywright, findClosestVisibleElement };
-export type { ElementTagType, RunStepOptions };
+export { Highlighter, NavTracker, OTP, Probo, ProboPlaywright, findClosestVisibleElement };
+export type { ElementTagType, MailinatorMessage, RunStepOptions };

package/dist/index.js

@@ -44,6 +44,7 @@ var PlaywrightAction;
     PlaywrightAction["EXECUTE_SCRIPT"] = "EXECUTE_SCRIPT";
     PlaywrightAction["UPLOAD_FILES"] = "UPLOAD_FILES";
     PlaywrightAction["WAIT_FOR"] = "WAIT_FOR";
+    PlaywrightAction["WAIT_FOR_OTP"] = "WAIT_FOR_OTP";
 })(PlaywrightAction || (PlaywrightAction = {}));
 
 // WebSocketsMessageType enum for WebSocket and event message types shared across the app
@@ -64,6 +65,7 @@ var WebSocketsMessageType;
     WebSocketsMessageType["INTERACTION_STEP_CREATED"] = "INTERACTION_STEP_CREATED";
     WebSocketsMessageType["INTERACTION_APPLY_AI_SUMMARY_COMPLETED"] = "INTERACTION_APPLY_AI_SUMMARY_COMPLETED";
     WebSocketsMessageType["INTERACTION_APPLY_AI_SUMMARY_ERROR"] = "INTERACTION_APPLY_AI_SUMMARY_ERROR";
+    WebSocketsMessageType["OTP_RETRIEVED"] = "OTP_RETRIEVED";
 })(WebSocketsMessageType || (WebSocketsMessageType = {}));
 
 /**
@@ -616,7 +618,7 @@ const decorateErrorWithCounts = (error, attemptNumber, options) => {
 	return error;
 };
 
-async function pRetry$2(input, options) {
+async function pRetry(input, options) {
 	return new Promise((resolve, reject) => {
 		options = {...options};
 		options.onFailedAttempt ??= () => {};
@@ -743,7 +745,7 @@ class ApiClient {
     }
     async createStep(options) {
         apiLogger.debug('creating step ', options.stepPrompt);
-        return pRetry$2(async () => {
+        return pRetry(async () => {
             const response = await fetch(`${this.apiUrl}/step-runners/`, {
                 method: 'POST',
                 headers: this.getHeaders(),
@@ -770,7 +772,7 @@ class ApiClient {
     async patchStep(stepId, fields) {
         // Use PATCH /steps/:id/ endpoint
         apiLogger.debug(`patching step #${stepId}`);
-        return pRetry$2(async () => {
+        return pRetry(async () => {
             const response = await fetch(`${this.apiUrl}/steps/${stepId}/`, {
                 method: 'PATCH',
                 headers: this.getHeaders(),
@@ -788,7 +790,7 @@ class ApiClient {
     }
     async resolveNextInstruction(stepId, instruction, aiModel) {
         apiLogger.debug(`resolving next instruction: ${instruction}`);
-        return pRetry$2(async () => {
+        return pRetry(async () => {
             apiLogger.debug(`API client: Resolving next instruction for step ${stepId}`);
             const cleanInstruction = cleanupInstructionElements(instruction);
             const response = await fetch(`${this.apiUrl}/step-runners/${stepId}/run/`, {
@@ -810,7 +812,7 @@ class ApiClient {
         });
     }
     async uploadScreenshot(screenshot_bytes) {
-        return pRetry$2(async () => {
+        return pRetry(async () => {
             const response = await fetch(`${this.apiUrl}/upload-screenshots/`, {
                 method: 'POST',
                 headers: {
@@ -830,7 +832,7 @@ class ApiClient {
     }
     async findStepByPrompt(prompt, scenarioName, url = '') {
         apiLogger.debug(`Finding step by prompt: ${prompt} and scenario: ${scenarioName}`);
-        return pRetry$2(async () => {
+        return pRetry(async () => {
             const response = await fetch(`${this.apiUrl}/step-runners/find-step-by-prompt/`, {
                 method: 'POST',
                 headers: this.getHeaders(),
@@ -864,7 +866,7 @@ class ApiClient {
         });
     }
     async resetStep(stepId) {
-        return pRetry$2(async () => {
+        return pRetry(async () => {
             const response = await fetch(`${this.apiUrl}/steps/${stepId}/reset/`, {
                 method: 'POST',
                 headers: this.getHeaders(),
@@ -876,7 +878,7 @@ class ApiClient {
     async interactionToStep(scenarioName, interaction, position = -1) {
         // Use POST /interaction-to-step/ endpoint
         apiLogger.debug(`converting interaction #${interaction.interactionId} to step`);
-        return pRetry$2(async () => {
+        return pRetry(async () => {
             var _a, _b;
             const response = await fetch(`${this.apiUrl}/interaction-to-step/`, {
                 method: 'POST',
@@ -910,7 +912,7 @@ class ApiClient {
     async actionToPrompt(action2promptInput, aiModel) {
         // Use POST /action-to-prompt/ endpoint
         apiLogger.debug(`running action2prompt for step #${action2promptInput.step_id}`);
-        return pRetry$2(async () => {
+        return pRetry(async () => {
             const response = await fetch(`${this.apiUrl}/steps/${action2promptInput.step_id}/action_to_prompt/`, {
                 method: 'POST',
                 headers: this.getHeaders(),
@@ -941,7 +943,7 @@ class ApiClient {
     async askAI(question, scenarioName, screenshot, aiModel) {
         apiLogger.debug(`Asking AI question: "${question}", scenarioName: ${scenarioName}`);
         apiLogger.debug(`headers: ${JSON.stringify(this.getHeaders())}`);
-        return pRetry$2(async () => {
+        return pRetry(async () => {
             const response = await fetch(`${this.apiUrl}/api/ask-ai/`, {
                 method: 'POST',
                 headers: this.getHeaders(),
@@ -1277,103 +1279,286 @@ class Highlighter {
     }
 }
 
-var pRetry$1 = {exports: {}};
-
-var hasRequiredPRetry;
-
-function requirePRetry () {
-	if (hasRequiredPRetry) return pRetry$1.exports;
-	hasRequiredPRetry = 1;
-	const retry = requireRetry();
-
-	const networkErrorMsgs = [
-		'Failed to fetch', // Chrome
-		'NetworkError when attempting to fetch resource.', // Firefox
-		'The Internet connection appears to be offline.', // Safari
-		'Network request failed' // `cross-fetch`
-	];
-
-	class AbortError extends Error {
-		constructor(message) {
-			super();
-
-			if (message instanceof Error) {
-				this.originalError = message;
-				({message} = message);
-			} else {
-				this.originalError = new Error(message);
-				this.originalError.stack = this.stack;
-			}
-
-			this.name = 'AbortError';
-			this.message = message;
-		}
-	}
-
-	const decorateErrorWithCounts = (error, attemptNumber, options) => {
-		// Minus 1 from attemptNumber because the first attempt does not count as a retry
-		const retriesLeft = options.retries - (attemptNumber - 1);
-
-		error.attemptNumber = attemptNumber;
-		error.retriesLeft = retriesLeft;
-		return error;
-	};
-
-	const isNetworkError = errorMessage => networkErrorMsgs.includes(errorMessage);
-
-	const pRetry = (input, options) => new Promise((resolve, reject) => {
-		options = {
-			onFailedAttempt: () => {},
-			retries: 10,
-			...options
-		};
-
-		const operation = retry.operation(options);
-
-		operation.attempt(async attemptNumber => {
-			try {
-				resolve(await input(attemptNumber));
-			} catch (error) {
-				if (!(error instanceof Error)) {
-					reject(new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`));
-					return;
-				}
-
-				if (error instanceof AbortError) {
-					operation.stop();
-					reject(error.originalError);
-				} else if (error instanceof TypeError && !isNetworkError(error.message)) {
-					operation.stop();
-					reject(error);
-				} else {
-					decorateErrorWithCounts(error, attemptNumber, options);
-
-					try {
-						await options.onFailedAttempt(error);
-					} catch (error) {
-						reject(error);
-						return;
-					}
-
-					if (!operation.retry(error)) {
-						reject(operation.mainError());
-					}
-				}
-			}
-		});
-	});
-
-	pRetry$1.exports = pRetry;
-	// TODO: remove this in the next major version
-	pRetry$1.exports.default = pRetry;
-
-	pRetry$1.exports.AbortError = AbortError;
-	return pRetry$1.exports;
+const MAILINATOR_API_KEY = '5bfef31518e84dfbb861b36f59259695';
+const MAILINATOR_DOMAIN = 'probolabs.testinator.com';
+/**
+ * OTP utility class for working with Mailinator API
+ */
+class OTP {
+    /**
+     * Fetches the last messages from Mailinator for a specific inbox
+     * @param inbox - The inbox name to check (without @domain)
+     * @param since - Unix timestamp to fetch messages since (optional)
+     * @returns Promise<MailinatorMessage[]> - Array of messages
+     */
+    static async fetchLastMessages(inbox, since) {
+        try {
+            // Use the correct Mailinator API endpoint structure
+            const url = `https://api.mailinator.com/v2/domains/${MAILINATOR_DOMAIN}/inboxes/${inbox}`;
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${MAILINATOR_API_KEY}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            if (!response.ok) {
+                throw new Error(`Mailinator API error: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            // The API returns messages in 'msgs' property, not 'messages'
+            const messages = data.msgs || data.messages || data || [];
+            // Filter messages by 'since' timestamp if provided
+            if (since) {
+                return messages.filter((message) => message.time >= since);
+            }
+            return messages;
+        }
+        catch (error) {
+            console.error('Error fetching messages from Mailinator:', error);
+            throw error;
+        }
+    }
+    /**
+     * Fetches a specific message by ID
+     * @param messageId - The message ID
+     * @returns Promise<MailinatorMessage> - The message details
+     */
+    static async fetchMessage(messageId) {
+        try {
+            const url = `https://api.mailinator.com/v2/domains/${MAILINATOR_DOMAIN}/messages/${messageId}`;
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${MAILINATOR_API_KEY}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            if (!response.ok) {
+                throw new Error(`Mailinator API error: ${response.status} ${response.statusText}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            console.error('Error fetching message from Mailinator:', error);
+            throw error;
+        }
+    }
+    /**
+     * Extracts OTP codes from message content
+     * @param message - The message to extract OTP from
+     * @returns string | null - The OTP code or null if not found
+     */
+    static extractOTPFromMessage(message) {
+        // Common OTP patterns - ordered by specificity (most specific first)
+        const otpPatterns = [
+            // Very specific patterns for common OTP formats
+            /(?:verification\s+code|verification\s+number|6-digit\s+verification\s+code)[\s\S]*?(\d{6})/i,
+            /(?:use\s+the\s+6-digit\s+verification\s+code\s+below)[\s\S]*?(\d{6})/i,
+            /(?:code\s+below\s+to\s+complete)[\s\S]*?(\d{6})/i,
+            /(?:verification\s+code)[\s\S]*?(\d{6})/i,
+            // Patterns with context around the code
+            /(?:OTP|code|verification code|verification):\s*(\d{4,8})/i,
+            /(?:enter|use|input)\s+(?:the\s+)?(?:code|OTP|verification code):\s*(\d{4,8})/i,
+            /(?:your\s+)?(?:verification\s+)?(?:code\s+is|OTP\s+is):\s*(\d{4,8})/i,
+            /(?:code|OTP|pin):\s*(\d{4,8})/i,
+            /(?:code|OTP)\s+is\s+(\d{4,8})/i,
+            // Look for codes in specific contexts (avoiding URLs and tracking IDs)
+            /(?:complete\s+your\s+sign-in)[\s\S]*?(\d{6})/i,
+            /(?:valid\s+for\s+the\s+next)[\s\S]*?(\d{6})/i,
+            // Fallback: 6-digit numbers (most common OTP length)
+            /(?:^|\s)(\d{6})(?:\s|$)/i,
+            // Last resort: 4-8 digit numbers (but avoid very long ones that are likely tracking IDs)
+            /(?:^|\s)(\d{4,8})(?:\s|$)/i
+        ];
+        // Helper function to check if a number is likely an OTP (not a tracking ID, phone number, etc.)
+        const isValidOTP = (number) => {
+            // Common OTP lengths
+            if (number.length < 4 || number.length > 8)
+                return false;
+            // Only filter out very obvious non-OTPs
+            // Avoid numbers that are all the same digit (unlikely to be OTPs)
+            if (/^(\d)\1+$/.test(number))
+                return false;
+            // Avoid very long numbers that are clearly tracking IDs (but be more lenient)
+            if (number.length >= 8 && parseInt(number) > 99999999)
+                return false;
+            return true;
+        };
+        // Helper function to extract OTP from text content
+        const extractFromText = (text) => {
+            if (!text)
+                return null;
+            for (const pattern of otpPatterns) {
+                const match = text.match(pattern);
+                if (match && match[1] && isValidOTP(match[1])) {
+                    return match[1];
+                }
+            }
+            return null;
+        };
+        // Helper function to strip HTML tags
+        const stripHtml = (html) => {
+            return html.replace(/<[^>]*>/g, '').replace(/&[^;]+;/g, ' ');
+        };
+        // 1. Try to extract from text body first (preferred)
+        if (message.textBody) {
+            const otp = extractFromText(message.textBody);
+            if (otp)
+                return otp;
+        }
+        // 2. Try to extract from HTML body (strip HTML tags first)
+        if (message.htmlBody) {
+            const plainText = stripHtml(message.htmlBody);
+            const otp = extractFromText(plainText);
+            if (otp)
+                return otp;
+        }
+        // 3. Try to extract from message parts
+        if (message.parts && message.parts.length > 0) {
+            for (const part of message.parts) {
+                if (part.body) {
+                    const otp = extractFromText(part.body);
+                    if (otp)
+                        return otp;
+                }
+            }
+        }
+        // 4. Fallback: try to extract from subject
+        const otp = extractFromText(message.subject);
+        if (otp)
+            return otp;
+        return null;
+    }
+    /**
+     * Gets the text content from a message for debugging/display purposes
+     * @param message - The message to extract text from
+     * @returns string - The text content of the message
+     */
+    static getMessageTextContent(message) {
+        // Helper function to strip HTML tags
+        const stripHtml = (html) => {
+            return html.replace(/<[^>]*>/g, '').replace(/&[^;]+;/g, ' ');
+        };
+        // Priority order: textBody > htmlBody > parts > subject
+        if (message.textBody) {
+            return message.textBody;
+        }
+        if (message.htmlBody) {
+            return stripHtml(message.htmlBody);
+        }
+        if (message.parts && message.parts.length > 0) {
+            return message.parts.map(part => part.body || '').join('\n');
+        }
+        return message.subject || '';
+    }
+    /**
+     * Fetches messages from all inboxes in the domain
+     * @param limit - Number of messages to fetch (default: 50)
+     * @param sort - Sort order: 'ascending' or 'descending' (default: 'descending')
+     * @param full - Whether to fetch full message content (default: false)
+     * @returns Promise<MailinatorMessage[]> - Array of messages from all inboxes
+     */
+    static async fetchAllInboxMessages(limit = 50, sort = 'descending', full = false) {
+        try {
+            const url = `https://api.mailinator.com/v2/domains/${MAILINATOR_DOMAIN}/inboxes/?limit=${limit}&sort=${sort}${full ? '&full=true' : ''}`;
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${MAILINATOR_API_KEY}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            if (!response.ok) {
+                throw new Error(`Mailinator API error: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            return data.msgs || data.messages || data || [];
+        }
+        catch (error) {
+            console.error('Error fetching messages from all inboxes:', error);
+            throw error;
+        }
+    }
+    /**
+     * Waits for an OTP to arrive in the inbox and extracts it
+     * @param inbox - The inbox name to monitor (optional - if not provided, searches all inboxes)
+     * @param timeout - Maximum time to wait in milliseconds (default: 30000)
+     * @param checkInterval - How often to check in milliseconds (default: 1000)
+     * @param checkRecentMessagesSinceMs - When > 0, check messages from the last X milliseconds and return the most recent OTP (default: 0)
+     * @returns Promise<string | null> - The extracted OTP code or null if timeout/no OTP found
+     */
+    static async waitForOTP(inbox, timeout = 30000, checkInterval = 1000, checkRecentMessagesSinceMs = 0) {
+        const startTime = Date.now();
+        // If checkRecentMessagesSinceMs > 0, check for recent messages first
+        if (checkRecentMessagesSinceMs > 0) {
+            console.log(`Checking for OTP in messages from the last ${checkRecentMessagesSinceMs}ms...`);
+            const recentMessagesCutoff = Date.now() - checkRecentMessagesSinceMs;
+            const recentMessages = inbox
+                ? await OTP.fetchLastMessages(inbox)
+                : await OTP.fetchAllInboxMessages();
+            // Filter messages from the specified time window
+            const messagesFromWindow = recentMessages.filter(msg => msg.time >= recentMessagesCutoff);
+            // Sort by time (most recent first) and check for OTP
+            const sortedMessages = messagesFromWindow.sort((a, b) => b.time - a.time);
+            for (const message of sortedMessages) {
+                let otp = OTP.extractOTPFromMessage(message);
+                if (otp) {
+                    console.log(`Found OTP in recent message: ${otp}`);
+                    return otp;
+                }
+                // If no OTP found in summary, fetch full message details
+                try {
+                    const fullMessage = await OTP.fetchMessage(message.id);
+                    otp = OTP.extractOTPFromMessage(fullMessage);
+                    if (otp) {
+                        console.log(`Found OTP in recent full message: ${otp}`);
+                        return otp;
+                    }
+                }
+                catch (error) {
+                    console.warn(`Error fetching full message ${message.id}:`, error);
+                }
+            }
+            console.log(`No OTP found in recent messages, starting to monitor for new messages...`);
+        }
+        // Get initial messages for monitoring new ones (from specific inbox or all inboxes)
+        const initialMessages = inbox
+            ? await OTP.fetchLastMessages(inbox)
+            : await OTP.fetchAllInboxMessages();
+        const initialMessageIds = new Set(initialMessages.map(msg => msg.id));
+        while (Date.now() - startTime < timeout) {
+            await new Promise(resolve => setTimeout(resolve, checkInterval));
+            try {
+                // Get current messages (from specific inbox or all inboxes)
+                const currentMessages = inbox
+                    ? await OTP.fetchLastMessages(inbox)
+                    : await OTP.fetchAllInboxMessages();
+                const newMessages = currentMessages.filter(msg => !initialMessageIds.has(msg.id));
+                if (newMessages.length > 0) {
+                    // Get the first new message and try to extract OTP
+                    const newMessage = newMessages[0];
+                    // First try to extract OTP from the message summary (faster)
+                    let otp = OTP.extractOTPFromMessage(newMessage);
+                    if (otp) {
+                        return otp;
+                    }
+                    // If no OTP found in summary, fetch full message details
+                    const fullMessage = await OTP.fetchMessage(newMessage.id);
+                    otp = OTP.extractOTPFromMessage(fullMessage);
+                    if (otp) {
+                        return otp;
+                    }
+                }
+            }
+            catch (error) {
+                console.warn('Error checking for new messages:', error);
+            }
+        }
+        return null; // Timeout reached or no OTP found
+    }
 }
 
-var pRetryExports = requirePRetry();
-var pRetry = /*@__PURE__*/getDefaultExportFromCjs(pRetryExports);
-
 class ProboPlaywright {
     constructor(config = DEFAULT_PLAYWRIGHT_TIMEOUT_CONFIG, page = null) {
         this.page = null;
@@ -1466,6 +1651,17 @@ class ProboPlaywright {
             case PlaywrightAction.SET_SLIDER:
                 await this.setSliderValue(locator, argument);
                 break;
+            case PlaywrightAction.WAIT_FOR_OTP:
+                // till we figure out how to get the inbox name we will wait for ANY OTP in all inboxes  
+                const otp = await OTP.waitForOTP();
+                if (otp) {
+                    console.log(`✅ OTP found: ${otp}`);
+                    await locator.fill(otp);
+                }
+                else {
+                    console.log(`❌ OTP not found`);
+                }
+                break;
             case PlaywrightAction.ASSERT_CONTAINS_VALUE:
                 const containerText = await this.getTextValue(locator);
                 if (!matchRegex(containerText, argument)) {
@@ -2437,5 +2633,5 @@ class Probo {
     }
 }
 
-export { Highlighter, NavTracker, PlaywrightAction, Probo, ProboLogLevel, ProboPlaywright, findClosestVisibleElement };
+export { Highlighter, NavTracker, OTP, PlaywrightAction, Probo, ProboLogLevel, ProboPlaywright, findClosestVisibleElement };
 //# sourceMappingURL=index.js.map