endorphin-ai 0.1.0

package/framework/testing/test-interactive-recorder.js

@@ -0,0 +1,83 @@
+// Endorphin e2e AI test framework>
+// Copyright (C)  2025 Redstudio Agency
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+// Simple test to validate the enhanced interactive recorder setup
+import { EnhancedBrowserTestFramework } from '../index.js';
+import { TestRecorder } from '../core/test-recorder.js';
+
+async function testRecorderSetup() {
+  console.log('🧪 Testing Enhanced Interactive Recorder Setup...');
+  console.log('═'.repeat(50));
+  
+  try {
+    // Test 1: Framework instantiation
+    console.log('1️⃣ Testing framework instantiation...');
+    const framework = new EnhancedBrowserTestFramework();
+    console.log('✅ Framework created successfully');
+    
+    // Test 2: Test recorder instantiation
+    console.log('2️⃣ Testing recorder instantiation...');
+    const testData = {
+      id: 'TEST-001',
+      name: 'Validation Test',
+      description: 'Testing recorder setup',
+      site: 'https://example.com'
+    };
+    const recorder = new TestRecorder(framework, testData);
+    console.log('✅ Recorder created successfully');
+    
+    // Test 3: Natural language command parsing
+    console.log('3️⃣ Testing command parsing...');
+    
+    // Mock the framework with basic structure
+    framework.tools = {
+      click: async (params) => `Clicked ${params.selector}`,
+      fill: async (params) => `Filled ${params.selector} with ${params.value}`,
+      navigate: async (params) => `Navigated to ${params.url}`,
+      screenshot: async () => 'Screenshot taken'
+    };
+    
+    // Test command parsing
+    const clickResult = framework.extractSelectorFromCommand('click login button');
+    console.log(`   Click parsing: "${clickResult}"`);
+    
+    const fillResult = framework.extractFillFromCommand('fill email with test@example.com');
+    console.log(`   Fill parsing: selector="${fillResult.selector}", value="${fillResult.value}"`);
+    
+    const urlResult = framework.extractUrlFromCommand('navigate to https://google.com');
+    console.log(`   URL parsing: "${urlResult}"`);
+    
+    console.log('✅ Command parsing works correctly');
+    
+    console.log('\n🎉 All tests passed! Enhanced Interactive Recorder is ready to use.');
+    console.log('\nTo start recording:');
+    console.log('  npm run interactive');
+    console.log('\nOr run directly:');
+    console.log('  node framework/interactive/enhanced-interactive-recorder.js');
+    
+  } catch (error) {
+    console.error('❌ Test failed:', error.message);
+    console.error(error.stack);
+    process.exit(1);
+  }
+}
+
+// Run if this file is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  testRecorderSetup().catch(console.error);
+}
+
+export { testRecorderSetup };

package/framework/testing/test-modular-framework.js

@@ -0,0 +1,47 @@
+// Endorphin e2e AI test framework>
+// Copyright (C)  2025 Redstudio Agency
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+import { EnhancedBrowserTestFramework } from '../index.js';
+
+async function testModularFramework() {
+  console.log('🧪 Testing Modular Framework...');
+  
+  const framework = new EnhancedBrowserTestFramework();
+  
+  try {
+    // Initialize framework
+    await framework.initialize();
+    console.log('✅ Framework initialized successfully');
+    
+    // Test simple navigation
+    const result = await framework.runTask(
+      "Navigate to https://httpbin.org. Take a screenshot. Get simple page content to verify the site loaded. STOP - test completed.",
+      "Modular Framework Test"
+    );
+    
+    console.log('✅ Test completed:', result.status);
+    console.log('📁 Results saved to:', result.sessionDir);
+    
+  } catch (error) {
+    console.error('❌ Test failed:', error.message);
+  } finally {
+    await framework.cleanup();
+    console.log('🧹 Framework cleanup completed');
+  }
+}
+
+// Run the test
+testModularFramework().catch(console.error);

package/framework/testing/verify-test-format.js

@@ -0,0 +1,58 @@
+// Endorphin e2e AI test framework>
+// Copyright (C)  2025 Redstudio Agency
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+// Verification script to test the updated test format and test-manager
+import { TestManager } from '../core/test-manager.js';
+
+async function verifyTestFormat() {
+  console.log("🔧 Verifying Test Format Updates...");
+  console.log("═".repeat(50));
+  
+  try {
+    const testManager = new TestManager();
+    const tests = await testManager.loadTests();
+    
+    console.log(`✅ Successfully loaded ${tests.size} test cases`);
+    console.log("\n📋 Test Summary:");
+    
+    // Verify each test has the new format
+    for (const [testId, test] of tests) {
+      const hasUID = test.testData && test.testData.uid;
+      const hasSimpleTask = test.task && !test.task.includes("Step-by-step");
+      const hasExportConst = true; // Already loaded, so format is correct
+      
+      console.log(`\n🔹 ${testId}: ${test.name}`);
+      console.log(`   ✅ Export Format: ${hasExportConst ? 'Updated (export const)' : 'Old (export default)'}`);
+      console.log(`   ✅ Task Format: ${hasSimpleTask ? 'Simplified' : 'Detailed Steps'}`);
+      console.log(`   ✅ Test Data: ${hasUID ? 'Enhanced with UID' : 'Basic'}`);
+      console.log(`   🎯 Priority: ${test.priority}`);
+      console.log(`   🏷️  Tags: ${test.tags.join(', ')}`);
+    }
+    
+    console.log("\n🎉 All tests verified successfully!");
+    console.log("✅ Export format updated to 'export const'");
+    console.log("✅ Task format simplified to natural language");
+    console.log("✅ Test data enhanced with unique identifiers");
+    console.log("✅ Test-manager handles both export formats");
+    
+  } catch (error) {
+    console.error("❌ Verification failed:", error);
+    process.exit(1);
+  }
+}
+
+// Run verification
+verifyTestFormat().catch(console.error);

package/framework/tools/content.js

@@ -0,0 +1,67 @@
+// Endorphin e2e AI test framework>
+// Copyright (C)  2025 Redstudio Agency
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+
+export function createGetPageContentTool(framework) {
+  return tool(async ({ includeTitle = true, maxLength = 8000 }) => {
+    const stepDesc = "Get page content for analysis";
+    console.log(`📄 ${stepDesc}`);
+    
+    try {
+      let content = '';
+      
+      if (includeTitle) {
+        const title = await framework.page.title();
+        const url = framework.page.url();
+        content += `Page Title: ${title}\nURL: ${url}\n\n`;
+      }
+      
+      const htmlContent = await framework.page.content();
+      const truncatedContent = htmlContent.length > maxLength 
+        ? htmlContent.substring(0, maxLength) + '\n... (truncated for brevity)'
+        : htmlContent;
+      content += truncatedContent;
+      
+      framework.logTestStep(stepDesc, 'getPageContent', { includeTitle, maxLength }, `Retrieved ${content.length} characters`, true);
+      return content;
+    } catch (error) {
+      framework.logTestStep(stepDesc, 'getPageContent', { includeTitle, maxLength }, error.message, false);
+      throw error;
+    }
+  }, {
+    name: 'getPageContent',
+    description: 'Get HTML content of the current page for analysis.',
+    schema: z.object({
+      includeTitle: z.boolean().optional(),
+      maxLength: z.number().optional(),
+    })
+  });
+}
+
+export function createGetSimplePageContentTool(framework) {
+  return tool(async () => {
+    console.log("📄 Getting page content");
+    const content = await framework.page.content();
+    framework.logTestStep("Get simple page content", 'getSimplePageContent', {}, `Retrieved ${content.length} characters`, true);
+    return content;
+  }, {
+    name: 'getSimplePageContent',
+    description: 'Get the current HTML content of the page to analyze its structure.',
+    schema: z.object({})
+  });
+}

package/framework/tools/index.js

@@ -0,0 +1,52 @@
+// Endorphin e2e AI test framework>
+// Copyright (C)  2025 Redstudio Agency
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+import { createNavigationTool } from './navigation.js';
+import { createGetPageContentTool, createGetSimplePageContentTool } from './content.js';
+import { createClickTool, createFillTool, createClearFieldTool } from './interaction.js';
+import { createVerifyElementTool, createGetElementInfoTool } from './verification.js';
+import { createWaitTool, createScreenshotTool } from './utilities.js';
+
+/**
+ * Create all browser automation tools for the framework
+ * @param {EnhancedBrowserTestFramework} framework - Framework instance
+ * @returns {Array} Array of all configured tools
+ */
+export function createAllTools(framework) {
+  return [
+    // Navigation tools
+    createNavigationTool(framework),
+    
+    // Content analysis tools
+    createGetPageContentTool(framework),
+    createGetSimplePageContentTool(framework),
+    
+    // Interaction tools
+    createClickTool(framework),
+    createFillTool(framework),
+    createClearFieldTool(framework),
+    
+    // Verification tools
+    createVerifyElementTool(framework),
+    createGetElementInfoTool(framework),
+    
+    // Utility tools
+    createWaitTool(framework),
+    createScreenshotTool(framework)
+  ];
+}
+
+export default createAllTools;

package/framework/tools/interaction.js

@@ -0,0 +1,180 @@
+// Endorphin e2e AI test framework>
+// Copyright (C)  2025 Redstudio Agency
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+
+export function createClickTool(framework) {
+  return tool(async ({ selector, strategy = 'css', timeout = 10000, force = false }) => {
+    const stepDesc = `Click ${selector} using ${strategy} strategy`;
+    console.log(`🔘 ${stepDesc}`);
+    
+    try {
+      let locator;
+      
+      switch (strategy) {
+        case 'text':
+          locator = framework.page.getByText(selector, { exact: false });
+          break;
+        case 'exact-text':
+          locator = framework.page.getByText(selector, { exact: true });
+          break;
+        case 'role':
+          const [role, name] = selector.split(':');
+          locator = framework.page.getByRole(role, { name });
+          break;
+        case 'placeholder':
+          locator = framework.page.getByPlaceholder(selector);
+          break;
+        case 'label':
+          locator = framework.page.getByLabel(selector);
+          break;
+        case 'title':
+          locator = framework.page.getByTitle(selector);
+          break;
+        case 'alt':
+          locator = framework.page.getByAltText(selector);
+          break;
+        default:
+          locator = framework.page.locator(selector);
+      }
+      
+      // Check if element exists first
+      const count = await locator.count();
+      if (count === 0) {
+        const result = `Element ${selector} not found on page`;
+        framework.logTestStep(stepDesc, 'click', { selector, strategy, timeout, force }, result, false);
+        return `❌ ${result}`;
+      }
+      
+      await locator.waitFor({ state: 'visible', timeout });
+      await locator.click({ force });
+      await framework.takeStepScreenshot(`After clicking ${selector}`);
+      
+      const result = `Successfully clicked ${selector} using ${strategy} strategy`;
+      framework.logTestStep(stepDesc, 'click', { selector, strategy, timeout, force }, result, true);
+      return result;
+    } catch (error) {
+      await framework.takeStepScreenshot(`Failed to click ${selector}`);
+      framework.logTestStep(stepDesc, 'click', { selector, strategy, timeout, force }, error.message, false);
+      return `❌ Error clicking ${selector}: ${error.message}`;
+    }
+  }, {
+    name: 'click',
+    description: 'Click any element with multiple selection strategies. For buttons with text like "Log In", "Sign In", "Submit", use strategy="text" and selector="Log In". For CSS selectors use strategy="css".',
+    schema: z.object({
+      selector: z.string().describe("Element selector - for buttons use the button text (e.g. 'Log In', 'Sign In'), for CSS use actual selector"),
+      strategy: z.enum(['css', 'text', 'exact-text', 'role', 'placeholder', 'label', 'title', 'alt']).optional().describe("Selection strategy - use 'text' for button text, 'css' for CSS selectors"),
+      timeout: z.number().optional(),
+      force: z.boolean().optional(),
+    })
+  });
+}
+
+export function createFillTool(framework) {
+  return tool(async ({ selector, value, strategy = 'fill', clearFirst = true, pressEnter = false }) => {
+    const stepDesc = `Fill ${selector} with "${value}"`;
+    console.log(`📝 ${stepDesc}`);
+    
+    try {
+      await framework.page.waitForSelector(selector, { state: 'visible', timeout: 10000 });
+      
+      if (clearFirst) {
+        // Focus and clear the field properly
+        await framework.page.focus(selector);
+        await framework.page.keyboard.press('Control+a');
+        await framework.page.keyboard.press('Delete');
+        
+        // Wait a moment for the field to clear
+        await framework.page.waitForTimeout(100);
+      }
+      
+      if (strategy === 'type') {
+        await framework.page.type(selector, value, { delay: 50 });
+      } else {
+        await framework.page.fill(selector, value);
+      }
+
+      if (pressEnter) {
+        await framework.page.keyboard.press('Enter');
+      }
+      
+      await framework.takeStepScreenshot(`After filling ${selector}`);
+      
+      // Verify the value was set correctly
+      const actualValue = await framework.page.locator(selector).inputValue();
+      const success = actualValue === value;
+      const result = success 
+        ? `Successfully filled ${selector} with "${value}"`
+        : `Filled ${selector} but value is "${actualValue}" instead of "${value}"`;
+      
+      framework.logTestStep(stepDesc, 'fill', { selector, value, strategy, clearFirst, pressEnter }, result, success);
+      return success ? `✅ ${result}` : `⚠️ ${result}`;
+    } catch (error) {
+      await framework.takeStepScreenshot(`Failed to fill ${selector}`);
+      framework.logTestStep(stepDesc, 'fill', { selector, value, strategy, clearFirst, pressEnter }, error.message, false);
+      return `❌ Error filling ${selector}: ${error.message}`;
+    }
+  }, {
+    name: 'fill',
+    description: 'Fill any input field with text. Use common selectors like input[type="email"], input[name="email"], #email for email fields, input[type="password"], input[name="password"], #password for password fields.',
+    schema: z.object({
+      selector: z.string().describe("CSS selector of input field - use input[type='email'] for email, input[type='password'] for password"),
+      value: z.string().describe("Text to enter"),
+      strategy: z.enum(['fill', 'type']).optional(),
+      clearFirst: z.boolean().optional(),
+      pressEnter: z.boolean().optional(),
+    })
+  });
+}
+
+export function createClearFieldTool(framework) {
+  return tool(async ({ selector }) => {
+    const stepDesc = `Clear field: ${selector}`;
+    console.log(`🧹 ${stepDesc}`);
+    
+    try {
+      await framework.page.waitForSelector(selector, { state: 'visible', timeout: 10000 });
+      
+      // Focus the field first
+      await framework.page.focus(selector);
+      
+      // Select all content and delete
+      await framework.page.keyboard.press('Control+a');
+      await framework.page.keyboard.press('Delete');
+      
+      // Verify field is cleared
+      const value = await framework.page.locator(selector).inputValue();
+      const isCleared = value === '';
+      
+      const result = isCleared 
+        ? `Successfully cleared field ${selector}`
+        : `Field ${selector} still contains: "${value}"`;
+      
+      framework.logTestStep(stepDesc, 'clearField', { selector }, result, isCleared);
+      return isCleared ? `✅ ${result}` : `⚠️ ${result}`;
+    } catch (error) {
+      framework.logTestStep(stepDesc, 'clearField', { selector }, error.message, false);
+      return `❌ Error clearing field ${selector}: ${error.message}`;
+    }
+  }, {
+    name: 'clearField',
+    description: 'Clear an input field completely.',
+    schema: z.object({
+      selector: z.string().describe("CSS selector of the input field to clear"),
+    })
+  });
+}

package/framework/tools/navigation.js

@@ -0,0 +1,43 @@
+// Endorphin e2e AI test framework>
+// Copyright (C)  2025 Redstudio Agency
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+
+export function createNavigationTool(framework) {
+  return tool(async ({ location, waitUntil = 'domcontentloaded' }) => {
+    const stepDesc = `Navigate to: ${location}`;
+    console.log(`🌍 ${stepDesc}`);
+    
+    try {
+      await framework.page.goto(location, { waitUntil, timeout: 60000 });
+      await framework.takeStepScreenshot(`Page loaded: ${location}`);
+      
+      framework.logTestStep(stepDesc, 'navigate', { location, waitUntil }, `Successfully navigated to: ${location}`, true);
+      return `Successfully navigated to: ${location}`;
+    } catch (error) {
+      framework.logTestStep(stepDesc, 'navigate', { location, waitUntil }, error.message, false);
+      throw error;
+    }
+  }, {
+    name: 'navigate',
+    description: 'Navigate to a URL with enhanced options.',
+    schema: z.object({
+      location: z.string().describe("URL to navigate to"),
+      waitUntil: z.enum(['load', 'domcontentloaded', 'networkidle']).optional(),
+    })
+  });
+}

package/framework/tools/utilities.js

@@ -0,0 +1,99 @@
+// Endorphin e2e AI test framework>
+// Copyright (C)  2025 Redstudio Agency
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+import path from 'path';
+
+export function createWaitTool(framework) {
+  return tool(async ({ milliseconds = 500, reason, selector, state = 'visible' }) => {
+    const stepDesc = selector 
+      ? `Wait for ${selector} to be ${state}` 
+      : `Wait for ${milliseconds}ms${reason ? ` (${reason})` : ''}`;
+    console.log(`⏱️ ${stepDesc}`);
+    
+    try {
+      if (selector) {
+        await framework.page.waitForSelector(selector, { state, timeout: milliseconds });
+        const result = `Element ${selector} is now ${state}`;
+        framework.logTestStep(stepDesc, 'wait', { milliseconds, reason, selector, state }, result, true);
+        return `✅ ${result}`;
+      } else {
+        await framework.page.waitForTimeout(milliseconds);
+        const result = `Waited for ${milliseconds}ms${reason ? ` - ${reason}` : ''}`;
+        framework.logTestStep(stepDesc, 'wait', { milliseconds, reason, selector, state }, result, true);
+        return result;
+      }
+    } catch (error) {
+      framework.logTestStep(stepDesc, 'wait', { milliseconds, reason, selector, state }, error.message, false);
+      return `❌ Timeout waiting for ${selector} to be ${state}`;
+    }
+  }, {
+    name: 'wait',
+    description: 'Wait for time or element state.',
+    schema: z.object({
+      milliseconds: z.number().optional(),
+      reason: z.string().optional(),
+      selector: z.string().optional(),
+      state: z.enum(['visible', 'hidden', 'attached', 'detached']).optional(),
+    })
+  });
+}
+
+export function createScreenshotTool(framework) {
+  return tool(async ({ name, selector, fullPage = false }) => {
+    if (!framework.currentTestSession) {
+      framework.currentTestSession.screenshotCounter++;
+    }
+    
+    const filename = name || `manual-screenshot-${Date.now()}.png`;
+    const stepDesc = `Take screenshot: ${filename}`;
+    console.log(`📸 ${stepDesc}`);
+    
+    try {
+      let filePath;
+      if (framework.currentTestSession) {
+        filePath = path.join(framework.currentTestSession.screenshotsDir, filename);
+      } else {
+        filePath = filename;
+      }
+      
+      if (selector) {
+        await framework.page.locator(selector).screenshot({ path: filePath });
+      } else {
+        await framework.page.screenshot({ path: filePath, fullPage });
+      }
+      
+      const result = selector 
+        ? `Screenshot of ${selector} saved as ${filename}`
+        : `${fullPage ? 'Full page' : 'Viewport'} screenshot saved as ${filename}`;
+      
+      framework.logTestStep(stepDesc, 'screenshot', { name, selector, fullPage }, result, true);
+      return `📸 ${result}`;
+    } catch (error) {
+      framework.logTestStep(stepDesc, 'screenshot', { name, selector, fullPage }, error.message, false);
+      return `❌ Error taking screenshot: ${error.message}`;
+    }
+  }, {
+    name: 'screenshot',
+    description: 'Take screenshot for documentation/debugging.',
+    schema: z.object({
+      name: z.string().optional(),
+      selector: z.string().optional(),
+      fullPage: z.boolean().optional(),
+    })
+  });
+}