chrometools-mcp 1.7.1 → 1.8.2

package/CHANGELOG.md

@@ -2,6 +2,98 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.8.2] - 2025-12-19
+
+### Fixed
+- **Code Generator Bugs** - Fixed multiple issues in test code generators
+  - **Python generators**: Fixed comment syntax - now use `#` instead of `//`
+  - **Python generators**: Moved `import re` to top of file instead of inline
+  - **Java generator**: Fixed variable name conflicts - now uses unique names (`typeElement`, `hoverElement`, etc.) instead of reusing `element`
+  - **Java generator**: Added missing imports (`JavascriptExecutor`, `Select`)
+  - **All generators**: Implemented language-specific comment generation via `generateComment()` method
+  - Location: `utils/code-generators/code-generator-base.js`, `playwright-python.js`, `selenium-python.js`, `selenium-java.js`
+
+## [1.8.1] - 2025-12-19
+
+### Added
+- **Smart Project Directory Detection** - Scenarios now automatically save to the correct project directory
+  - Auto-detection cascade: `CLAUDE_PROJECT_DIR` env var → `PROJECT_DIR` env var → Git root → current working directory
+  - Optional `directory` parameter on all recorder tools (`enableRecorder`, `executeScenario`, `listScenarios`, `searchScenarios`, `getScenarioInfo`, `deleteScenario`, `exportScenarioAsCode`)
+  - Session memory: once directory is set (explicitly or auto-detected), it's remembered for the entire MCP server session
+  - Solves issue where scenarios were saved to unpredictable locations based on where MCP process was launched
+  - Location: `utils/project-detector.js`, `index.js:97-115`
+
+### Changed
+- **All recorder storage functions now accept `baseDir` parameter** - Breaking change for direct API usage
+  - Updated: `saveScenario()`, `loadScenario()`, `listScenarios()`, `searchScenarios()`, `deleteScenario()`, `loadIndex()`, and all other storage functions
+  - MCP tool users: no breaking changes, just new optional `directory` parameter
+  - Location: `recorder/scenario-storage.js`, `recorder/scenario-executor.js`, `recorder/recorder-script.js`
+
+## [1.8.0] - 2025-12-19
+
+### Added
+- **Test Code Generation** - New MCP tool `exportScenarioAsCode` for generating executable test code from recorded scenarios
+  - Supports 4 test frameworks: Playwright (TypeScript/Python), Selenium (Python/Java)
+  - Automatic selector cleaning - removes unstable CSS classes (CSS Modules, styled-components, Emotion, hashed classes)
+  - Generates clean, readable test code with comments
+  - Smart selector stability analysis with pattern-based detection
+  - Fallback selector selection - chooses most stable selector from fallbacks
+  - Location: `utils/code-generators/`, `utils/selector-cleaner.js`
+
+  **Unstable patterns detected:**
+  - CSS Modules: `Button_primary__2x3yZ`
+  - Styled-components: `sc-AbCdEf-0`
+  - Emotion: `css-1a2b3c4d`
+  - Hash suffixes: `component_a1b2c3d`
+  - Random hashes: `_1a2b3c4d`
+
+  **Usage:**
+  ```javascript
+  exportScenarioAsCode('checkout', {
+    language: 'playwright-typescript',
+    cleanSelectors: true,
+    includeComments: true
+  })
+  ```
+
+## [1.7.4] - 2025-12-19
+
+### Changed
+- **executeScenario auto-opens browser** - No longer throws error when no page is open
+  - Automatically opens browser at scenario's `entryUrl` if no page is currently open
+  - Eliminates need to manually call `openBrowser` before executing scenarios
+  - Improves user experience by treating browser opening as a side effect
+  - Falls back gracefully: shows error only if scenario has no `entryUrl`
+  - Location: `index.js:3417-3469`
+
+## [1.7.3] - 2025-12-19
+
+### Fixed
+- **Fixed CSS selector generation crash** - `analyzePage` now handles attribute values with special characters
+  - Added `isSafeSelectorValue()` function to validate attribute values before using in selectors
+  - Filters out attributes containing problematic characters: `["'\\[]{}()]`
+  - Added try-catch blocks to prevent selector syntax errors
+  - Example: `button[data-counter="["b"]"]` (invalid) is now skipped
+  - Location: `element-finder-utils.js:302-360`
+
+### Improved
+- **Recorder now skips hidden elements** - Prevents recording actions on invisible elements
+  - Added `isElementVisible()` function to check element visibility before recording
+  - Checks: offsetWidth/Height, display, visibility, opacity
+  - Applies to all event types: click, type, select, upload, hover, drag
+  - Prevents scenarios with duplicate/invisible element actions (e.g., Yandex search with hidden input)
+  - Console logs when skipping hidden elements for debugging
+  - Location: `recorder/recorder-script.js:1173-1188`
+
+## [1.7.2] - 2025-12-16
+
+### Added
+- **Figma API Token Setup documentation** - Added comprehensive guide on how to obtain and configure Figma Personal Access Token
+  - Step-by-step instructions for getting token from Figma account settings
+  - Configuration examples for both Claude Desktop and Claude Code
+  - Environment variable setup (`FIGMA_TOKEN`)
+  - Note about alternative parameter-based token passing
+
 ## [1.7.1] - 2025-12-15
 
 ### Performance

package/README.md

@@ -14,7 +14,7 @@ MCP server for Chrome automation using Puppeteer with persistent browser session
   - [Interaction Tools](#2-interaction-tools) - click, type, scrollTo
   - [Inspection Tools](#3-inspection-tools) - getElement, getComputedCss, getBoxModel, screenshot
   - [Advanced Tools](#4-advanced-tools) - executeScript, getConsoleLogs, listNetworkRequests, getNetworkRequest, filterNetworkRequests, hover, setStyles, setViewport, getViewport, navigateTo
-  - [Recorder Tools](#6-recorder-tools) ⭐ **NEW** - enableRecorder, executeScenario, listScenarios, searchScenarios, getScenarioInfo, deleteScenario
+  - [Recorder Tools](#6-recorder-tools) ⭐ **NEW** - enableRecorder, executeScenario, listScenarios, searchScenarios, getScenarioInfo, deleteScenario, exportScenarioAsCode
 - [Typical Workflow Example](#typical-workflow-example)
 - [Tool Usage Tips](#tool-usage-tips)
 - [Configuration](#configuration)
@@ -506,9 +506,32 @@ Extract detailed design specifications from Figma including text content, colors
 
 ### 6. Recorder Tools ⭐ NEW
 
+**Directory Management**: All recorder tools support an optional `directory` parameter to specify where scenarios are stored. If not provided, the directory is auto-detected using this cascade:
+1. `CLAUDE_PROJECT_DIR` environment variable (set by Claude Code)
+2. `PROJECT_DIR` environment variable (custom)
+3. Git repository root (detected via `git rev-parse --show-toplevel`)
+4. Current working directory (fallback)
+
+Once a directory is set (explicitly or auto-detected), it's remembered for the entire MCP server session.
+
+**Example**:
+```javascript
+// Let it auto-detect (recommended)
+enableRecorder()
+
+// Or specify explicitly
+enableRecorder({ directory: "/path/to/project" })
+
+// Later calls reuse the same directory automatically
+executeScenario({ name: "test" })  // Uses remembered directory
+```
+
+---
+
 #### enableRecorder
 Inject visual recorder UI widget into the current page.
-- **Parameters**: None
+- **Parameters**:
+  - `directory` (optional): Directory to save scenarios (auto-detected if not provided)
 - **Use case**: Start recording user interactions visually
 - **Returns**: Success status
 - **Features**:
@@ -524,6 +547,7 @@ Execute a previously recorded scenario by name.
   - `name` (required): Scenario name
   - `parameters` (optional): Runtime parameters (e.g., { email: "user@test.com" })
   - `executeDependencies` (optional): Execute dependencies before running scenario (default: true)
+  - `directory` (optional): Directory where scenarios are stored (auto-detected if not provided)
 - **Use case**: Run automated test scenarios
 - **Returns**: Execution result with success/failure status
 - **Features**:
@@ -541,7 +565,8 @@ Execute a previously recorded scenario by name.
 
 #### listScenarios
 Get all available scenarios with metadata.
-- **Parameters**: None
+- **Parameters**:
+  - `directory` (optional): Directory where scenarios are stored (auto-detected if not provided)
 - **Use case**: Browse recorded scenarios
 - **Returns**: Array of scenarios with names, descriptions, tags, timestamps
 
@@ -550,6 +575,7 @@ Search scenarios by text or tags.
 - **Parameters**:
   - `text` (optional): Search in name/description
   - `tags` (optional): Array of tags to filter
+  - `directory` (optional): Directory where scenarios are stored (auto-detected if not provided)
 - **Use case**: Find specific scenarios
 - **Returns**: Matching scenarios
 
@@ -558,15 +584,59 @@ Get detailed information about a scenario.
 - **Parameters**:
   - `name` (required): Scenario name
   - `includeSecrets` (optional): Include secret values (default: false)
+  - `directory` (optional): Directory where scenarios are stored (auto-detected if not provided)
 - **Use case**: Inspect scenario actions and dependencies
 - **Returns**: Full scenario details (actions, metadata, dependencies)
 
 #### deleteScenario
 Delete a scenario and its associated secrets.
-- **Parameters**: `name` (required)
+- **Parameters**:
+  - `name` (required): Scenario name
+  - `directory` (optional): Directory where scenarios are stored (auto-detected if not provided)
 - **Use case**: Clean up unused scenarios
 - **Returns**: Success confirmation
 
+#### exportScenarioAsCode ⭐ **NEW**
+Export recorded scenario as executable test code for various frameworks. Automatically cleans unstable selectors (CSS Modules, styled-components, Emotion).
+
+- **Parameters**:
+  - `scenarioName` (required): Name of scenario to export
+  - `language` (required): Target framework - `"playwright-typescript"`, `"playwright-python"`, `"selenium-python"`, `"selenium-java"`
+  - `cleanSelectors` (optional): Remove unstable CSS classes (default: true)
+  - `includeComments` (optional): Include descriptive comments (default: true)
+  - `directory` (optional): Directory where scenarios are stored (auto-detected if not provided)
+
+- **Use case**: Convert recorded scenarios into maintainable test code
+
+- **Returns**: Generated test code as string
+
+- **Example**:
+  ```javascript
+  // Export scenario as Playwright TypeScript
+  exportScenarioAsCode({
+    scenarioName: "checkout_flow",
+    language: "playwright-typescript",
+    cleanSelectors: true,
+    includeComments: true
+  })
+
+  // Returns clean test code:
+  // import { test, expect } from '@playwright/test';
+  //
+  // test('checkout_flow', async ({ page }) => {
+  //   await page.goto('https://example.com');
+  //   await page.locator('button[data-testid="add-to-cart"]').click();
+  //   await expect(page).toHaveURL(/checkout/);
+  // });
+  ```
+
+- **Selector Cleaning**: Automatically removes unstable patterns:
+  - CSS Modules: `Button_primary__2x3yZ` → removed
+  - Styled-components: `sc-AbCdEf-0` → removed
+  - Emotion: `css-1a2b3c4d` → removed
+  - Hash suffixes: `component_a1b2c3d` → removed
+  - Prefers stable selectors: `data-testid`, `role`, `aria-label`, semantic attributes
+
 ---
 
 ## Typical Workflow Example
@@ -667,6 +737,54 @@ If you don't need to see the browser window, you can use xvfb (virtual X server)
 
 This runs Chrome in GUI mode but on a virtual display (window is not visible).
 
+### Figma API Token Setup
+
+To use Figma tools, you need to configure your Figma Personal Access Token.
+
+**How to get your Figma token:**
+1. Go to your Figma account settings: https://www.figma.com/settings
+2. Scroll down to "Personal access tokens"
+3. Click "Create a new personal access token"
+4. Give it a name (e.g., "chrometools-mcp")
+5. Copy the generated token
+
+**Add token to MCP configuration:**
+
+**Claude Desktop** (`~/.claude/mcp_config.json` or `~/AppData/Roaming/Claude/mcp_config.json` on Windows):
+
+```json
+{
+  "mcpServers": {
+    "chrometools": {
+      "command": "npx",
+      "args": ["-y", "chrometools-mcp"],
+      "env": {
+        "FIGMA_TOKEN": "your-figma-token-here"
+      }
+    }
+  }
+}
+```
+
+**Claude Code** (`~/.claude.json`):
+
+```json
+{
+  "mcpServers": {
+    "chrometools": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "chrometools-mcp"],
+      "env": {
+        "FIGMA_TOKEN": "your-figma-token-here"
+      }
+    }
+  }
+}
+```
+
+**Note:** Alternatively, you can pass the token directly in each Figma tool call using the `figmaToken` parameter, but using the environment variable is more convenient.
+
 ---
 
 ## WSL Setup Guide

package/element-finder-utils.js

@@ -295,6 +295,16 @@ function scoreInputField(element, context, description) {
   return score;
 }
 
+/**
+ * Check if attribute value is safe to use in CSS selector
+ * Returns false if value contains characters that could break selector syntax
+ */
+function isSafeSelectorValue(value) {
+  if (!value || typeof value !== 'string') return false;
+  // Check for problematic characters: quotes, brackets, backslashes
+  return !/["'\\[\]{}()]/.test(value);
+}
+
 /**
  * Generate unique CSS selector for an element
  */
@@ -320,23 +330,32 @@ function getUniqueSelectorInPage(element) {
     }
   }
 
-  // Try name attribute
-  if (element.name) {
+  // Try name attribute (only if value is safe)
+  if (element.name && isSafeSelectorValue(element.name)) {
     const selector = `${element.tagName.toLowerCase()}[name="${element.name}"]`;
-    if (document.querySelectorAll(selector).length === 1) {
-      return selector;
+    try {
+      if (document.querySelectorAll(selector).length === 1) {
+        return selector;
+      }
+    } catch (e) {
+      // Invalid selector, skip
     }
   }
 
-  // Try data attributes
+  // Try data attributes (only if values are safe)
   const dataAttrs = Array.from(element.attributes)
-    .filter(attr => attr.name.startsWith('data-'))
+    .filter(attr => attr.name.startsWith('data-') && isSafeSelectorValue(attr.value))
     .slice(0, 2);
 
   for (const attr of dataAttrs) {
     const selector = `${element.tagName.toLowerCase()}[${attr.name}="${attr.value}"]`;
-    if (document.querySelectorAll(selector).length === 1) {
-      return selector;
+    try {
+      if (document.querySelectorAll(selector).length === 1) {
+        return selector;
+      }
+    } catch (e) {
+      // Invalid selector, skip
+      continue;
     }
   }
 

package/index.js

@@ -47,6 +47,18 @@ import {
   deleteScenario
 } from './recorder/scenario-storage.js';
 
+// Import Project Detection
+import { detectProjectRoot } from './utils/project-detector.js';
+
+// Import Code Generators
+import { PlaywrightTypeScriptGenerator } from './utils/code-generators/playwright-typescript.js';
+import { PlaywrightPythonGenerator } from './utils/code-generators/playwright-python.js';
+import { SeleniumPythonGenerator } from './utils/code-generators/selenium-python.js';
+import { SeleniumJavaGenerator } from './utils/code-generators/selenium-java.js';
+
+// Global state for scenarios directory
+let currentScenariosDirectory = null;
+
 // Import Figma tools
 import {
   parseFigmaUrl,
@@ -76,6 +88,32 @@ const isWSL = (() => {
 // Detect Windows environment (including WSL)
 const isWindows = process.platform === 'win32' || isWSL;
 
+/**
+ * Get base directory for scenarios storage
+ * Uses cascade strategy: explicit param → remembered → auto-detect
+ * @param {string|null} explicitDir - Optional explicit directory path
+ * @returns {string} - Base directory path
+ */
+function getScenariosBaseDir(explicitDir = null) {
+  // 1. If explicitly provided - remember and return
+  if (explicitDir) {
+    currentScenariosDirectory = path.resolve(explicitDir);
+    console.log('[chrometools-mcp] Using explicit directory:', currentScenariosDirectory);
+    return currentScenariosDirectory;
+  }
+
+  // 2. If already remembered - return
+  if (currentScenariosDirectory) {
+    console.log('[chrometools-mcp] Using remembered directory:', currentScenariosDirectory);
+    return currentScenariosDirectory;
+  }
+
+  // 3. Auto-detect from environment
+  const detected = detectProjectRoot();
+  currentScenariosDirectory = detected;
+  return detected;
+}
+
 // Get Chrome executable path based on platform
 function getChromePath() {
   if (process.platform === 'win32') {
@@ -398,7 +436,8 @@ async function setupRecorderAutoReinjection(page) {
       // Check if this page had recorder before
       if (pagesWithRecorder.has(page)) {
         try {
-          await injectRecorder(page);
+          const baseDir = getScenariosBaseDir();
+          await injectRecorder(page, baseDir);
         } catch (error) {
           console.error('[chrometools-mcp] Failed to re-inject recorder:', error.message);
         }
@@ -411,7 +450,8 @@ async function setupRecorderAutoReinjection(page) {
     // Check if this page had recorder before
     if (pagesWithRecorder.has(page)) {
       try {
-        await injectRecorder(page);
+        const baseDir = getScenariosBaseDir();
+        await injectRecorder(page, baseDir);
       } catch (error) {
         console.error('[chrometools-mcp] Failed to re-inject recorder after reload:', error.message);
       }
@@ -1576,7 +1616,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         description: "Inject recorder UI widget. Visual recording with start/stop/save controls.",
         inputSchema: {
           type: "object",
-          properties: {},
+          properties: {
+            directory: { type: "string", description: "Directory to save scenarios (optional, defaults to auto-detected project root)" },
+          },
         },
       },
       {
@@ -1588,6 +1630,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             name: { type: "string", description: "Scenario name" },
             parameters: { type: "object", description: "Execution parameters" },
             executeDependencies: { type: "boolean", description: "Execute dependencies (default: true)" },
+            directory: { type: "string", description: "Directory where scenarios are stored (optional, defaults to auto-detected project root)" },
           },
           required: ["name"],
         },
@@ -1597,7 +1640,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         description: "List all scenarios with metadata.",
         inputSchema: {
           type: "object",
-          properties: {},
+          properties: {
+            directory: { type: "string", description: "Directory where scenarios are stored (optional, defaults to auto-detected project root)" },
+          },
         },
       },
       {
@@ -1608,6 +1653,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           properties: {
             text: { type: "string", description: "Search text" },
             tags: { type: "array", items: { type: "string" }, description: "Filter tags" },
+            directory: { type: "string", description: "Directory where scenarios are stored (optional, defaults to auto-detected project root)" },
           },
         },
       },
@@ -1619,6 +1665,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           properties: {
             name: { type: "string", description: "Scenario name" },
             includeSecrets: { type: "boolean", description: "Include secrets (default: false)" },
+            directory: { type: "string", description: "Directory where scenarios are stored (optional, defaults to auto-detected project root)" },
           },
           required: ["name"],
         },
@@ -1630,10 +1677,42 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           type: "object",
           properties: {
             name: { type: "string", description: "Scenario name" },
+            directory: { type: "string", description: "Directory where scenarios are stored (optional, defaults to auto-detected project root)" },
           },
           required: ["name"],
         },
       },
+      {
+        name: "exportScenarioAsCode",
+        description: "Export recorded scenario as executable test code for various frameworks. Automatically cleans unstable selectors (CSS modules, styled-components).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            scenarioName: {
+              type: "string",
+              description: "Name of scenario to export"
+            },
+            language: {
+              type: "string",
+              enum: ["playwright-typescript", "playwright-python", "selenium-python", "selenium-java"],
+              description: "Target test framework and language"
+            },
+            cleanSelectors: {
+              type: "boolean",
+              description: "Remove unstable CSS classes (default: true)"
+            },
+            includeComments: {
+              type: "boolean",
+              description: "Include descriptive comments (default: true)"
+            },
+            directory: {
+              type: "string",
+              description: "Directory where scenarios are stored (optional, defaults to auto-detected project root)"
+            },
+          },
+          required: ["scenarioName", "language"],
+        },
+      },
     ],
   };
 });
@@ -3392,8 +3471,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
 
     if (name === "enableRecorder") {
+      const baseDir = getScenariosBaseDir(args.directory);
       const page = await getLastOpenPage();
-      const result = await injectRecorder(page);
+      const result = await injectRecorder(page, baseDir);
 
       // Track this page as having recorder enabled
       if (result.success) {
@@ -3415,8 +3495,48 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
 
     if (name === "executeScenario") {
-      const page = await getLastOpenPage();
-      const options = {};
+      // Get base directory for scenarios
+      const baseDir = getScenariosBaseDir(args.directory);
+
+      // Try to get existing page, or auto-open browser using scenario's entryUrl
+      let page;
+      try {
+        page = await getLastOpenPage();
+      } catch (error) {
+        // No page is open - load scenario and open browser at entryUrl
+        const scenario = await loadScenario(args.name, false, baseDir);
+        if (!scenario) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: false,
+                error: `Scenario "${args.name}" not found`
+              }, null, 2)
+            }]
+          };
+        }
+
+        const entryUrl = scenario.metadata?.entryUrl;
+        if (!entryUrl) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: false,
+                error: `Scenario "${args.name}" has no entryUrl. Cannot auto-open browser.`
+              }, null, 2)
+            }]
+          };
+        }
+
+        // Auto-open browser at scenario's entry URL
+        page = await getOrCreatePage(entryUrl);
+      }
+
+      const options = {
+        baseDir: baseDir
+      };
 
       // Pass executeDependencies option if provided
       if (args.executeDependencies !== undefined) {
@@ -3434,7 +3554,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
 
     if (name === "listScenarios") {
-      const scenarios = await listScenarios();
+      const baseDir = getScenariosBaseDir(args.directory);
+      const scenarios = await listScenarios(baseDir);
 
       return {
         content: [{
@@ -3445,7 +3566,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
 
     if (name === "searchScenarios") {
-      const results = await searchScenarios(args);
+      const baseDir = getScenariosBaseDir(args.directory);
+      const results = await searchScenarios(args, baseDir);
 
       return {
         content: [{
@@ -3456,7 +3578,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
 
     if (name === "getScenarioInfo") {
-      const scenario = await loadScenario(args.name, args.includeSecrets || false);
+      const baseDir = getScenariosBaseDir(args.directory);
+      const scenario = await loadScenario(args.name, args.includeSecrets || false, baseDir);
 
       return {
         content: [{
@@ -3467,7 +3590,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
 
     if (name === "deleteScenario") {
-      const result = await deleteScenario(args.name);
+      const baseDir = getScenariosBaseDir(args.directory);
+      const result = await deleteScenario(args.name, baseDir);
 
       return {
         content: [{
@@ -3477,6 +3601,65 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       };
     }
 
+    if (name === "exportScenarioAsCode") {
+      const baseDir = getScenariosBaseDir(args.directory);
+      const scenario = await loadScenario(args.scenarioName, false, baseDir);
+
+      if (!scenario) {
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              error: `Scenario "${args.scenarioName}" not found`
+            }, null, 2)
+          }],
+          isError: true
+        };
+      }
+
+      // Select generator based on language
+      let generator;
+      const options = {
+        cleanSelectors: args.cleanSelectors !== false, // default true
+        includeComments: args.includeComments !== false, // default true
+      };
+
+      switch (args.language) {
+        case 'playwright-typescript':
+          generator = new PlaywrightTypeScriptGenerator(options);
+          break;
+        case 'playwright-python':
+          generator = new PlaywrightPythonGenerator(options);
+          break;
+        case 'selenium-python':
+          generator = new SeleniumPythonGenerator(options);
+          break;
+        case 'selenium-java':
+          generator = new SeleniumJavaGenerator(options);
+          break;
+        default:
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                error: `Unknown language: ${args.language}. Supported: playwright-typescript, playwright-python, selenium-python, selenium-java`
+              }, null, 2)
+            }],
+            isError: true
+          };
+      }
+
+      // Generate code
+      const code = generator.generate(scenario, options);
+
+      return {
+        content: [{
+          type: 'text',
+          text: code
+        }]
+      };
+    }
+
     return {
       content: [
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrometools-mcp",
-  "version": "1.7.1",
+  "version": "1.8.2",
   "description": "MCP (Model Context Protocol) server for Chrome automation using Puppeteer. Persistent browser sessions, visual testing, Figma comparison, and design validation. Works seamlessly in WSL, Linux, and macOS.",
   "type": "module",
   "main": "index.js",