@probolabs/playwright 1.2.0 → 1.4.0-rc.1

package/dist/cli.js

@@ -0,0 +1,1893 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { exec, spawn } from 'child_process';
+import { promisify } from 'util';
+import 'adm-zip';
+import fetch$1 from 'node-fetch';
+
+var ApplyAIStatus;
+(function (ApplyAIStatus) {
+    ApplyAIStatus["PREPARE_START"] = "PREPARE_START";
+    ApplyAIStatus["PREPARE_SUCCESS"] = "PREPARE_SUCCESS";
+    ApplyAIStatus["PREPARE_ERROR"] = "PREPARE_ERROR";
+    ApplyAIStatus["SEND_START"] = "SEND_START";
+    ApplyAIStatus["SEND_SUCCESS"] = "SEND_SUCCESS";
+    ApplyAIStatus["SEND_ERROR"] = "SEND_ERROR";
+    ApplyAIStatus["APPLY_AI_ERROR"] = "APPLY_AI_ERROR";
+    ApplyAIStatus["APPLY_AI_CANCELLED"] = "APPLY_AI_CANCELLED";
+    ApplyAIStatus["SUMMARY_COMPLETED"] = "SUMMARY_COMPLETED";
+    ApplyAIStatus["SUMMARY_ERROR"] = "SUMMARY_ERROR";
+})(ApplyAIStatus || (ApplyAIStatus = {}));
+var ReplayStatus;
+(function (ReplayStatus) {
+    ReplayStatus["REPLAY_START"] = "REPLAY_START";
+    ReplayStatus["REPLAY_SUCCESS"] = "REPLAY_SUCCESS";
+    ReplayStatus["REPLAY_ERROR"] = "REPLAY_ERROR";
+    ReplayStatus["REPLAY_CANCELLED"] = "REPLAY_CANCELLED";
+})(ReplayStatus || (ReplayStatus = {}));
+
+// Action constants
+var PlaywrightAction;
+(function (PlaywrightAction) {
+    PlaywrightAction["VISIT_BASE_URL"] = "VISIT_BASE_URL";
+    PlaywrightAction["VISIT_URL"] = "VISIT_URL";
+    PlaywrightAction["CLICK"] = "CLICK";
+    PlaywrightAction["FILL_IN"] = "FILL_IN";
+    PlaywrightAction["SELECT_DROPDOWN"] = "SELECT_DROPDOWN";
+    PlaywrightAction["SELECT_MULTIPLE_DROPDOWN"] = "SELECT_MULTIPLE_DROPDOWN";
+    PlaywrightAction["CHECK_CHECKBOX"] = "CHECK_CHECKBOX";
+    PlaywrightAction["SELECT_RADIO"] = "SELECT_RADIO";
+    PlaywrightAction["TOGGLE_SWITCH"] = "TOGGLE_SWITCH";
+    PlaywrightAction["SET_SLIDER"] = "SET_SLIDER";
+    PlaywrightAction["TYPE_KEYS"] = "TYPE_KEYS";
+    PlaywrightAction["HOVER"] = "HOVER";
+    PlaywrightAction["ASSERT_EXACT_VALUE"] = "ASSERT_EXACT_VALUE";
+    PlaywrightAction["ASSERT_CONTAINS_VALUE"] = "ASSERT_CONTAINS_VALUE";
+    PlaywrightAction["ASSERT_URL"] = "ASSERT_URL";
+    PlaywrightAction["SCROLL_TO_ELEMENT"] = "SCROLL_TO_ELEMENT";
+    PlaywrightAction["EXTRACT_VALUE"] = "EXTRACT_VALUE";
+    PlaywrightAction["ASK_AI"] = "ASK_AI";
+    PlaywrightAction["EXECUTE_SCRIPT"] = "EXECUTE_SCRIPT";
+    PlaywrightAction["UPLOAD_FILES"] = "UPLOAD_FILES";
+    PlaywrightAction["WAIT_FOR"] = "WAIT_FOR";
+    PlaywrightAction["WAIT_FOR_OTP"] = "WAIT_FOR_OTP";
+    PlaywrightAction["GEN_TOTP"] = "GEN_TOTP";
+    // Sequence marker actions (not real interactions, used only for grouping)
+    PlaywrightAction["SEQUENCE_START"] = "SEQUENCE_START";
+    PlaywrightAction["SEQUENCE_END"] = "SEQUENCE_END";
+})(PlaywrightAction || (PlaywrightAction = {}));
+
+// clickable element detection result
+var IsClickable;
+(function (IsClickable) {
+    IsClickable["YES"] = "YES";
+    IsClickable["NO"] = "NO";
+    IsClickable["MAYBE"] = "MAYBE";
+})(IsClickable || (IsClickable = {}));
+
+// WebSocketsMessageType enum for WebSocket and event message types shared across the app
+var WebSocketsMessageType;
+(function (WebSocketsMessageType) {
+    WebSocketsMessageType["INTERACTION_APPLY_AI_PREPARE_START"] = "INTERACTION_APPLY_AI_PREPARE_START";
+    WebSocketsMessageType["INTERACTION_APPLY_AI_PREPARE_SUCCESS"] = "INTERACTION_APPLY_AI_PREPARE_SUCCESS";
+    WebSocketsMessageType["INTERACTION_APPLY_AI_PREPARE_ERROR"] = "INTERACTION_APPLY_AI_PREPARE_ERROR";
+    WebSocketsMessageType["INTERACTION_APPLY_AI_SEND_TO_LLM_START"] = "INTERACTION_APPLY_AI_SEND_TO_LLM_START";
+    WebSocketsMessageType["INTERACTION_APPLY_AI_SEND_TO_LLM_SUCCESS"] = "INTERACTION_APPLY_AI_SEND_TO_LLM_SUCCESS";
+    WebSocketsMessageType["INTERACTION_APPLY_AI_SEND_TO_LLM_ERROR"] = "INTERACTION_APPLY_AI_SEND_TO_LLM_ERROR";
+    WebSocketsMessageType["INTERACTION_REPLAY_START"] = "INTERACTION_REPLAY_START";
+    WebSocketsMessageType["INTERACTION_REPLAY_SUCCESS"] = "INTERACTION_REPLAY_SUCCESS";
+    WebSocketsMessageType["INTERACTION_REPLAY_ERROR"] = "INTERACTION_REPLAY_ERROR";
+    WebSocketsMessageType["INTERACTION_REPLAY_CANCELLED"] = "INTERACTION_REPLAY_CANCELLED";
+    WebSocketsMessageType["INTERACTION_APPLY_AI_CANCELLED"] = "INTERACTION_APPLY_AI_CANCELLED";
+    WebSocketsMessageType["INTERACTION_APPLY_AI_ERROR"] = "INTERACTION_APPLY_AI_ERROR";
+    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["TEST_SUITE_RUN_START"] = "TEST_SUITE_RUN_START";
+    WebSocketsMessageType["TEST_SUITE_RUN_LOG"] = "TEST_SUITE_RUN_LOG";
+    WebSocketsMessageType["TEST_SUITE_RUN_COMPLETE"] = "TEST_SUITE_RUN_COMPLETE";
+    WebSocketsMessageType["TEST_SUITE_RUN_ERROR"] = "TEST_SUITE_RUN_ERROR";
+    WebSocketsMessageType["TEST_SUITE_RUN_REPORTER_EVENT"] = "TEST_SUITE_RUN_REPORTER_EVENT";
+})(WebSocketsMessageType || (WebSocketsMessageType = {}));
+
+/**
+ * Logging levels for Probo
+ */
+var ProboLogLevel;
+(function (ProboLogLevel) {
+    ProboLogLevel["DEBUG"] = "DEBUG";
+    ProboLogLevel["INFO"] = "INFO";
+    ProboLogLevel["LOG"] = "LOG";
+    ProboLogLevel["WARN"] = "WARN";
+    ProboLogLevel["ERROR"] = "ERROR";
+})(ProboLogLevel || (ProboLogLevel = {}));
+const logLevelOrder = {
+    [ProboLogLevel.DEBUG]: 0,
+    [ProboLogLevel.INFO]: 1,
+    [ProboLogLevel.LOG]: 2,
+    [ProboLogLevel.WARN]: 3,
+    [ProboLogLevel.ERROR]: 4,
+};
+class ProboLogger {
+    constructor(prefix, level = ProboLogLevel.INFO) {
+        this.prefix = prefix;
+        this.level = level;
+    }
+    setLogLevel(level) {
+        console.log(`[${this.prefix}] Setting log level to: ${level} (was: ${this.level})`);
+        this.level = level;
+    }
+    shouldLog(level) {
+        return logLevelOrder[level] >= logLevelOrder[this.level];
+    }
+    preamble(level) {
+        const now = new Date();
+        const hours = String(now.getHours()).padStart(2, '0');
+        const minutes = String(now.getMinutes()).padStart(2, '0');
+        const seconds = String(now.getSeconds()).padStart(2, '0');
+        const milliseconds = String(now.getMilliseconds()).padStart(3, '0');
+        return `[${hours}:${minutes}:${seconds}.${milliseconds}] [${this.prefix}] [${level}]`;
+    }
+    debug(...args) { if (this.shouldLog(ProboLogLevel.DEBUG))
+        console.debug(this.preamble(ProboLogLevel.DEBUG), ...args); }
+    info(...args) { if (this.shouldLog(ProboLogLevel.INFO))
+        console.info(this.preamble(ProboLogLevel.INFO), ...args); }
+    log(...args) { if (this.shouldLog(ProboLogLevel.LOG))
+        console.log(this.preamble(ProboLogLevel.LOG), ...args); }
+    warn(...args) { if (this.shouldLog(ProboLogLevel.WARN))
+        console.warn(this.preamble(ProboLogLevel.WARN), ...args); }
+    error(...args) { if (this.shouldLog(ProboLogLevel.ERROR))
+        console.error(this.preamble(ProboLogLevel.ERROR), ...args); }
+}
+// Element cleaner logging
+// const elementLogger = new ProboLogger('element-cleaner');
+/**
+ * Cleans and returns a minimal element info structure.
+ */
+//TODO: is this needed?
+/* export function cleanupElementInfo(elementInfo: ElementInfo): CleanElementInfo {
+  elementLogger.debug(
+    `Cleaning up element info for ${elementInfo.tag} at index ${elementInfo.index}`
+  );
+  const depth = elementInfo.depth ?? elementInfo.getDepth();
+  const cleanEl = {
+    index: elementInfo.index,
+    tag: elementInfo.tag,
+    type: elementInfo.type,
+    text: elementInfo.text,
+    html: elementInfo.html,
+    xpath: elementInfo.xpath,
+    css_selector: elementInfo.css_selector,
+    iframe_selector: elementInfo.iframe_selector,
+    bounding_box: elementInfo.bounding_box,
+    depth
+  };
+  elementLogger.debug(`Cleaned element: ${JSON.stringify(cleanEl)}`);
+  return cleanEl;
+} */
+/**
+ * Cleans highlighted elements in an instruction payload.
+ */
+/* export function cleanupInstructionElements(instruction: any): any {
+  if (!instruction?.result?.highlighted_elements) {
+    elementLogger.debug('No highlighted elements to clean');
+    return instruction;
+  }
+  elementLogger.debug(
+    `Cleaning ${instruction.result.highlighted_elements.length} highlighted elements`
+  );
+  const cleaned = {
+    ...instruction,
+    result: {
+      ...instruction.result,
+      highlighted_elements: instruction.result.highlighted_elements.map(
+        (el: ElementInfo) => cleanupElementInfo(el)
+      )
+    }
+  };
+  elementLogger.debug('Instruction cleaning completed');
+  return cleaned;
+} */
+// Determine whether an interaction can return a value
+const hasReturnValue = (i) => {
+    return [
+        PlaywrightAction.EXTRACT_VALUE,
+        PlaywrightAction.ASK_AI,
+        PlaywrightAction.EXECUTE_SCRIPT
+    ].includes(i.action);
+};
+const getReturnValueParameterName = (i) => {
+    switch (i.action) {
+        case PlaywrightAction.EXTRACT_VALUE:
+        case PlaywrightAction.EXECUTE_SCRIPT:
+            return i.parameterName;
+        case PlaywrightAction.ASK_AI:
+            return i.parameterName.replace(/^assert_/, '');
+        default:
+            console.error(`Action ${i.action} has no return value`);
+            return '';
+    }
+};
+// Determine whether an interaction can be parameterized
+const isParameterizable = (i) => {
+    const parameterizableActions = [
+        PlaywrightAction.FILL_IN,
+        PlaywrightAction.SELECT_DROPDOWN,
+        PlaywrightAction.SET_SLIDER,
+        PlaywrightAction.ASSERT_CONTAINS_VALUE,
+        PlaywrightAction.ASSERT_EXACT_VALUE,
+        PlaywrightAction.VISIT_URL,
+        PlaywrightAction.ASSERT_URL,
+        PlaywrightAction.UPLOAD_FILES,
+        PlaywrightAction.WAIT_FOR,
+        PlaywrightAction.GEN_TOTP,
+        PlaywrightAction.WAIT_FOR_OTP
+    ];
+    return parameterizableActions.includes(i.action) || (i.action === PlaywrightAction.ASK_AI && i.argument);
+};
+// Determine whether an interaction is AI-related
+const isAI = (i) => {
+    var _a, _b, _c, _d, _e, _f;
+    return !['TYPE_KEYS', 'VISIT_URL', 'EXECUTE_SCRIPT'].includes(i.action) &&
+        (i.action === PlaywrightAction.ASK_AI ||
+            (((_b = (_a = i.serverResponse) === null || _a === void 0 ? void 0 : _a.result) === null || _b === void 0 ? void 0 : _b.prompt) && (((_d = (_c = i.serverResponse) === null || _c === void 0 ? void 0 : _c.result) === null || _d === void 0 ? void 0 : _d.error) === "" || !((_f = (_e = i.serverResponse) === null || _e === void 0 ? void 0 : _e.result) === null || _f === void 0 ? void 0 : _f.error))));
+};
+function singleQuoteString(str) {
+    if (!str)
+        return '';
+    return `'${str.replace(/'/g, "\\'")}'`;
+}
+/**
+ * Converts a string to a filesystem-safe slug.
+ * Used for filenames/package names (not URL parsing).
+ */
+function slugify(text) {
+    if (!text)
+        return 'scenario';
+    return text
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-zA-Z0-9-_]/g, '-') // Replace non-alphanumeric chars with hyphens
+        .replace(/-+/g, '-') // Replace multiple hyphens with single hyphen
+        .replace(/^-|-$/g, '') // Remove leading/trailing hyphens
+        .substring(0, 100); // Limit length to 100 chars
+}
+
+new ProboLogger('apiclient');
+
+/**
+ * Available AI models for LLM operations
+ */
+var AIModel;
+(function (AIModel) {
+    AIModel["AZURE_GPT4"] = "azure-gpt4";
+    AIModel["AZURE_GPT4_MINI"] = "azure-gpt4-mini";
+    AIModel["GEMINI_1_5_FLASH"] = "gemini-1.5-flash";
+    AIModel["GEMINI_2_5_FLASH"] = "gemini-2.5-flash";
+    AIModel["GPT4"] = "gpt4";
+    AIModel["GPT4_MINI"] = "gpt4-mini";
+    AIModel["CLAUDE_3_5"] = "claude-3.5";
+    AIModel["CLAUDE_SONNET_4_5"] = "claude-sonnet-4.5";
+    AIModel["CLAUDE_HAIKU_4_5"] = "claude-haiku-4.5";
+    AIModel["CLAUDE_OPUS_4_1"] = "claude-opus-4.1";
+    AIModel["GROK_2"] = "grok-2";
+    AIModel["LLAMA_4_SCOUT"] = "llama-4-scout";
+    AIModel["DEEPSEEK_V3"] = "deepseek-v3";
+})(AIModel || (AIModel = {}));
+
+const DEFAULT_PLAYWRIGHT_TIMEOUT_CONFIG = {
+    highlightTimeout: 300,
+    playwrightActionTimeout: 5000,
+    playwrightNavigationTimeout: 10000,
+    playwrightLocatorTimeout: 2000,
+    // mutation observer
+    mutationsTimeout: 500,
+    mutationsInitTimeout: 1000,
+    // wait for navigation
+    waitForNavigationInitialTimeout: 2000,
+    waitForNavigationNavigationTimeout: 7000,
+    waitForNavigationGlobalTimeout: 15000,
+    // wait for stability
+    waitForStabilityQuietTimeout: 2000,
+    waitForStabilityInitialDelay: 100,
+    waitForStabilityGlobalTimeout: 15000,
+    waitForStabilityVerbose: false,
+    scriptTimeout: 120000, // 2 minutes
+};
+
+const DEFAULT_RECORDER_SETTINGS = {
+    // API Configuration
+    apiKey: '',
+    apiEndPoint: 'https://api.probolabs.ai',
+    frontendUrl: 'https://app.probolabs.ai',
+    baseUrl: undefined,
+    // Scenario Configuration
+    scenarioName: 'new recording',
+    scenarioId: undefined,
+    aiModel: 'azure-gpt4-mini',
+    activeParamSet: 0,
+    // Browser Configuration
+    resetBrowserBeforeReplay: true,
+    enableSmartSelectors: true, // Smart selectors always enabled
+    // Script Configuration
+    scriptTimeout: DEFAULT_PLAYWRIGHT_TIMEOUT_CONFIG.scriptTimeout,
+    // Logging Configuration
+    enableConsoleLogs: true,
+    debugLevel: 'DEBUG',
+    // Timeout Configuration (spread from PlaywrightTimeoutConfig)
+    ...DEFAULT_PLAYWRIGHT_TIMEOUT_CONFIG,
+};
+
+// --- Code generation utilities for Probo Labs Playwright scripts ---
+/**
+ * Extracts environment variable names from parameter table rows
+ * by parsing ${process.env.VAR_NAME} patterns from parameter values
+ *
+ * @param rows - Array of parameter table rows (Record<string, string>)
+ * @returns Set of unique environment variable names (in uppercase)
+ */
+function extractRequiredEnvVars(rows) {
+    const envVars = new Set();
+    // Return empty set if rows are not provided or empty
+    if (!rows || !Array.isArray(rows) || rows.length === 0) {
+        return envVars;
+    }
+    // Regex to match both escaped and unescaped process.env patterns
+    // Matches: ${process.env.VAR_NAME} or \${process.env.VAR_NAME}
+    // Pattern: optional backslash (\\), then ${ (escaped as \$\{), then process.env., then variable name
+    const envVarPattern = /\\?\$\{process\.env\.([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
+    // Scan all parameter values in all rows for env var patterns
+    rows.forEach((row) => {
+        if (row && typeof row === 'object') {
+            Object.values(row).forEach((value) => {
+                if (typeof value === 'string') {
+                    let match;
+                    while ((match = envVarPattern.exec(value)) !== null) {
+                        const varName = match[1].toUpperCase(); // Ensure uppercase for consistency
+                        envVars.add(varName);
+                    }
+                    // Reset regex lastIndex for next iteration
+                    envVarPattern.lastIndex = 0;
+                }
+            });
+        }
+    });
+    return envVars;
+}
+/**
+ * Generates Playwright native code for a given interaction.
+ *
+ * @param interaction - The interaction object containing action, element info, and other metadata.
+ * @returns A string of Playwright code that performs the specified interaction.
+ */
+function interactionToNativeCode(interaction) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    const selector = ((_a = interaction.elementInfo) === null || _a === void 0 ? void 0 : _a.css_selector) || '';
+    const iframe = ((_b = interaction.elementInfo) === null || _b === void 0 ? void 0 : _b.iframe_selector) || '';
+    const smartSelector = ((_c = interaction.elementInfo) === null || _c === void 0 ? void 0 : _c.smart_selector) || null;
+    const smartIFrameSelector = ((_d = interaction.elementInfo) === null || _d === void 0 ? void 0 : _d.smart_iframe_selector) || null;
+    const argument = isParameterizable(interaction) ? `param.${interaction.parameterName}` : singleQuoteString(interaction.argument);
+    // Escape the nativeDescription for use in test.step() string literal
+    const escapedStepName = interaction.nativeDescription.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    const comment = `
+        // ${interaction.nativeDescription}${interaction.annotation ? `\n        // annotation: ${interaction.annotation}` : ''}`;
+    switch (interaction.action) {
+        case PlaywrightAction.CLICK:
+        case PlaywrightAction.CHECK_CHECKBOX:
+        case PlaywrightAction.SELECT_RADIO:
+        case PlaywrightAction.FILL_IN:
+        case PlaywrightAction.TYPE_KEYS:
+        case PlaywrightAction.SET_SLIDER:
+        case PlaywrightAction.SELECT_DROPDOWN:
+        case PlaywrightAction.ASSERT_CONTAINS_VALUE:
+        case PlaywrightAction.ASSERT_EXACT_VALUE:
+        case PlaywrightAction.HOVER:
+        case PlaywrightAction.SCROLL_TO_ELEMENT:
+        case PlaywrightAction.UPLOAD_FILES:
+        case PlaywrightAction.VISIT_URL:
+        case PlaywrightAction.VISIT_BASE_URL:
+        case PlaywrightAction.ASSERT_URL:
+        case PlaywrightAction.WAIT_FOR:
+        case PlaywrightAction.WAIT_FOR_OTP:
+        case PlaywrightAction.GEN_TOTP:
+            const args = [
+                `action: PlaywrightAction.${interaction.action}`,
+                ...(argument ? [`argument: ${argument}`] : []),
+                ...(iframe ? [`iframeSelector: '${iframe}'`] : []),
+                ...(selector ? [`elementSelector: '${selector}'`] : []),
+                ...(smartSelector ? [`smartSelector: ${JSON.stringify(smartSelector)}`] : []),
+                ...(smartIFrameSelector ? [`smartIFrameSelector: ${JSON.stringify(smartIFrameSelector)}`] : []),
+                ...(interaction.annotation ? [`annotation: '${interaction.annotation}'`] : []),
+                ...(((_e = interaction.waitForConfig) === null || _e === void 0 ? void 0 : _e.pollingInterval) ? [`pollingInterval: ${(_f = interaction.waitForConfig) === null || _f === void 0 ? void 0 : _f.pollingInterval}`] : []),
+                ...(((_g = interaction.waitForConfig) === null || _g === void 0 ? void 0 : _g.timeout) ? [`timeout: ${(_h = interaction.waitForConfig) === null || _h === void 0 ? void 0 : _h.timeout}`] : []),
+                // Always include totpConfig for GEN_TOTP actions, using defaults if not present in interaction
+                ...(interaction.action === PlaywrightAction.GEN_TOTP ? [`totpConfig: { digits: ${((_j = interaction.totpConfig) === null || _j === void 0 ? void 0 : _j.digits) || 6}, algorithm: '${((_k = interaction.totpConfig) === null || _k === void 0 ? void 0 : _k.algorithm) || 'SHA1'}' }`] : [])
+            ];
+            return `${comment}
+        await test.step("${escapedStepName}", async () => {
+          await ppw.runStep({
+            ${args.join(',\n            ')}
+          });
+        });`;
+        case PlaywrightAction.EXTRACT_VALUE:
+            const extractVarName = getReturnValueParameterName(interaction);
+            return `${comment}
+        await test.step("${escapedStepName}", async () => {
+          const ${extractVarName} = await ppw.runStep({
+            iframeSelector: '${iframe}',
+            elementSelector: '${selector}',
+            smartSelector: ${JSON.stringify(smartSelector)},
+            smartIFrameSelector: ${JSON.stringify(smartIFrameSelector)},
+            action: '${interaction.action}',          
+            annotation: '${(_l = interaction.annotation) !== null && _l !== void 0 ? _l : ""}',
+          });
+          param['${extractVarName}'] = ${extractVarName};
+        });`;
+        case PlaywrightAction.EXECUTE_SCRIPT:
+            return generateExecuteScriptCode(interaction, comment, escapedStepName);
+        default:
+            return `// Unhandled action: ${interaction.action}!!!`;
+    }
+}
+function interactionToProboLib(interaction) {
+    var _a, _b, _c;
+    const escapedPrompt = (_c = (_b = (_a = interaction.serverResponse) === null || _a === void 0 ? void 0 : _a.result) === null || _b === void 0 ? void 0 : _b.prompt) === null || _c === void 0 ? void 0 : _c.replace(/'/g, "\\'");
+    const argument = isParameterizable(interaction) ? `param.${interaction.parameterName}` : `'${interaction.argument}'`;
+    // Escape the nativeDescription for use in test.step() string literal
+    const escapedStepName = interaction.nativeDescription.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    const comment = `
+        // ${interaction.nativeDescription}${interaction.annotation ? `\n        // annotation: ${interaction.annotation}` : ''}`;
+    if (interaction.action === PlaywrightAction.EXTRACT_VALUE) {
+        const extractVarName = getReturnValueParameterName(interaction);
+        return `${comment}
+      await test.step("${escapedStepName}", async () => {
+        const ${extractVarName} = await probo.runStep(page, '${escapedPrompt}', null, { stepId: ${interaction.stepId} });
+        param['${extractVarName}'] = ${extractVarName};
+      });`;
+    }
+    else if (interaction.action === PlaywrightAction.ASSERT_CONTAINS_VALUE ||
+        interaction.action === PlaywrightAction.ASSERT_EXACT_VALUE) {
+        return `${comment}
+      await test.step("${escapedStepName}", async () => {
+        await probo.runStep(page, '${escapedPrompt}', ${argument}, { stepId: ${interaction.stepId} });
+      });`;
+    }
+    else if (interaction.action === PlaywrightAction.VISIT_URL) {
+        return `${comment}
+      await test.step("${escapedStepName}", async () => {
+        await probo.runStep(page, '${interaction.nativeDescription}', ${argument}, { stepId: ${interaction.stepId} });
+      });`;
+    }
+    else if (interaction.action === PlaywrightAction.ASK_AI) {
+        const escapedQuestion = interaction.nativeDescription.replace(/'/g, "\\'");
+        const aiVarName = getReturnValueParameterName(interaction);
+        // const assertion = interaction.argument ? `    
+        const askAIOptions = interaction.stepId ? `{ stepId: ${interaction.stepId} }` : '{}';
+        return `${comment}
+        await test.step("${escapedStepName}", async () => {
+          const ${aiVarName} = await probo.askAI(page, '${escapedQuestion}', ${askAIOptions}${argument ? `, ${argument}` : ''});
+          param['${aiVarName}'] = ${aiVarName};
+        });`;
+    }
+    else if (interaction.action === PlaywrightAction.EXECUTE_SCRIPT) {
+        return generateExecuteScriptCode(interaction, comment, escapedStepName);
+    }
+    else {
+        return `${comment}
+      await test.step("${escapedStepName}", async () => {
+        ${argument ? `await probo.runStep(page, '${escapedPrompt}', ${argument}, { stepId: ${interaction.stepId} });` : `await probo.runStep(page, '${escapedPrompt}', null, { stepId: ${interaction.stepId} });`}
+      });`;
+    }
+}
+function generateExecuteScriptCode(interaction, comment, escapedStepName) {
+    let scriptCode = Array.isArray(interaction.argument) ? interaction.argument[0] : interaction.argument;
+    const scriptVarName = getReturnValueParameterName(interaction);
+    // Replace returnValue(x) with 'const param = x;'
+    scriptCode = scriptCode.replace(/returnValue\((.*)\);?/, `${scriptVarName} = $1;`);
+    // Trim trailing whitespace
+    scriptCode = scriptCode.trimEnd();
+    // If scriptCode doesn't end with a semicolon add one
+    if (!/\s*;\s*$/.test(scriptCode))
+        scriptCode = scriptCode + ';';
+    // Indent the code (extra indent for test.step wrapper)
+    const indentedCode = scriptCode.split('\n').map((line, idx) => idx === 0 ? line : `            ${line}`).join('\n');
+    return `${comment}
+        await test.step("${escapedStepName}", async () => {
+          let ${scriptVarName} = null;
+          try {
+            ${indentedCode}
+          } catch (error) {
+            console.error('❌ Workspace script execution failed:', error.message);
+            throw error;
+          }
+          param['${scriptVarName}'] = ${scriptVarName};
+        });`;
+}
+function scriptTemplate(options, settings, viewPort) {
+    var _a, _b, _c, _d;
+    const areActionsParameterized = options.rows.length > 0;
+    const hasAiInteractions = options.interactions.some((interaction) => isAI(interaction));
+    const hasScriptInteractions = options.interactions.some((interaction) => interaction.action === PlaywrightAction.EXECUTE_SCRIPT);
+    // const uniquelyParameterizedInteractions = uniquifyInteractionParameters(options.interactions);
+    const steps = options.interactions.map((interaction) => {
+        if (isAI(interaction))
+            return interactionToProboLib(interaction);
+        return interactionToNativeCode(interaction);
+    }).join('\n');
+    // Get list of all extracted value parameter names to filter them out from the parameter table
+    const extractedValueNames = new Set();
+    options.interactions.forEach((interaction) => {
+        if (hasReturnValue(interaction)) {
+            const retName = getReturnValueParameterName(interaction);
+            if (retName) {
+                extractedValueNames.add(retName);
+            }
+        }
+    });
+    // Escape apostrophes and backslashes for single-quoted strings
+    const escapeForSingleQuotes = (value) => {
+        if (!value || typeof value !== 'string')
+            return ''; //check for null, undefined, or non-string values
+        //escape backslashes and single quotes
+        return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+    };
+    // Lookup value from settings  
+    const aiModelKey = Object.keys(AIModel).find(key => AIModel[key] === settings.aiModel);
+    // Check if any interactions have the isSecret flag set
+    const hasSecrets = options.interactions.some(interaction => interaction.isSecret === true);
+    // Extract required environment variable names from parameter table rows
+    const requiredEnvVars = extractRequiredEnvVars(options.rows);
+    const requiredEnvVarsArray = Array.from(requiredEnvVars).sort();
+    // generate the parameter table (exclude extracted values as they are declared as const in the steps)
+    const parameterTable = areActionsParameterized ? `
+  const parameterTable: Record<string, any>[] = [
+    ${options.rows.map((row) => {
+        // Filter out extracted value columns from the parameter table
+        const filteredRow = Object.fromEntries(Object.entries(row).filter(([key]) => !extractedValueNames.has(key)));
+        return `{ ${Object.entries(filteredRow).map(([key, value]) => `${key}: '${escapeForSingleQuotes(value)}'`).join(', ')} }`;
+    }).join(',\n    ')}
+  ];
+  ` : '';
+    const proboConstructor = hasAiInteractions ? `
+  const probo = new Probo({
+    scenarioName: '${options.scenarioName}',
+    enableSmartSelectors: ${settings.enableSmartSelectors},
+    debugLevel: ProboLogLevel.${settings.debugLevel},
+    aiModel: AIModel.${aiModelKey},
+    timeoutConfig: {
+      waitForStabilityQuietTimeout: ${(_a = settings.waitForStabilityQuietTimeout) !== null && _a !== void 0 ? _a : 2000},
+      waitForStabilityInitialDelay: ${(_b = settings.waitForStabilityInitialDelay) !== null && _b !== void 0 ? _b : 500},
+      waitForStabilityGlobalTimeout: ${(_c = settings.waitForStabilityGlobalTimeout) !== null && _c !== void 0 ? _c : 15000},
+      waitForStabilityVerbose: ${(_d = settings.waitForStabilityVerbose) !== null && _d !== void 0 ? _d : false}
+    }
+  });` : '';
+    return `
+  /*
+   * Probo Labs Playwright Script
+   * Scenario: ${options.scenarioName}
+   * Auto generated on ${new Date().toLocaleDateString()} ${new Date().toLocaleTimeString()}
+   * 
+   * HOW TO INTEGRATE THIS SCRIPT INTO YOUR EXISTING PROJECT:
+  * 1. Install dependencies: npm install @playwright/test @probolabs/playwright@latest${hasSecrets ? ' dotenv' : ''}
+  * 2. copy and paste the code below into your test file${hasSecrets ? '\n   * 3. Ensure a .env file exists in your project root (or ~/.probium/.env) or set environment variables manually' : ''}
+   */
+  
+  // launch chromium with pre-installed extensions
+  import { test, expect} from '@probolabs/playwright/fixtures';
+  import { ProboPlaywright, Probo, PlaywrightAction, ProboLogLevel, AIModel } from '@probolabs/playwright';${hasScriptInteractions ? `
+  import { execSync } from 'child_process';
+  import * as fs from 'fs';
+  import * as path from 'path';
+  import * as os from 'os';` : ''}${hasSecrets && !hasScriptInteractions ? `
+  import * as path from 'path';
+  import * as os from 'os';
+  import * as fs from 'fs';` : ''}
+  
+${hasSecrets ? `import { config } from 'dotenv';
+  // Load secrets: first try local .env (project root), then fallback to ~/.probium/.env
+  const localEnvPath = path.join(process.cwd(), '.env');
+  const homeEnvPath = path.join(os.homedir(), '.probium', '.env');
+  
+  if (fs.existsSync(localEnvPath)) {
+    config({ path: localEnvPath });
+    console.log('✅ Loaded env vars from project .env:', localEnvPath);
+  } else if (fs.existsSync(homeEnvPath)) {
+    config({ path: homeEnvPath });
+    console.log('✅ Loaded env vars from home .env:', homeEnvPath);
+  } else {
+    console.warn('⚠️ .env not found at', localEnvPath, 'or', homeEnvPath, '- ensure environment variables are set before running tests');
+  }
+  
+  // Validate that all required secrets are set
+  const requiredSecrets: string[] = ${JSON.stringify(requiredEnvVarsArray)};
+  const missingSecrets = requiredSecrets.filter(varName => !process.env[varName] || process.env[varName].trim() === '');
+  if (missingSecrets.length > 0) {
+    throw new Error(\`Missing required environment variables: \${missingSecrets.join(', ')}. Please set them in your .env file or as environment variables.\`);
+  }
+  console.log(\`✅ All required secrets are set: \${requiredSecrets.join(', ')}\`);
+  ` : ''}
+  
+  ${parameterTable}    
+  ${proboConstructor}
+  const ppw = new ProboPlaywright({
+        enableSmartSelectors: ${settings.enableSmartSelectors},
+        debugLevel: ProboLogLevel.${settings.debugLevel},
+        timeoutConfig: {
+          waitForStabilityQuietTimeout: ${settings.waitForStabilityQuietTimeout},
+          waitForStabilityInitialDelay: ${settings.waitForStabilityInitialDelay},
+          waitForStabilityGlobalTimeout: ${settings.waitForStabilityGlobalTimeout},
+          waitForStabilityVerbose: ${settings.waitForStabilityVerbose},
+          highlightTimeout: ${settings.highlightTimeout},
+          playwrightActionTimeout: ${settings.playwrightActionTimeout},
+          playwrightNavigationTimeout: ${settings.playwrightNavigationTimeout},
+          playwrightLocatorTimeout: ${settings.playwrightLocatorTimeout}
+        }
+    });
+
+  test.describe('${options.scenarioName}', () => {
+    test.beforeEach(async ({ page }) => {
+      // set the ProboPlaywright instance to the current page
+      ppw.setPage(page);      
+      // set the viewport dimensions to be identical to their values during recording
+      await page.setViewportSize({ width: ${viewPort.width}, height: ${viewPort.height} });
+    });
+
+    for (const param of parameterTable) {
+      test(param.testName, async ({ page }) => {
+        ${hasAiInteractions ? `probo.setParams(param);` : ''}
+        ppw.setParams(param);
+        ${steps}
+      });
+    }
+  });
+  `;
+}
+/**
+ * Generates Playwright code for a scenario
+ * @param options - Code generation options (scenarioName, interactions, rows)
+ * @param settings - Recorder settings (timeouts, AI model, etc.)
+ * @param viewPort - Viewport dimensions {width, height}
+ * @returns Generated Playwright test code as a string
+ */
+function generateCode(options, settings, viewPort) {
+    return scriptTemplate(options, settings, viewPort);
+}
+/**
+ * Generate package.json content for a Playwright test project
+ */
+function generatePackageJson(options) {
+    const { name, hasSecrets = false, testScript = 'npx playwright test' } = options;
+    return `{
+  "name": "${name}",
+  "version": "1.0.0",
+  "description": "Probo Labs Playwright Script",
+  "type": "module",
+  "scripts": {
+    "test": "${testScript}"
+  },
+  "dependencies": {
+    "@playwright/test": "^1.40.0",
+    "@probolabs/playwright": "latest"${hasSecrets ? ',\n    "dotenv": "latest"' : ''}
+  }
+}`;
+}
+/**
+ * Generate playwright.config.ts content
+ */
+function generatePlaywrightConfig(includeReporter = true, runId) {
+    const reporters = [
+        ['list'],
+        ['html', { open: 'never' }],
+    ];
+    // Configure run-specific output directories if runId is provided
+    if (runId !== undefined) {
+        reporters[1] = ['html', { open: 'never', outputFolder: `playwright-report/run-${runId}` }];
+    }
+    if (includeReporter) {
+        reporters.push(['./probo-reporter.ts']);
+    }
+    // Configure outputDir for run-specific test results if runId is provided
+    const outputDirConfig = runId !== undefined ? `\n  outputDir: 'test-results/run-${runId}',` : '';
+    return `import { defineConfig } from '@playwright/test';
+
+export default defineConfig({
+  testDir: 'tests',
+  testMatch: /.*\\.(ts|js)$/,
+  timeout: 600000,${outputDirConfig}
+  // Keep Playwright's default console output, plus HTML report${includeReporter ? ', plus Probo live progress reporter' : ''}.
+  reporter: ${JSON.stringify(reporters)},
+  use: {
+    headless: true,
+    ignoreHTTPSErrors: true,
+    actionTimeout: 30000,
+    navigationTimeout: 30000,
+    video: 'off',
+    screenshot: 'on',
+    trace: 'on',
+  },
+  retries: 0,
+  workers: 1,
+});
+`;
+}
+/**
+ * Generate a Playwright reporter that emits structured events to stdout.
+ *
+ * The recorder app runner can parse these lines and broadcast them to the UI.
+ */
+function generateProboReporter() {
+    // NOTE: Keep this file dependency-free; it runs inside the generated test suite project.
+    // It prints one JSON payload per line, prefixed for easy extraction from stdout.
+    return `import type { Reporter, FullConfig, Suite, TestCase, TestResult, TestStep } from '@playwright/test/reporter';
+
+const PREFIX = '__PROBO_REPORTER_EVENT__';
+
+type ProboReporterEvent =
+  | {
+      v: 1;
+      ts: number;
+      eventType: 'runBegin';
+      config: { workers: number; retries: number; projects: string[] };
+    }
+  | {
+      v: 1;
+      ts: number;
+      eventType: 'runEnd';
+      status: 'passed' | 'failed' | 'timedout' | 'interrupted';
+    }
+  | {
+      v: 1;
+      ts: number;
+      eventType: 'testBegin';
+      test: ProboTestRef;
+    }
+  | {
+      v: 1;
+      ts: number;
+      eventType: 'testEnd';
+      test: ProboTestRef;
+      result: {
+        status: 'passed' | 'failed' | 'timedout' | 'skipped' | 'interrupted';
+        expectedStatus: 'passed' | 'failed' | 'timedout' | 'skipped';
+        duration: number;
+        errors: string[];
+      };
+    }
+  | {
+      v: 1;
+      ts: number;
+      eventType: 'stepBegin';
+      test: ProboTestRef;
+      step: ProboStepRef & { title: string; category?: string; depth: number };
+    }
+  | {
+      v: 1;
+      ts: number;
+      eventType: 'stepEnd';
+      test: ProboTestRef;
+      step: ProboStepRef & { duration?: number; error?: string | null };
+    };
+
+type ProboLocation = { file?: string; line?: number; column?: number };
+type ProboTestRef = {
+  id?: string;
+  title: string;
+  titlePath: string[];
+  location?: ProboLocation;
+};
+type ProboStepRef = {
+  id: number;
+  location?: ProboLocation;
+};
+
+function safeLocation(loc: any): ProboLocation | undefined {
+  if (!loc || typeof loc !== 'object') return undefined;
+  const file = typeof loc.file === 'string' ? loc.file : undefined;
+  const line = typeof loc.line === 'number' ? loc.line : undefined;
+  const column = typeof loc.column === 'number' ? loc.column : undefined;
+  return file || line || column ? { file, line, column } : undefined;
+}
+
+function safeTitlePath(test: TestCase): string[] {
+  try {
+    // titlePath() exists on TestCase and includes describe blocks.
+    return test.titlePath();
+  } catch {
+    return [test.title];
+  }
+}
+
+function testRef(test: TestCase): ProboTestRef {
+  return {
+    // @ts-expect-error: Playwright has test.id at runtime; keep optional for forward/back compat.
+    id: (test as any).id,
+    title: test.title,
+    titlePath: safeTitlePath(test),
+    location: safeLocation((test as any).location),
+  };
+}
+
+function serializeErrors(result: TestResult): string[] {
+  const errors: any[] = (result as any).errors || [];
+  if (!Array.isArray(errors)) return [];
+  return errors
+    .map((e) => {
+      if (!e) return null;
+      if (typeof e === 'string') return e;
+      if (typeof e.message === 'string') return e.message;
+      if (typeof e.value === 'string') return e.value;
+      try {
+        return JSON.stringify(e);
+      } catch {
+        return String(e);
+      }
+    })
+    .filter(Boolean) as string[];
+}
+
+function emit(event: ProboReporterEvent) {
+  try {
+    process.stdout.write(PREFIX + JSON.stringify(event) + '\\n');
+  } catch {
+    // Ignore reporter failures; never break the run.
+  }
+}
+
+/**
+ * Check if a step should be included in the output.
+ * Filters out hooks, fixtures, and internal Playwright operations.
+ */
+function shouldIncludeStep(step: TestStep): boolean {
+  const category = (step as any).category;
+  const title = step.title?.toLowerCase() || '';
+  
+  // Filter out hooks (beforeAll, beforeEach, afterAll, afterEach)
+  if (category === 'hook') {
+    return false;
+  }
+  
+  // Filter out fixtures
+  if (category === 'fixture') {
+    return false;
+  }
+  
+  // Filter out internal waiting/timeout operations
+  if (title.includes('waiting for') || 
+      title.includes('wait for') ||
+      title.includes('timeout') ||
+      title.includes('attaching') ||
+      title.startsWith('attach')) {
+    return false;
+  }
+  
+  // Include user-defined steps and assertions only (exclude pw:api like click, evaluate, etc.)
+  return category === 'test.step' || 
+         category === 'expect' ||
+         !category; // Include steps without category (likely user actions)
+}
+
+export default class ProboReporter implements Reporter {
+  private stepIds = new WeakMap<TestStep, number>();
+  private stepDepths = new WeakMap<TestStep, number>();
+  private nextStepId = 1;
+
+  onBegin(config: FullConfig, suite: Suite) {
+    emit({
+      v: 1,
+      ts: Date.now(),
+      eventType: 'runBegin',
+      config: {
+        workers: config.workers,
+        retries: config.retries,
+        projects: (config.projects || []).map((p) => p.name || 'project'),
+      },
+    });
+  }
+
+  onEnd(result: any) {
+    emit({
+      v: 1,
+      ts: Date.now(),
+      eventType: 'runEnd',
+      status: result?.status || 'failed',
+    });
+  }
+
+  onTestBegin(test: TestCase, result: TestResult) {
+    emit({
+      v: 1,
+      ts: Date.now(),
+      eventType: 'testBegin',
+      test: testRef(test),
+    });
+  }
+
+  onTestEnd(test: TestCase, result: TestResult) {
+    emit({
+      v: 1,
+      ts: Date.now(),
+      eventType: 'testEnd',
+      test: testRef(test),
+      result: {
+        status: result.status,
+        expectedStatus: result.expectedStatus,
+        duration: result.duration,
+        errors: serializeErrors(result),
+      },
+    });
+  }
+
+  onStepBegin(test: TestCase, result: TestResult, step: TestStep) {
+    // Filter out hooks, fixtures, and internal operations
+    if (!shouldIncludeStep(step)) {
+      return;
+    }
+
+    const id = this.stepIds.get(step) ?? this.nextStepId++;
+    this.stepIds.set(step, id);
+
+    const depth = this.stepDepths.get(step) ?? (step.parent ? (this.stepDepths.get(step.parent) ?? 0) + 1 : 0);
+    this.stepDepths.set(step, depth);
+
+    emit({
+      v: 1,
+      ts: Date.now(),
+      eventType: 'stepBegin',
+      test: testRef(test),
+      step: {
+        id,
+        title: step.title,
+        category: (step as any).category,
+        depth,
+        location: safeLocation((step as any).location),
+      },
+    });
+  }
+
+  onStepEnd(test: TestCase, result: TestResult, step: TestStep) {
+    // Filter out hooks, fixtures, and internal operations
+    if (!shouldIncludeStep(step)) {
+      return;
+    }
+
+    const id = this.stepIds.get(step) ?? this.nextStepId++;
+    this.stepIds.set(step, id);
+
+    const err = (step as any).error;
+    emit({
+      v: 1,
+      ts: Date.now(),
+      eventType: 'stepEnd',
+      test: testRef(test),
+      step: {
+        id,
+        duration: (step as any).duration,
+        error: err ? (typeof err.message === 'string' ? err.message : String(err)) : null,
+        location: safeLocation((step as any).location),
+      },
+    });
+  }
+}
+`;
+}
+
+// --- Code generation API utilities for Probo Labs Playwright scripts ---
+/**
+ * ProboCodeGenerator - Handles fetching test suite/scenario data and generating Playwright code
+ */
+class ProboCodeGenerator {
+    /**
+     * Normalize API URL by removing trailing slash
+     */
+    static normalizeApiUrl(apiUrl) {
+        return apiUrl.replace(/\/+$/, '');
+    }
+    static async readResponseErrorText(response) {
+        try {
+            const contentType = response.headers.get('content-type');
+            if (contentType && contentType.includes('application/json')) {
+                const errorData = await response.json();
+                return errorData.error || errorData.detail || JSON.stringify(errorData);
+            }
+            let errorText = await response.text();
+            // Truncate HTML error pages to first 200 chars
+            if (errorText.length > 200) {
+                errorText = errorText.substring(0, 200) + '...';
+            }
+            return errorText;
+        }
+        catch (e) {
+            // Best-effort fallback
+            return `HTTP ${response.status}`;
+        }
+    }
+    /**
+     * Fetch scenario data from the backend API
+     */
+    static async fetchScenarioData(scenarioId, apiToken, apiUrl) {
+        const normalizedUrl = this.normalizeApiUrl(apiUrl);
+        const url = `${normalizedUrl}/api/scenarios/${scenarioId}/interactions`;
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Token ${apiToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            const errorText = await this.readResponseErrorText(response);
+            throw new Error(`Failed to fetch scenario ${scenarioId}: ${response.status} ${errorText}`);
+        }
+        return response.json();
+    }
+    /**
+     * Fetch test suite data from the backend API
+     */
+    static async fetchTestSuiteData(testSuiteId, apiToken, apiUrl) {
+        const normalizedUrl = this.normalizeApiUrl(apiUrl);
+        // Note: test-suites endpoint doesn't have /api/ prefix (it's from the router at root level)
+        const url = `${normalizedUrl}/test-suites/${testSuiteId}/`;
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Token ${apiToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            const errorText = await this.readResponseErrorText(response);
+            throw new Error(`Failed to fetch test suite ${testSuiteId}: ${response.status} ${errorText}`);
+        }
+        return response.json();
+    }
+    /**
+     * Convert backend interaction format to Interaction[] format
+     */
+    static convertBackendInteractionsToInteractionFormat(backendInteractions) {
+        return backendInteractions.map((backendInteraction) => {
+            // Convert action string to PlaywrightAction enum
+            const action = backendInteraction.action;
+            // Convert apply_ai_status string to enum if present
+            let applyAiStatus = null;
+            if (backendInteraction.apply_ai_status) {
+                applyAiStatus = backendInteraction.apply_ai_status;
+            }
+            // Build elementInfo from backend data
+            const elementInfo = backendInteraction.elementInfo || null;
+            // Build interaction object
+            const interaction = {
+                interactionId: backendInteraction.interactionId,
+                action: action,
+                argument: backendInteraction.argument || '',
+                elementInfo: elementInfo,
+                iframe_selector: backendInteraction.iframe_selector,
+                css_selector: backendInteraction.css_selector,
+                smart_selector: backendInteraction.smart_selector || undefined,
+                smart_iframe_selector: backendInteraction.smart_iframe_selector || undefined,
+                url: backendInteraction.url,
+                timestamp: backendInteraction.last_replay_timestamp || Date.now(),
+                base_screenshot_url: backendInteraction.base_screenshot_url,
+                actual_interaction_screenshot_url: backendInteraction.actual_interaction_screenshot_url,
+                candidates_screenshot_url: backendInteraction.candidates_screenshot_url,
+                candidate_elements: backendInteraction.candidate_elements || [],
+                recordingId: backendInteraction.recordingId,
+                syncStatus: backendInteraction.syncStatus,
+                serverResponse: backendInteraction.serverResponse || null,
+                nativeName: backendInteraction.nativeName,
+                nativeDescription: backendInteraction.nativeDescription,
+                isNativeDescriptionElaborate: backendInteraction.isNativeDescriptionElaborate,
+                parameterName: backendInteraction.parameterName,
+                annotation: backendInteraction.annotation,
+                last_replay_timestamp: backendInteraction.last_replay_timestamp,
+                replay_status: backendInteraction.replay_status,
+                apply_ai_status: applyAiStatus,
+                error: null,
+                index: backendInteraction.index,
+                html: backendInteraction.html,
+                stepId: backendInteraction.stepId,
+                scrollableContainers: backendInteraction.scrollableContainers,
+                stdout: undefined,
+                waitForConfig: backendInteraction.waitForConfig,
+                totpConfig: backendInteraction.totpConfig,
+                isSecret: backendInteraction.isSecret || false,
+            };
+            return interaction;
+        });
+    }
+    /**
+     * Get default recorder settings for code generation
+     */
+    static getDefaultRecorderSettings() {
+        return {
+            ...DEFAULT_RECORDER_SETTINGS,
+            // Override with sensible defaults for code generation
+            enableSmartSelectors: true,
+            debugLevel: 'INFO',
+            enableConsoleLogs: false,
+        };
+    }
+    /**
+     * Get default viewport dimensions
+     */
+    static getDefaultViewPort() {
+        return { width: 1280, height: 720 };
+    }
+    /**
+     * Generate code for a single scenario
+     * Fetches scenario data, converts to Interaction[], generates code
+     */
+    static async generateCodeForScenario(scenarioId, apiToken, apiUrl, options) {
+        // Validate inputs
+        if (!apiToken) {
+            throw new Error('API token is required');
+        }
+        if (!apiUrl) {
+            throw new Error('API URL is required');
+        }
+        // Fetch scenario data
+        const scenarioData = await this.fetchScenarioData(scenarioId, apiToken, apiUrl);
+        // Convert backend interactions to Interaction[] format
+        const interactions = this.convertBackendInteractionsToInteractionFormat(scenarioData.interactions || []);
+        // Get settings and viewport
+        const settings = (options === null || options === void 0 ? void 0 : options.recorderSettings) || this.getDefaultRecorderSettings();
+        const viewPort = (options === null || options === void 0 ? void 0 : options.viewPort) || scenarioData.viewPort || this.getDefaultViewPort();
+        // Get parameter table rows
+        const rows = scenarioData.parameterTable || [];
+        // Generate code
+        const codeOptions = {
+            scenarioName: scenarioData.name,
+            interactions: interactions,
+            rows: rows,
+        };
+        return generateCode(codeOptions, settings, viewPort);
+    }
+    /**
+     * Generate code for all scenarios in a test suite
+     * Returns map of scenario names to generated code
+     */
+    static async generateCodeForTestSuite(testSuiteId, apiToken, apiUrl, options) {
+        // Validate inputs
+        if (!apiToken) {
+            throw new Error('API token is required');
+        }
+        if (!apiUrl) {
+            throw new Error('API URL is required');
+        }
+        // Fetch test suite data
+        const testSuiteData = await this.fetchTestSuiteData(testSuiteId, apiToken, apiUrl);
+        // Generate code for each scenario
+        const scenarioResults = await Promise.all(testSuiteData.scenarios.map(async (scenario) => {
+            try {
+                const code = await this.generateCodeForScenario(scenario.id, apiToken, apiUrl, options);
+                return {
+                    scenarioId: scenario.id,
+                    scenarioName: scenario.name,
+                    code: code,
+                };
+            }
+            catch (error) {
+                // Log error but continue with other scenarios
+                console.error(`Failed to generate code for scenario ${scenario.id}: ${error.message}`);
+                throw error; // Re-throw to fail fast for now
+            }
+        }));
+        return {
+            testSuiteId: testSuiteData.id,
+            testSuiteName: testSuiteData.name,
+            scenarios: scenarioResults,
+        };
+    }
+}
+
+const execAsync = promisify(exec);
+/**
+ * Ensures a directory exists, creating it recursively if needed
+ */
+function ensureDirectoryExists(dir) {
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+/**
+ * Gets the default test suite directory path
+ */
+function getDefaultTestSuiteDir(testSuiteId, testSuiteName) {
+    const baseDir = path.join(os.homedir(), '.probium', 'test-suites');
+    if (testSuiteName) {
+        const sanitizedName = slugify(testSuiteName);
+        return path.join(baseDir, `${testSuiteId}-${sanitizedName}`);
+    }
+    return path.join(baseDir, testSuiteId.toString());
+}
+/**
+ * Count total tests by scanning spec files
+ */
+function countTotalTests(testSuiteDir) {
+    const testsDir = path.join(testSuiteDir, 'tests');
+    if (!fs.existsSync(testsDir)) {
+        return 0;
+    }
+    let totalTests = 0;
+    const specFiles = fs.readdirSync(testsDir).filter(f => f.endsWith('.spec.ts'));
+    for (const specFile of specFiles) {
+        const filePath = path.join(testsDir, specFile);
+        const content = fs.readFileSync(filePath, 'utf-8');
+        // Count test() and it() calls
+        const testMatches = content.match(/\btest\s*\(/g);
+        const itMatches = content.match(/\bit\s*\(/g);
+        if (testMatches)
+            totalTests += testMatches.length;
+        if (itMatches)
+            totalTests += itMatches.length;
+        // If no matches, assume at least 1 test per file
+        if (!testMatches && !itMatches) {
+            totalTests += 1;
+        }
+    }
+    return totalTests;
+}
+/**
+ * Parse Playwright statistics from stdout
+ */
+function parsePlaywrightStatistics(stdout) {
+    // Try to find final summary line: "X passed" or "X passed, Y failed" etc.
+    const summaryMatch = stdout.match(/(\d+)\s+passed(?:,\s*(\d+)\s+failed)?(?:,\s*(\d+)\s+skipped)?/);
+    if (summaryMatch) {
+        return {
+            passed: parseInt(summaryMatch[1]) || 0,
+            failed: parseInt(summaryMatch[2]) || 0,
+            skipped: parseInt(summaryMatch[3]) || 0,
+        };
+    }
+    // Fallback: count individual test results
+    const passed = (stdout.match(/✓/g) || []).length;
+    const failed = (stdout.match(/✘/g) || []).length;
+    const skipped = (stdout.match(/-\s+test/g) || []).length;
+    return { passed, failed, skipped };
+}
+/**
+ * Parse statistics from Playwright HTML report metadata (most reliable)
+ */
+function parseStatisticsFromMetadata(testSuiteDir) {
+    try {
+        const reportDir = path.join(testSuiteDir, 'playwright-report');
+        const metadataPath = path.join(reportDir, 'data', 'metadata.json');
+        if (!fs.existsSync(metadataPath)) {
+            return null;
+        }
+        const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
+        return {
+            passed: metadata.passed || 0,
+            failed: metadata.failed || 0,
+            skipped: metadata.skipped || 0,
+        };
+    }
+    catch (error) {
+        console.warn('⚠️ Could not parse metadata.json:', error);
+        return null;
+    }
+}
+/**
+ * Update run status via API
+ */
+async function updateRunStatus(runId, testSuiteId, updates, apiToken, apiUrl) {
+    // Ensure apiUrl doesn't have trailing slash
+    const baseUrl = apiUrl.endsWith('/') ? apiUrl.slice(0, -1) : apiUrl;
+    const url = `${baseUrl}/test-suites/${testSuiteId}/runs/${runId}/`;
+    const body = JSON.stringify(updates);
+    const headers = {
+        'Authorization': `Token ${apiToken}`,
+        'Content-Type': 'application/json',
+    };
+    try {
+        const response = await fetch$1(url, {
+            method: 'PATCH',
+            headers: headers,
+            body: body,
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.warn(`⚠️ Failed to update run status: ${response.status} ${errorText}`);
+        }
+    }
+    catch (error) {
+        console.error(`❌ Error updating run status:`, error);
+    }
+}
+/**
+ * TestSuiteRunner - Handles test suite file generation and execution
+ */
+class TestSuiteRunner {
+    /**
+     * Lookup test suite ID by name and project
+     */
+    static async lookupTestSuiteByName(testSuiteName, projectName, apiToken, apiUrl) {
+        const baseUrl = apiUrl.endsWith('/') ? apiUrl.slice(0, -1) : apiUrl;
+        const url = `${baseUrl}/test-suites/?name=${encodeURIComponent(testSuiteName)}&project=${encodeURIComponent(projectName)}`;
+        const response = await fetch$1(url, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Token ${apiToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to lookup test suite: ${response.status} ${errorText}`);
+        }
+        const data = await response.json();
+        if (Array.isArray(data) && data.length > 0) {
+            return data[0].id;
+        }
+        if (data.results && Array.isArray(data.results) && data.results.length > 0) {
+            return data.results[0].id;
+        }
+        throw new Error(`Test suite "${testSuiteName}" not found in project "${projectName}"`);
+    }
+    /**
+     * Generate all files for a test suite
+     */
+    static async generateTestSuiteFiles(testSuiteId, apiToken, apiUrl, outputDir, testSuiteName, includeReporter = true, runId) {
+        const testSuiteDir = outputDir || getDefaultTestSuiteDir(testSuiteId, testSuiteName);
+        // Generate code for all scenarios
+        const codeGenResult = await ProboCodeGenerator.generateCodeForTestSuite(testSuiteId, apiToken, apiUrl);
+        // Ensure directories exist
+        ensureDirectoryExists(testSuiteDir);
+        const testsDir = path.join(testSuiteDir, 'tests');
+        ensureDirectoryExists(testsDir);
+        // Save each scenario's code to a .spec.ts file
+        for (const scenario of codeGenResult.scenarios) {
+            const fileName = `${slugify(scenario.scenarioName)}.spec.ts`;
+            const filePath = path.join(testsDir, fileName);
+            fs.writeFileSync(filePath, scenario.code, 'utf-8');
+            console.log(`✅ Generated test file: ${filePath}`);
+        }
+        // Generate package.json
+        await this.generatePackageJson(testSuiteDir, codeGenResult);
+        // Generate playwright.config.ts with runId if available
+        await this.generatePlaywrightConfig(testSuiteDir, includeReporter, runId);
+        // Generate custom reporter file for live progress streaming (only if requested)
+        if (includeReporter) {
+            await this.generateProboReporter(testSuiteDir);
+        }
+    }
+    /**
+     * Generate package.json file
+     */
+    static async generatePackageJson(outputDir, codeGenResult) {
+        // Check if any scenario has secrets by examining the generated code
+        // We'll check for dotenv imports in the generated code
+        const hasSecrets = codeGenResult.scenarios.some(scenario => scenario.code.includes("import { config } from 'dotenv'"));
+        const sanitizedName = slugify(codeGenResult.testSuiteName);
+        const packageJsonContent = generatePackageJson({
+            name: sanitizedName,
+            hasSecrets: hasSecrets,
+            testScript: 'npx playwright test'
+        });
+        const filePath = path.join(outputDir, 'package.json');
+        fs.writeFileSync(filePath, packageJsonContent, 'utf-8');
+        console.log(`✅ Generated package.json: ${filePath}`);
+    }
+    /**
+     * Generate playwright.config.ts file
+     */
+    static async generatePlaywrightConfig(outputDir, includeReporter = true, runId) {
+        const configContent = generatePlaywrightConfig(includeReporter, runId);
+        const filePath = path.join(outputDir, 'playwright.config.ts');
+        fs.writeFileSync(filePath, configContent, 'utf-8');
+        console.log(`✅ Generated playwright.config.ts: ${filePath}`);
+    }
+    /**
+     * Generate Probo custom Playwright reporter (for live step/test events)
+     */
+    static async generateProboReporter(outputDir) {
+        const reporterContent = generateProboReporter();
+        const filePath = path.join(outputDir, 'probo-reporter.ts');
+        fs.writeFileSync(filePath, reporterContent, 'utf-8');
+        console.log(`✅ Generated probo-reporter.ts: ${filePath}`);
+    }
+    /**
+     * Run a test suite
+     * Generates files, installs dependencies, and executes tests
+     */
+    static async runTestSuite(testSuiteId, apiToken, apiUrl, testSuiteName, runId, options = {}) {
+        const { outputDir, includeReporter = true, onStatusUpdate, onStdout, onStderr, onReporterEvent, } = options;
+        const testSuiteDir = outputDir || getDefaultTestSuiteDir(testSuiteId, testSuiteName);
+        let currentRunId = runId;
+        try {
+            // Create run record if not provided (needed for run-specific report directories)
+            if (!currentRunId) {
+                try {
+                    const createResponse = await fetch$1(`${apiUrl}/test-suites/${testSuiteId}/runs/`, {
+                        method: 'POST',
+                        headers: {
+                            'Authorization': `Token ${apiToken}`,
+                            'Content-Type': 'application/json',
+                        },
+                    });
+                    if (createResponse.ok) {
+                        const runData = await createResponse.json();
+                        currentRunId = runData.id;
+                        console.log(`✅ Created test suite run: ${currentRunId}`);
+                    }
+                    else {
+                        console.warn('⚠️ Failed to create run record, continuing without tracking');
+                    }
+                }
+                catch (error) {
+                    console.warn('⚠️ Failed to create run record:', error);
+                }
+            }
+            // Generate all files (with runId if available for run-specific report directories)
+            console.log(`📝 Generating test suite files for test suite ${testSuiteId}...`);
+            await this.generateTestSuiteFiles(testSuiteId, apiToken, apiUrl, testSuiteDir, testSuiteName, includeReporter, currentRunId);
+            // Count total tests
+            const testsTotal = countTotalTests(testSuiteDir);
+            if (currentRunId && testsTotal > 0) {
+                await updateRunStatus(currentRunId, testSuiteId, { tests_total: testsTotal }, apiToken, apiUrl);
+                if (onStatusUpdate) {
+                    await onStatusUpdate({ tests_total: testsTotal });
+                }
+            }
+            // Install dependencies
+            console.log(`📦 Installing dependencies in ${testSuiteDir}...`);
+            try {
+                const { stdout: installStdout, stderr: installStderr } = await execAsync('npm install', { cwd: testSuiteDir, timeout: 300000 } // 5 minute timeout for install
+                );
+                console.log('✅ Dependencies installed successfully');
+                if (installStdout)
+                    console.log(installStdout);
+                if (installStderr)
+                    console.warn(installStderr);
+            }
+            catch (installError) {
+                console.error('❌ Failed to install dependencies:', installError);
+                const errorMsg = `Failed to install dependencies: ${installError.message}`;
+                if (currentRunId) {
+                    await updateRunStatus(currentRunId, testSuiteId, {
+                        status: 'error',
+                        exit_code: installError.code || 1,
+                        error_message: errorMsg,
+                        stderr: installError.stderr || installError.message || '',
+                    }, apiToken, apiUrl);
+                    if (onStatusUpdate) {
+                        await onStatusUpdate({
+                            status: 'error',
+                            exit_code: installError.code || 1,
+                            error_message: errorMsg,
+                            stderr: installError.stderr || installError.message || '',
+                        });
+                    }
+                }
+                return {
+                    success: false,
+                    exitCode: installError.code || 1,
+                    stdout: installError.stdout || '',
+                    stderr: installError.stderr || installError.message || '',
+                    error: errorMsg,
+                    runId: currentRunId,
+                };
+            }
+            // Run Playwright tests with streaming output
+            console.log(`🚀 Running Playwright tests in ${testSuiteDir}...`);
+            return new Promise(async (resolve) => {
+                var _a, _b;
+                let stdout = '';
+                let stderr = '';
+                let hasResolved = false;
+                let lastStatsUpdate = 0;
+                let stdoutLineBuffer = '';
+                const PROBO_REPORTER_PREFIX = '__PROBO_REPORTER_EVENT__';
+                const reporterStats = { passed: 0, failed: 0, skipped: 0 };
+                let lastReporterStatsUpdate = 0;
+                const REPORTER_STATS_UPDATE_INTERVAL = 1500; // throttle API updates from reporter events
+                const STATS_UPDATE_INTERVAL = 10000; // Update stats every 10 seconds
+                const STEPS_UPDATE_INTERVAL = 2000; // Update steps every 2 seconds
+                let lastStepsUpdate = 0;
+                const collectedSteps = [];
+                // Use spawn for streaming output
+                const testProcess = spawn('npx', ['playwright', 'test'], {
+                    cwd: testSuiteDir,
+                    shell: true,
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                // Stream stdout line by line
+                (_a = testProcess.stdout) === null || _a === void 0 ? void 0 : _a.on('data', async (data) => {
+                    var _a, _b;
+                    const chunk = data.toString();
+                    stdoutLineBuffer += chunk;
+                    // Process complete lines so we can intercept reporter events without polluting logs.
+                    const parts = stdoutLineBuffer.split(/\n/);
+                    stdoutLineBuffer = (_a = parts.pop()) !== null && _a !== void 0 ? _a : '';
+                    let forwarded = '';
+                    for (const rawLine of parts) {
+                        const line = rawLine.endsWith('\r') ? rawLine.slice(0, -1) : rawLine;
+                        if (line.startsWith(PROBO_REPORTER_PREFIX)) {
+                            const jsonPart = line.slice(PROBO_REPORTER_PREFIX.length);
+                            try {
+                                const reporterEvent = JSON.parse(jsonPart);
+                                // Call reporter event callback if provided
+                                if (onReporterEvent) {
+                                    await onReporterEvent(reporterEvent);
+                                }
+                                // Collect steps from reporter events
+                                if ((reporterEvent === null || reporterEvent === void 0 ? void 0 : reporterEvent.eventType) === 'stepBegin') {
+                                    const step = reporterEvent === null || reporterEvent === void 0 ? void 0 : reporterEvent.step;
+                                    const id = typeof (step === null || step === void 0 ? void 0 : step.id) === 'number' ? step.id : null;
+                                    const title = typeof (step === null || step === void 0 ? void 0 : step.title) === 'string' ? step.title : null;
+                                    const depth = typeof (step === null || step === void 0 ? void 0 : step.depth) === 'number' ? step.depth : 0;
+                                    if (id && title) {
+                                        // Check if step already exists (update) or add new
+                                        const existingIndex = collectedSteps.findIndex(s => s.id === id);
+                                        if (existingIndex === -1) {
+                                            collectedSteps.push({ id, title, depth, status: 'running' });
+                                        }
+                                    }
+                                }
+                                if ((reporterEvent === null || reporterEvent === void 0 ? void 0 : reporterEvent.eventType) === 'stepEnd') {
+                                    const step = reporterEvent === null || reporterEvent === void 0 ? void 0 : reporterEvent.step;
+                                    const id = typeof (step === null || step === void 0 ? void 0 : step.id) === 'number' ? step.id : null;
+                                    if (id) {
+                                        const error = typeof (step === null || step === void 0 ? void 0 : step.error) === 'string' ? step.error : null;
+                                        const existingIndex = collectedSteps.findIndex(s => s.id === id);
+                                        if (existingIndex !== -1) {
+                                            // Update existing step with final status
+                                            collectedSteps[existingIndex] = {
+                                                ...collectedSteps[existingIndex],
+                                                status: error ? 'failed' : 'passed',
+                                                error: error || null,
+                                            };
+                                        }
+                                        // If step doesn't exist, ignore (stepBegin should have been called first)
+                                    }
+                                }
+                                // Save steps periodically
+                                if (currentRunId) {
+                                    const now = Date.now();
+                                    if (now - lastStepsUpdate > STEPS_UPDATE_INTERVAL) {
+                                        lastStepsUpdate = now;
+                                        await updateRunStatus(currentRunId, testSuiteId, { steps: [...collectedSteps] }, apiToken, apiUrl);
+                                    }
+                                }
+                                // Keep a more reliable running tally than parsing stdout.
+                                if (currentRunId && (reporterEvent === null || reporterEvent === void 0 ? void 0 : reporterEvent.eventType) === 'testEnd' && ((_b = reporterEvent === null || reporterEvent === void 0 ? void 0 : reporterEvent.result) === null || _b === void 0 ? void 0 : _b.status)) {
+                                    const status = reporterEvent.result.status;
+                                    if (status === 'passed')
+                                        reporterStats.passed += 1;
+                                    else if (status === 'failed' || status === 'timedout' || status === 'interrupted')
+                                        reporterStats.failed += 1;
+                                    else if (status === 'skipped')
+                                        reporterStats.skipped += 1;
+                                    const now = Date.now();
+                                    if (now - lastReporterStatsUpdate > REPORTER_STATS_UPDATE_INTERVAL) {
+                                        lastReporterStatsUpdate = now;
+                                        await updateRunStatus(currentRunId, testSuiteId, {
+                                            tests_passed: reporterStats.passed,
+                                            tests_failed: reporterStats.failed,
+                                            tests_skipped: reporterStats.skipped,
+                                        }, apiToken, apiUrl);
+                                        if (onStatusUpdate) {
+                                            await onStatusUpdate({
+                                                tests_passed: reporterStats.passed,
+                                                tests_failed: reporterStats.failed,
+                                                tests_skipped: reporterStats.skipped,
+                                            });
+                                        }
+                                    }
+                                }
+                            }
+                            catch (_c) {
+                                // If parsing fails, ignore and don't forward to logs.
+                            }
+                            continue;
+                        }
+                        forwarded += rawLine + '\n';
+                    }
+                    if (forwarded) {
+                        stdout += forwarded;
+                        // Call stdout callback if provided
+                        if (onStdout) {
+                            await onStdout(forwarded);
+                        }
+                    }
+                    // Parse and update statistics periodically
+                    if (currentRunId) {
+                        const now = Date.now();
+                        // Only use stdout parsing as a fallback (in case reporter isn't loaded).
+                        if (now - lastStatsUpdate > STATS_UPDATE_INTERVAL && now - lastReporterStatsUpdate > REPORTER_STATS_UPDATE_INTERVAL) {
+                            lastStatsUpdate = now;
+                            const stats = parsePlaywrightStatistics(stdout);
+                            await updateRunStatus(currentRunId, testSuiteId, {
+                                tests_passed: stats.passed,
+                                tests_failed: stats.failed,
+                                tests_skipped: stats.skipped,
+                            }, apiToken, apiUrl);
+                            if (onStatusUpdate) {
+                                await onStatusUpdate({
+                                    tests_passed: stats.passed,
+                                    tests_failed: stats.failed,
+                                    tests_skipped: stats.skipped,
+                                });
+                            }
+                        }
+                    }
+                });
+                // Stream stderr line by line
+                (_b = testProcess.stderr) === null || _b === void 0 ? void 0 : _b.on('data', async (data) => {
+                    const chunk = data.toString();
+                    stderr += chunk;
+                    // Call stderr callback if provided
+                    if (onStderr) {
+                        await onStderr(chunk);
+                    }
+                });
+                // Handle process completion
+                testProcess.on('close', async (code) => {
+                    var _a;
+                    if (hasResolved)
+                        return;
+                    hasResolved = true;
+                    // Flush any remaining buffered stdout (may be a partial last line)
+                    if (stdoutLineBuffer) {
+                        const remaining = stdoutLineBuffer;
+                        stdoutLineBuffer = '';
+                        if (remaining.startsWith(PROBO_REPORTER_PREFIX)) {
+                            try {
+                                const reporterEvent = JSON.parse(remaining.slice(PROBO_REPORTER_PREFIX.length));
+                                if (onReporterEvent) {
+                                    await onReporterEvent(reporterEvent);
+                                }
+                                if (currentRunId && (reporterEvent === null || reporterEvent === void 0 ? void 0 : reporterEvent.eventType) === 'testEnd' && ((_a = reporterEvent === null || reporterEvent === void 0 ? void 0 : reporterEvent.result) === null || _a === void 0 ? void 0 : _a.status)) {
+                                    const status = reporterEvent.result.status;
+                                    if (status === 'passed')
+                                        reporterStats.passed += 1;
+                                    else if (status === 'failed' || status === 'timedout' || status === 'interrupted')
+                                        reporterStats.failed += 1;
+                                    else if (status === 'skipped')
+                                        reporterStats.skipped += 1;
+                                }
+                            }
+                            catch (_b) {
+                                // ignore
+                            }
+                        }
+                        else {
+                            stdout += remaining;
+                            if (onStdout) {
+                                await onStdout(remaining);
+                            }
+                        }
+                    }
+                    const exitCode = code !== null && code !== void 0 ? code : 1;
+                    const success = exitCode === 0;
+                    const isTestFailure = exitCode === 1 && stdout.length > 0;
+                    console.log(success ? '✅ Tests completed successfully' : (isTestFailure ? '⚠️ Tests completed with failures' : '❌ Test execution failed'));
+                    // Parse final statistics from metadata/stdout as fallback
+                    let parsedStats = null;
+                    if (fs.existsSync(path.join(testSuiteDir, 'playwright-report'))) {
+                        parsedStats = parseStatisticsFromMetadata(testSuiteDir);
+                    }
+                    if (!parsedStats) {
+                        parsedStats = parsePlaywrightStatistics(stdout);
+                    }
+                    // Use reporterStats as source of truth (tracked from real-time events)
+                    // Fall back to parsed stats only if reporterStats is empty
+                    const totalFromReporter = reporterStats.passed + reporterStats.failed + reporterStats.skipped;
+                    const finalStats = totalFromReporter > 0 ? reporterStats : (parsedStats || { passed: 0, failed: 0, skipped: 0 });
+                    // Update run status with final steps
+                    if (currentRunId) {
+                        const finalStatus = success ? 'success' : 'error';
+                        await updateRunStatus(currentRunId, testSuiteId, {
+                            status: finalStatus,
+                            exit_code: exitCode,
+                            stdout: stdout,
+                            stderr: stderr,
+                            steps: [...collectedSteps], // Save final steps state
+                            error_message: success || isTestFailure ? undefined : `Test execution failed with exit code ${exitCode}`,
+                            tests_passed: finalStats.passed,
+                            tests_failed: finalStats.failed,
+                            tests_skipped: finalStats.skipped,
+                        }, apiToken, apiUrl);
+                        if (onStatusUpdate) {
+                            await onStatusUpdate({
+                                status: finalStatus,
+                                exit_code: exitCode,
+                                stdout: stdout,
+                                stderr: stderr,
+                                tests_passed: finalStats.passed,
+                                tests_failed: finalStats.failed,
+                                tests_skipped: finalStats.skipped,
+                            });
+                        }
+                        // Artifact uploads disabled - reports are now accessed locally via trace viewer
+                        // Upload artifacts functionality preserved but disabled
+                        // await this.uploadArtifacts(currentRunId, testSuiteId, testSuiteDir, apiToken, apiUrl);
+                    }
+                    resolve({
+                        success: success,
+                        exitCode: exitCode,
+                        stdout: stdout,
+                        stderr: stderr,
+                        // Only set error if it's not a success and not a test failure (i.e., real execution error)
+                        error: success || isTestFailure ? undefined : `Test execution failed with exit code ${exitCode}`,
+                        runId: currentRunId,
+                    });
+                });
+                // Handle process errors
+                testProcess.on('error', async (error) => {
+                    if (hasResolved)
+                        return;
+                    hasResolved = true;
+                    const errorMessage = error.message || String(error);
+                    stderr += errorMessage;
+                    console.error('❌ Test execution failed:', error);
+                    // Update run status
+                    if (currentRunId) {
+                        await updateRunStatus(currentRunId, testSuiteId, {
+                            status: 'error',
+                            exit_code: 1,
+                            error_message: `Test execution failed: ${errorMessage}`,
+                            stderr: stderr,
+                        }, apiToken, apiUrl);
+                        if (onStatusUpdate) {
+                            await onStatusUpdate({
+                                status: 'error',
+                                exit_code: 1,
+                                error_message: `Test execution failed: ${errorMessage}`,
+                                stderr: stderr,
+                            });
+                        }
+                    }
+                    resolve({
+                        success: false,
+                        exitCode: 1,
+                        stdout: stdout,
+                        stderr: stderr,
+                        error: `Test execution failed: ${errorMessage}`,
+                        runId: currentRunId,
+                    });
+                });
+                // Set timeout (1 hour)
+                setTimeout(async () => {
+                    if (!hasResolved) {
+                        hasResolved = true;
+                        testProcess.kill();
+                        const errorMessage = 'Test execution timed out after 1 hour';
+                        stderr += errorMessage;
+                        // Update run status
+                        if (currentRunId) {
+                            await updateRunStatus(currentRunId, testSuiteId, {
+                                status: 'error',
+                                exit_code: 1,
+                                error_message: errorMessage,
+                                stderr: stderr,
+                            }, apiToken, apiUrl);
+                            if (onStatusUpdate) {
+                                await onStatusUpdate({
+                                    status: 'error',
+                                    exit_code: 1,
+                                    error_message: errorMessage,
+                                    stderr: stderr,
+                                });
+                            }
+                        }
+                        resolve({
+                            success: false,
+                            exitCode: 1,
+                            stdout: stdout,
+                            stderr: stderr,
+                            error: errorMessage,
+                            runId: currentRunId,
+                        });
+                    }
+                }, 3600000); // 1 hour timeout
+            });
+        }
+        catch (error) {
+            console.error('❌ Error running test suite:', error);
+            const errorMsg = error.message || String(error);
+            if (currentRunId) {
+                await updateRunStatus(currentRunId, testSuiteId, {
+                    status: 'error',
+                    exit_code: 1,
+                    error_message: errorMsg,
+                }, apiToken, apiUrl).catch(() => { }); // Ignore errors updating status
+                if (onStatusUpdate) {
+                    try {
+                        const result = onStatusUpdate({
+                            status: 'error',
+                            exit_code: 1,
+                            error_message: errorMsg,
+                        });
+                        if (result && typeof result.then === 'function') {
+                            await result.catch(() => { });
+                        }
+                    }
+                    catch (_a) {
+                        // Ignore errors in status update callback
+                    }
+                }
+            }
+            return {
+                success: false,
+                exitCode: 1,
+                stdout: '',
+                stderr: errorMsg,
+                error: errorMsg,
+                runId: currentRunId,
+            };
+        }
+    }
+    /**
+     * Upload artifacts for a test suite run
+     *
+     * NOTE: This method is preserved for potential future use but is currently disabled.
+     * Artifacts are now accessed locally via the trace viewer instead of being uploaded to the backend.
+     */
+    static async uploadArtifacts(runId, testSuiteId, testSuiteDir, apiToken, apiUrl) {
+        // Artifact uploads disabled - reports are now accessed locally via trace viewer
+        // Method signature preserved for potential future re-enablement
+        return;
+    }
+}
+
+async function runCLI(options) {
+    const apiToken = options.apiKey || process.env.PROBO_API_KEY;
+    if (!apiToken) {
+        console.error('❌ Error: PROBO_API_KEY environment variable or --api-key flag is required');
+        process.exit(1);
+    }
+    const apiUrl = options.apiEndpoint || process.env.PROBO_API_ENDPOINT || 'https://api.probolabs.ai';
+    let testSuiteId;
+    // Resolve test suite ID
+    if (options.testSuiteId) {
+        testSuiteId = options.testSuiteId;
+    }
+    else if (options.testSuiteName) {
+        if (!options.project) {
+            console.error('❌ Error: --project is required when using --test-suite-name');
+            process.exit(1);
+        }
+        try {
+            console.log(`🔍 Looking up test suite "${options.testSuiteName}" in project "${options.project}"...`);
+            testSuiteId = await TestSuiteRunner.lookupTestSuiteByName(options.testSuiteName, options.project, apiToken, apiUrl);
+            console.log(`✅ Found test suite ID: ${testSuiteId}`);
+        }
+        catch (error) {
+            console.error(`❌ Error looking up test suite: ${error.message}`);
+            process.exit(1);
+        }
+    }
+    else {
+        console.error('❌ Error: Either --test-suite-id or --test-suite-name must be provided');
+        process.exit(1);
+    }
+    // Run the test suite
+    try {
+        const result = await TestSuiteRunner.runTestSuite(testSuiteId, apiToken, apiUrl, options.testSuiteName, undefined, // runId - will be created automatically
+        {
+            outputDir: options.outputDir,
+            includeReporter: false, // CI/CD mode - no custom reporter
+        });
+        if (result.success) {
+            console.log('✅ Test suite completed successfully');
+            process.exit(0);
+        }
+        else {
+            console.error(`❌ Test suite failed with exit code ${result.exitCode}`);
+            if (result.error) {
+                console.error(`Error: ${result.error}`);
+            }
+            process.exit(result.exitCode || 1);
+        }
+    }
+    catch (error) {
+        console.error(`❌ Error running test suite: ${error.message}`);
+        process.exit(1);
+    }
+}
+
+export { runCLI };
+//# sourceMappingURL=cli.js.map