chrometools-mcp 1.9.1 → 2.3.2

package/recorder/recorder-script.js

@@ -27,6 +27,56 @@ export function generateRecorderScript() {
 (function() {
   'use strict';
 
+  // ==========================
+  // URL TO PROJECT UTILITIES
+  // ==========================
+
+  /**
+   * Extract project ID from URL (browser version)
+   * @param {string} url - Full URL
+   * @returns {string} - Project ID
+   */
+  function urlToProjectId(url) {
+    try {
+      if (url.startsWith('file://')) {
+        return 'local';
+      }
+
+      const urlObj = new URL(url);
+      let hostname = urlObj.hostname.toLowerCase();
+      const port = urlObj.port;
+
+      hostname = hostname.replace(/^www\\./, '');
+      const parts = hostname.split('.');
+
+      if (parts.length === 1) {
+        const projectId = sanitizeProjectId(parts[0]);
+        return port ? \`\${projectId}-\${port}\` : projectId;
+      }
+
+      const mainDomain = parts[parts.length - 2];
+      const projectId = sanitizeProjectId(mainDomain);
+      return port ? \`\${projectId}-\${port}\` : projectId;
+
+    } catch (error) {
+      console.error('[url-to-project] Invalid URL:', url, error);
+      return 'unknown';
+    }
+  }
+
+  /**
+   * Sanitize project ID (browser version)
+   * @param {string} id - Raw project ID
+   * @returns {string} - Sanitized ID
+   */
+  function sanitizeProjectId(id) {
+    return id
+      .toLowerCase()
+      .replace(/[^a-z0-9-]/g, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-|-$/g, '');
+  }
+
   // ==========================
   // RECORDER STATE
   // ==========================
@@ -1393,7 +1443,10 @@ export function generateRecorderScript() {
     // Call MCP server via exposed function
     if (window.saveScenarioToMCP) {
       try {
-        const result = await window.saveScenarioToMCP(scenario);
+        // Extract projectId from URL
+        const urlProjectId = urlToProjectId(state.startUrl || window.location.href);
+
+        const result = await window.saveScenarioToMCP(scenario, urlProjectId);
         if (result.success) {
           // Set clearing flag to prevent any saves during cleanup
           isClearing = true;
@@ -1651,9 +1704,10 @@ export function generateRecorderScript() {
 
 /**
  * Inject recorder into page
+ * Project ID will be automatically determined from URL in browser context
  * @param {Object} page - Puppeteer page instance
  */
-export async function injectRecorder(page, baseDir) {
+export async function injectRecorder(page) {
   try {
     // Check if recorder is already injected
     const alreadyInjected = await page.evaluate(() => {
@@ -1681,20 +1735,20 @@ export async function injectRecorder(page, baseDir) {
 
     // Only expose functions if they don't exist yet
     if (!functionExists) {
-      await page.exposeFunction('saveScenarioToMCP', async (scenarioData) => {
+      // saveScenarioToMCP now receives urlProjectId from browser
+      await page.exposeFunction('saveScenarioToMCP', async (scenarioData, urlProjectId) => {
         const { saveScenario } = await import('./scenario-storage.js');
-        return await saveScenario(scenarioData, baseDir);
+        return await saveScenario(scenarioData, urlProjectId);
       });
 
+      // listScenariosFromMCP returns ALL scenarios (no filtering by project)
       await page.exposeFunction('listScenariosFromMCP', async () => {
-        const { loadIndex } = await import('./scenario-storage.js');
-        const path = await import('path');
+        const { listScenarios } = await import('./scenario-storage.js');
         try {
-          const scenariosDir = path.join(baseDir, 'scenarios');
-          const index = await loadIndex(scenariosDir);
+          const scenarios = await listScenarios(null, true); // null projectId, allProjects=true
           return {
             success: true,
-            scenarios: Object.values(index)
+            scenarios: scenarios
           };
         } catch (error) {
           return {

package/recorder/scenario-executor.js

@@ -21,16 +21,16 @@ const debugLog = DEBUG_MODE ? console.error : () => {};
  * @param {string} scenarioName - Scenario to execute
  * @param {Object} page - Puppeteer page instance
  * @param {Object} params - Parameters for scenario
- * @param {Object} options - Execution options { executeDependencies, skipConditions, maxRetries, timeout, baseDir }
+ * @param {Object} options - Execution options { executeDependencies, skipConditions, maxRetries, timeout }
  * @returns {Object} - Execution result
  */
 export async function executeScenario(scenarioName, page, params = {}, options = {}) {
   const {
-    executeDependencies = true,  // NEW: Execute dependencies by default
+    executeDependencies = true,  // Execute dependencies by default
     skipConditions = false,
     maxRetries = 3,
     timeout = 30000,
-    baseDir  // Base directory for scenarios
+    projectId = null  // Optional projectId for disambiguation
   } = options;
 
   const result = {
@@ -45,30 +45,50 @@ export async function executeScenario(scenarioName, page, params = {}, options =
   const startTime = Date.now();
 
   try {
-    // Load scenario index
-    const path = await import('path');
-    const scenariosDir = path.join(baseDir, 'scenarios');
-    const scenarioIndex = await loadIndex(scenariosDir);
+    // Load scenario to get its metadata (needed for dependency resolution)
+    const initialScenario = await loadScenario(scenarioName, false, projectId);
 
-    let chain = [scenarioName]; // Default: execute only the requested scenario
+    if (!initialScenario) {
+      result.errors.push(`Scenario "${scenarioName}" not found`);
+      return result;
+    }
 
-    // Resolve and execute dependencies if enabled
-    if (executeDependencies) {
-      const resolution = resolveDependencies(scenarioName, scenarioIndex, { skipConditions });
+    // Check for name collision
+    if (initialScenario.collision) {
+      result.errors.push(initialScenario.message);
+      result.availableProjectIds = initialScenario.availableProjectIds;
+      return result;
+    }
 
-      if (resolution.errors.length > 0) {
-        result.errors.push(...resolution.errors);
-        return result;
-      }
+    let chain = [{ name: scenarioName, projectId }]; // Default: execute only the requested scenario
 
-      chain = resolution.chain; // Use full dependency chain
+    // Resolve and execute dependencies if enabled
+    if (executeDependencies && initialScenario.metadata?.dependencies) {
+      // Build a simplified index from metadata for dependency resolution
+      // In the new system, we need to resolve cross-project dependencies
+      // Dependencies inherit parent's projectId unless they specify their own
+      chain = [
+        ...initialScenario.metadata.dependencies.map(dep => ({
+          name: dep.scenario,
+          projectId: dep.projectId || projectId // Use explicit projectId or inherit from parent
+        })),
+        { name: scenarioName, projectId }
+      ];
     }
 
     // Execute chain in order
-    for (const name of chain) {
-      const scenario = await loadScenario(name, false, baseDir);
+    for (const item of chain) {
+      const scenario = await loadScenario(item.name, true, item.projectId); // Load with secrets, using item's projectId
+
       if (!scenario) {
-        result.errors.push(`Scenario "${name}" not found`);
+        result.errors.push(`Scenario "${item.name}" not found`);
+        return result;
+      }
+
+      // Check for name collision in dependencies
+      if (scenario.collision) {
+        result.errors.push(`Dependency "${item.name}": ${scenario.message}`);
+        result.availableProjectIds = scenario.availableProjectIds;
         return result;
       }
 
@@ -80,19 +100,15 @@ export async function executeScenario(scenarioName, page, params = {}, options =
             const shouldExecute = await checkDependencyCondition(dep.condition, context);
 
             if (!shouldExecute) {
-              debugLog(`Skipping scenario "${name}" due to condition`);
+              debugLog(`Skipping scenario "${item.name}" due to condition`);
               continue;
             }
           }
         }
       }
 
-      // Load secrets
-      const secretsDir = path.join(baseDir, 'secrets');
-      const secrets = await loadSecrets(name, secretsDir);
-
       // Merge secrets with params
-      const executionParams = { ...params, ...secrets };
+      const executionParams = { ...params, ...(scenario.secrets || {}) };
 
       // Execute scenario
       const scenarioResult = await executeSingleScenario(scenario, page, executionParams, {
@@ -100,7 +116,7 @@ export async function executeScenario(scenarioName, page, params = {}, options =
         timeout
       });
 
-      result.executedScenarios.push(name);
+      result.executedScenarios.push(item.name);
 
       if (!scenarioResult.success) {
         result.errors.push(...scenarioResult.errors);
@@ -170,7 +186,11 @@ async function executeSingleScenario(scenario, page, params = {}, options = {})
 
     // Validate final URL if exitUrl is specified in metadata
     if (scenario.metadata?.exitUrl) {
-      const currentUrl = page.url();
+      // Wait a bit for any pending navigation/redirects to complete
+      await new Promise(resolve => setTimeout(resolve, 500));
+
+      // Get current URL from the page (more reliable than page.url() for recent navigation)
+      const currentUrl = await page.evaluate(() => window.location.href);
       const expectedUrl = scenario.metadata.exitUrl;
 
       // Normalize URLs for comparison (remove trailing slashes, fragments)

package/recorder/scenario-storage.js

@@ -4,21 +4,168 @@
  * Manages scenario and secrets storage:
  * 1. Save/load scenarios to/from files
  * 2. Save/load secrets separately
- * 3. Maintain scenario index with metadata
+ * 3. Maintain project-specific and global indexes
  * 4. Ensure .gitignore for secrets directory
  */
 
 import fs from 'fs/promises';
+import fssync from 'fs';
 import path from 'path';
+import { homedir } from 'os';
 
 // Constants
 const INDEX_FILE = 'index.json';
 const GITIGNORE_FILE = '.gitignore';
+const BASE_STORAGE_DIR = path.join(homedir(), '.config', 'chrometools-mcp');
+const GLOBAL_INDEX_PATH = path.join(BASE_STORAGE_DIR, 'index.json');
+const PROJECTS_DIR = path.join(BASE_STORAGE_DIR, 'projects');
+
+/**
+ * Load global index from ~/.config/chrometools-mcp/index.json
+ * @returns {object} - Global index object
+ */
+function loadGlobalIndex() {
+  try {
+    const data = fssync.readFileSync(GLOBAL_INDEX_PATH, 'utf-8');
+    return JSON.parse(data);
+  } catch (err) {
+    // Index doesn't exist yet, return empty structure
+    return {
+      version: '2.0',
+      projects: {}
+    };
+  }
+}
+
+/**
+ * Save global index to ~/.config/chrometools-mcp/index.json
+ * @param {object} index - Global index object
+ */
+async function saveGlobalIndex(index) {
+  await fs.mkdir(BASE_STORAGE_DIR, { recursive: true });
+  await fs.writeFile(GLOBAL_INDEX_PATH, JSON.stringify(index, null, 2), 'utf-8');
+}
+
+/**
+ * Update global index with scenario metadata
+ * @param {string} projectId - Project identifier
+ * @param {string} projectPath - Full path to project root
+ * @param {string} scenarioName - Scenario name
+ * @param {object} metadata - Scenario metadata
+ */
+async function updateGlobalIndex(projectId, projectPath, scenarioName, metadata) {
+  const index = loadGlobalIndex();
+
+  if (!index.projects[projectId]) {
+    index.projects[projectId] = {
+      projectPath,
+      lastAccessed: new Date().toISOString(),
+      scenarios: {}
+    };
+  }
+
+  index.projects[projectId].scenarios[scenarioName] = {
+    name: scenarioName,
+    description: metadata.description || '',
+    tags: metadata.tags || [],
+    dependencies: metadata.dependencies || [],
+    parameters: metadata.parameters || {},
+    outputs: metadata.outputs || [],
+    entryUrl: metadata.entryUrl || null,
+    exitUrl: metadata.exitUrl || null,
+    createdAt: index.projects[projectId].scenarios[scenarioName]?.createdAt || new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+  };
+
+  index.projects[projectId].lastAccessed = new Date().toISOString();
+
+  await saveGlobalIndex(index);
+}
+
+/**
+ * Remove scenario from global index
+ * @param {string} projectId - Project identifier
+ * @param {string} scenarioName - Scenario name
+ */
+async function removeFromGlobalIndex(projectId, scenarioName) {
+  const index = loadGlobalIndex();
+
+  if (index.projects[projectId]?.scenarios[scenarioName]) {
+    delete index.projects[projectId].scenarios[scenarioName];
+
+    // Remove project if no scenarios left
+    if (Object.keys(index.projects[projectId].scenarios).length === 0) {
+      delete index.projects[projectId];
+    }
+
+    await saveGlobalIndex(index);
+  }
+}
+
+/**
+ * Find scenario in global index
+ * @param {string} scenarioName - Scenario name
+ * @param {string|null} projectId - Optional project filter
+ * @returns {object|null} - { projectId, metadata } or null
+ */
+/**
+ * Find all scenarios with the given name across all projects
+ * @param {string} scenarioName - Scenario name
+ * @returns {Array} - Array of { projectId, metadata } objects
+ */
+function findAllScenariosWithName(scenarioName) {
+  const index = loadGlobalIndex();
+  const results = [];
+
+  for (const [pid, project] of Object.entries(index.projects)) {
+    if (project.scenarios[scenarioName]) {
+      results.push({
+        projectId: pid,
+        metadata: project.scenarios[scenarioName]
+      });
+    }
+  }
+
+  return results;
+}
+
+function findScenarioInGlobalIndex(scenarioName, projectId = null) {
+  const index = loadGlobalIndex();
+
+  if (projectId) {
+    // Search in specific project
+    if (index.projects[projectId]?.scenarios[scenarioName]) {
+      return {
+        projectId,
+        metadata: index.projects[projectId].scenarios[scenarioName]
+      };
+    }
+    return null;
+  }
+
+  // Search in all projects - check for collisions
+  const allMatches = findAllScenariosWithName(scenarioName);
+
+  if (allMatches.length === 0) {
+    return null;
+  }
+
+  if (allMatches.length > 1) {
+    // Multiple scenarios with same name - return collision error
+    return {
+      collision: true,
+      matches: allMatches.map(m => m.projectId)
+    };
+  }
+
+  // Single match - return it
+  return allMatches[0];
+}
 
 /**
  * Initialize storage directories
  * Creates directories and ensures .gitignore exists
- * @param {string} baseDir - Base directory for scenarios and secrets
+ * @param {string} baseDir - Base directory for scenarios and secrets (project directory)
  */
 export async function initializeStorage(baseDir) {
   const scenariosDir = path.join(baseDir, 'scenarios');
@@ -64,12 +211,18 @@ async function ensureSecretsGitignore(secretsDir) {
 /**
  * Save scenario to file
  * @param {Object} scenario - Scenario data
- * @param {string} baseDir - Base directory for storage
+ * @param {string} urlProjectId - Project identifier extracted from URL (e.g., "google", "localhost-3000")
  * @returns {Object} - { success: boolean, path: string, error?: string }
  */
-export async function saveScenario(scenario, baseDir) {
+export async function saveScenario(scenario, urlProjectId) {
   try {
-    await initializeStorage(baseDir);
+    // Use URL-based projectId directly
+    const projectId = urlProjectId;
+    const projectPath = `url://${urlProjectId}`;
+
+    // Get project directory
+    const projectDir = path.join(PROJECTS_DIR, projectId);
+    await initializeStorage(projectDir);
 
     const { name, metadata, chain, secrets } = scenario;
 
@@ -81,13 +234,20 @@ export async function saveScenario(scenario, baseDir) {
       };
     }
 
-    const scenariosDir = path.join(baseDir, 'scenarios');
-    const secretsDir = path.join(baseDir, 'secrets');
+    const scenariosDir = path.join(projectDir, 'scenarios');
+    const secretsDir = path.join(projectDir, 'secrets');
+
+    // Add project info to metadata
+    const enhancedMetadata = {
+      ...(metadata || {}),
+      projectId,
+      projectPath
+    };
 
     // Save main scenario file (without secrets)
     const scenarioData = {
       name,
-      metadata: metadata || {},
+      metadata: enhancedMetadata,
       chain,
       version: '1.0',
       createdAt: new Date().toISOString()
@@ -101,8 +261,11 @@ export async function saveScenario(scenario, baseDir) {
       await saveSecrets(name, secrets, secretsDir);
     }
 
-    // Update index
-    await updateIndex(name, metadata, scenariosDir);
+    // Update project-local index
+    await updateIndex(name, enhancedMetadata, scenariosDir);
+
+    // Update global index
+    await updateGlobalIndex(projectId, projectPath, name, enhancedMetadata);
 
     return {
       success: true,
@@ -120,19 +283,40 @@ export async function saveScenario(scenario, baseDir) {
  * Load scenario from file
  * @param {string} name - Scenario name
  * @param {boolean} includeSecrets - Whether to load secrets
- * @param {string} baseDir - Base directory for storage
+ * @param {string|null} projectId - Optional project ID filter
  * @returns {Object} - Scenario data or null
  */
-export async function loadScenario(name, includeSecrets = false, baseDir) {
+export async function loadScenario(name, includeSecrets = false, projectId = null) {
   try {
-    const scenariosDir = path.join(baseDir, 'scenarios');
+    // Find scenario in global index
+    const result = findScenarioInGlobalIndex(name, projectId);
+
+    if (!result) {
+      console.error(`Scenario "${name}" not found${projectId ? ` in project "${projectId}"` : ''}`);
+      return null;
+    }
+
+    // Check for name collision
+    if (result.collision) {
+      const error = {
+        collision: true,
+        message: `Multiple scenarios named "${name}" found. Please specify projectId.`,
+        availableProjectIds: result.matches
+      };
+      console.error(error.message, 'Available projectIds:', result.matches);
+      return error;
+    }
+
+    // Load from project directory
+    const projectDir = path.join(PROJECTS_DIR, result.projectId);
+    const scenariosDir = path.join(projectDir, 'scenarios');
     const scenarioPath = path.join(scenariosDir, `${name}.json`);
     const content = await fs.readFile(scenarioPath, 'utf-8');
     const scenario = JSON.parse(content);
 
     // Load secrets if requested
     if (includeSecrets) {
-      const secretsDir = path.join(baseDir, 'secrets');
+      const secretsDir = path.join(projectDir, 'secrets');
       const secrets = await loadSecrets(name, secretsDir);
       if (secrets) {
         scenario.secrets = secrets;
@@ -235,25 +419,51 @@ async function saveIndex(index, scenariosDir) {
 
 /**
  * List all available scenarios
- * @param {string} baseDir - Base directory for storage
+ * @param {string} currentProjectId - Current project identifier
+ * @param {boolean} allProjects - Whether to list scenarios from all projects
  * @returns {Array} - Array of scenario metadata
  */
-export async function listScenarios(baseDir) {
-  const scenariosDir = path.join(baseDir, 'scenarios');
-  const index = await loadIndex(scenariosDir);
-  return Object.values(index);
+export async function listScenarios(currentProjectId, allProjects = false) {
+  const globalIndex = loadGlobalIndex();
+  const results = [];
+
+  if (allProjects) {
+    // Return scenarios from all projects
+    for (const [projectId, project] of Object.entries(globalIndex.projects)) {
+      for (const scenario of Object.values(project.scenarios)) {
+        results.push({
+          ...scenario,
+          projectId,
+          projectPath: project.projectPath
+        });
+      }
+    }
+  } else {
+    // Return scenarios from current project only
+    if (globalIndex.projects[currentProjectId]) {
+      for (const scenario of Object.values(globalIndex.projects[currentProjectId].scenarios)) {
+        results.push({
+          ...scenario,
+          projectId: currentProjectId,
+          projectPath: globalIndex.projects[currentProjectId].projectPath
+        });
+      }
+    }
+  }
+
+  return results;
 }
 
 /**
  * Search scenarios by query
  * @param {Object} query - Search query { tags?, text?, dependencies? }
- * @param {string} baseDir - Base directory for storage
+ * @param {string} currentProjectId - Current project identifier
+ * @param {boolean} allProjects - Whether to search in all projects
  * @returns {Array} - Matching scenarios
  */
-export async function searchScenarios(query, baseDir) {
-  const scenariosDir = path.join(baseDir, 'scenarios');
-  const index = await loadIndex(scenariosDir);
-  const scenarios = Object.values(index);
+export async function searchScenarios(query, currentProjectId, allProjects = false) {
+  // Get all scenarios based on allProjects flag
+  const scenarios = await listScenarios(currentProjectId, allProjects);
 
   let results = scenarios;
 
@@ -286,13 +496,22 @@ export async function searchScenarios(query, baseDir) {
 /**
  * Delete scenario
  * @param {string} name - Scenario name
- * @param {string} baseDir - Base directory for storage
+ * @param {string|null} projectId - Optional project ID filter
  * @returns {boolean} - Success
  */
-export async function deleteScenario(name, baseDir) {
+export async function deleteScenario(name, projectId = null) {
   try {
-    const scenariosDir = path.join(baseDir, 'scenarios');
-    const secretsDir = path.join(baseDir, 'secrets');
+    // Find scenario in global index
+    const result = findScenarioInGlobalIndex(name, projectId);
+
+    if (!result) {
+      console.error(`Scenario "${name}" not found${projectId ? ` in project "${projectId}"` : ''}`);
+      return false;
+    }
+
+    const projectDir = path.join(PROJECTS_DIR, result.projectId);
+    const scenariosDir = path.join(projectDir, 'scenarios');
+    const secretsDir = path.join(projectDir, 'secrets');
 
     // Delete scenario file
     const scenarioPath = path.join(scenariosDir, `${name}.json`);
@@ -306,11 +525,14 @@ export async function deleteScenario(name, baseDir) {
       // Secrets file may not exist
     }
 
-    // Remove from index
+    // Remove from project-local index
     const index = await loadIndex(scenariosDir);
     delete index[name];
     await saveIndex(index, scenariosDir);
 
+    // Remove from global index
+    await removeFromGlobalIndex(result.projectId, name);
+
     return true;
   } catch (error) {
     console.error(`Error deleting scenario "${name}":`, error.message);