@dynamicu/chromedebug-mcp 2.5.5 → 2.5.6

package/src/commands/install-pro.js.bak

@@ -0,0 +1,542 @@
+/**
+ * ChromeDebug PRO License Installer
+ *
+ * Handles installation of PRO extension after purchase:
+ * - Validates license key format
+ * - Extracts PRO extension ZIP to ~/.chromedebug-pro/extension/
+ * - Saves license information to ~/.chromedebug-pro/license.json
+ * - Configures shell environment for CHROMEDEBUG_EXTENSION_PATH
+ */
+
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+import os from 'os';
+import { execSync } from 'child_process';
+import AdmZip from 'adm-zip';
+
+// Constants
+const CHROMEDEBUG_DIR = path.join(os.homedir(), '.chromedebug-pro');
+const EXTENSION_DIR = path.join(CHROMEDEBUG_DIR, 'extension');
+const LICENSE_FILE = path.join(CHROMEDEBUG_DIR, 'license.json');
+const INSTALL_LOG = path.join(CHROMEDEBUG_DIR, 'install.log');
+const ENV_VAR_NAME = 'CHROMEDEBUG_EXTENSION_PATH';
+
+// License key format: LICENSEID-HASH (e.g., ABC12345-0123456789ABCDEF)
+const LICENSE_KEY_REGEX = /^[A-Z0-9]{8,}-[A-Z0-9]{16,}$/i;
+
+/**
+ * Log installation activity
+ */
+async function logInstall(message, isError = false) {
+  const timestamp = new Date().toISOString();
+  const logMessage = `[${timestamp}] ${isError ? 'ERROR: ' : ''}${message}\n`;
+
+  try {
+    await fs.appendFile(INSTALL_LOG, logMessage);
+  } catch (err) {
+    // Ignore log errors - don't let logging break installation
+  }
+
+  if (isError) {
+    console.error(message);
+  } else {
+    console.log(message);
+  }
+}
+
+/**
+ * Validate command-line arguments
+ */
+function validateArguments(args) {
+  const licenseIndex = args.indexOf('--license');
+  const pathIndex = args.indexOf('--extension-path');
+
+  if (licenseIndex === -1 || pathIndex === -1) {
+    console.error(`
+ChromeDebug PRO License Installer
+
+Usage:
+  chromedebug-mcp install-pro --license YOUR_LICENSE_KEY --extension-path /path/to/chromedebug-pro-extension.zip
+
+Required Arguments:
+  --license          Your PRO license key (received after purchase)
+  --extension-path   Path to the PRO extension ZIP file
+
+Example:
+  chromedebug-mcp install-pro \\
+    --license ABC12345-0123456789ABCDEF \\
+    --extension-path ~/Downloads/chromedebug-pro-extension.zip
+
+Get PRO: https://chromedebug.com/pro
+`);
+    return null;
+  }
+
+  const license = args[licenseIndex + 1];
+  const extensionPath = args[pathIndex + 1];
+
+  if (!license || !extensionPath) {
+    console.error('Error: Missing values for --license or --extension-path');
+    return null;
+  }
+
+  return { license, extensionPath };
+}
+
+/**
+ * Validate license key format
+ */
+function validateLicenseKey(key) {
+  if (!LICENSE_KEY_REGEX.test(key)) {
+    console.error(`
+Error: Invalid license key format
+
+Expected format: LICENSEID-HASH
+Example: ABC12345-0123456789ABCDEF
+
+Your key: ${maskLicenseKey(key)}
+
+Please check your purchase confirmation email for the correct license key.
+Need help? https://github.com/dynamicupgrade/ChromeDebug/issues
+`);
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Mask license key for display (show first 6 and last 3 chars)
+ */
+function maskLicenseKey(key) {
+  if (key.length <= 9) return '***';
+  return `${key.substring(0, 6)}...${key.substring(key.length - 3)}`;
+}
+
+/**
+ * Check pre-flight conditions
+ */
+async function preflightChecks() {
+  // Check write permission to home directory
+  try {
+    const testFile = path.join(os.homedir(), '.chromedebug-test');
+    await fs.writeFile(testFile, 'test');
+    await fs.unlink(testFile);
+  } catch (err) {
+    console.error(`
+Error: Cannot write to home directory
+
+Possible causes:
+1. Permission denied - check: ls -ld ~
+2. Disk full - check: df -h ~
+3. Home directory not writable
+
+Need help? https://github.com/dynamicupgrade/ChromeDebug/issues
+`);
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Check for existing installation
+ */
+async function checkExistingInstallation() {
+  try {
+    const stats = await fs.stat(LICENSE_FILE);
+    if (stats.isFile()) {
+      const licenseData = JSON.parse(await fs.readFile(LICENSE_FILE, 'utf-8'));
+      return {
+        exists: true,
+        installed_at: licenseData.installed_at,
+        extension_version: licenseData.extension_version,
+        license_key: licenseData.license_key
+      };
+    }
+  } catch (err) {
+    // No existing installation
+  }
+  return { exists: false };
+}
+
+/**
+ * Prompt for confirmation (synchronous for CLI)
+ */
+function promptConfirmation(message) {
+  // For now, we'll auto-continue with a warning
+  // In future, could add readline for interactive prompts
+  console.log(`\n${message}`);
+  console.log('Continuing with installation...\n');
+  return true;
+}
+
+/**
+ * Extract and validate ZIP file
+ */
+async function extractExtension(zipPath, targetPath) {
+  // Resolve path (handle ~ and relative paths)
+  const resolvedZipPath = zipPath.startsWith('~')
+    ? path.join(os.homedir(), zipPath.slice(1))
+    : path.resolve(zipPath);
+
+  // Check if ZIP exists
+  try {
+    await fs.access(resolvedZipPath);
+  } catch (err) {
+    console.error(`
+Error: Extension ZIP file not found
+
+Path: ${resolvedZipPath}
+
+Please check:
+1. File path is correct
+2. File exists at the specified location
+3. You have read permission
+
+Need help? https://github.com/dynamicupgrade/ChromeDebug/issues
+`);
+    throw err;
+  }
+
+  // Create target directory (clean if exists)
+  try {
+    await fs.rm(targetPath, { recursive: true, force: true });
+  } catch (err) {
+    // Ignore - directory might not exist
+  }
+
+  await fs.mkdir(targetPath, { recursive: true });
+
+  // Extract ZIP
+  try {
+    const zip = new AdmZip(resolvedZipPath);
+    zip.extractAllTo(targetPath, true);
+  } catch (err) {
+    console.error(`
+Error: Failed to extract ZIP file
+
+Possible causes:
+1. ZIP file is corrupted - try re-downloading
+2. Not a valid ZIP file
+3. Disk space full
+
+Error details: ${err.message}
+
+Need help? https://github.com/dynamicupgrade/ChromeDebug/issues
+`);
+    throw err;
+  }
+
+  // Validate extracted contents
+  const manifestPath = path.join(targetPath, 'manifest.json');
+  try {
+    const manifestContent = await fs.readFile(manifestPath, 'utf-8');
+    const manifest = JSON.parse(manifestContent);
+
+    if (!manifest.name || !manifest.name.toLowerCase().includes('chromedebug')) {
+      throw new Error('Extension does not appear to be ChromeDebug');
+    }
+
+    return {
+      version: manifest.version,
+      name: manifest.name
+    };
+  } catch (err) {
+    console.error(`
+Error: Invalid extension package
+
+The extracted files do not appear to be a valid ChromeDebug extension.
+Expected manifest.json with ChromeDebug name.
+
+Please verify you downloaded the correct PRO extension ZIP.
+
+Need help? https://github.com/dynamicupgrade/ChromeDebug/issues
+`);
+    throw err;
+  }
+}
+
+/**
+ * Save license information
+ */
+async function saveLicenseInfo(license, extensionVersion) {
+  const licenseData = {
+    license_key: license,
+    installed_at: new Date().toISOString(),
+    extension_version: extensionVersion,
+    extension_path: EXTENSION_DIR
+  };
+
+  await fs.writeFile(LICENSE_FILE, JSON.stringify(licenseData, null, 2), 'utf-8');
+
+  // Set restrictive permissions (owner read/write only)
+  await fs.chmod(LICENSE_FILE, 0o600);
+}
+
+/**
+ * Detect user's shell
+ */
+function detectShell() {
+  try {
+    const shell = process.env.SHELL || '';
+
+    if (shell.includes('zsh')) return 'zsh';
+    if (shell.includes('bash')) return 'bash';
+    if (shell.includes('fish')) return 'fish';
+
+    // Default to bash
+    return 'bash';
+  } catch (err) {
+    return 'bash';
+  }
+}
+
+/**
+ * Get shell configuration file path
+ */
+function getShellConfigFile(shell) {
+  const home = os.homedir();
+
+  switch (shell) {
+    case 'zsh':
+      return path.join(home, '.zshrc');
+    case 'bash':
+      // Prefer .bashrc on Linux, .bash_profile on macOS
+      if (process.platform === 'darwin') {
+        return path.join(home, '.bash_profile');
+      }
+      return path.join(home, '.bashrc');
+    case 'fish':
+      return path.join(home, '.config', 'fish', 'config.fish');
+    default:
+      return path.join(home, '.bashrc');
+  }
+}
+
+/**
+ * Check if environment variable is already configured
+ */
+async function checkIfAlreadyConfigured(configFile) {
+  try {
+    const content = await fs.readFile(configFile, 'utf-8');
+    const envVarLine = `export ${ENV_VAR_NAME}=`;
+
+    if (content.includes(envVarLine)) {
+      // Check if it's the correct path
+      const regex = new RegExp(`export ${ENV_VAR_NAME}=["']?([^"'\\n]+)["']?`);
+      const match = content.match(regex);
+
+      if (match && match[1]) {
+        const currentPath = match[1].replace(/^~/, os.homedir());
+        const targetPath = EXTENSION_DIR;
+
+        if (path.resolve(currentPath) === path.resolve(targetPath)) {
+          return { configured: true, needsUpdate: false, currentPath };
+        } else {
+          return { configured: true, needsUpdate: true, currentPath };
+        }
+      }
+    }
+  } catch (err) {
+    // File doesn't exist or can't be read
+  }
+
+  return { configured: false, needsUpdate: false };
+}
+
+/**
+ * Update shell configuration
+ */
+async function updateShellConfig(configFile, envVarValue) {
+  // Create backup
+  const backupFile = `${configFile}.chromedebug-backup`;
+  try {
+    await fs.copyFile(configFile, backupFile);
+  } catch (err) {
+    // Config file might not exist yet
+  }
+
+  // Read existing content
+  let content = '';
+  try {
+    content = await fs.readFile(configFile, 'utf-8');
+  } catch (err) {
+    // File doesn't exist, create new
+    if (configFile.includes('.bash')) {
+      content = '#!/bin/bash\n\n';
+    } else if (configFile.includes('.zsh')) {
+      content = '#!/bin/zsh\n\n';
+    }
+  }
+
+  // Check if already configured
+  const status = await checkIfAlreadyConfigured(configFile);
+
+  if (status.configured && !status.needsUpdate) {
+    return { updated: false, reason: 'already_configured' };
+  }
+
+  // Add or update environment variable
+  const envVarLine = `export ${ENV_VAR_NAME}="${envVarValue}"`;
+  const commentLine = '# ChromeDebug PRO extension path';
+
+  if (status.configured && status.needsUpdate) {
+    // Update existing line
+    const regex = new RegExp(`export ${ENV_VAR_NAME}=["']?[^"'\\n]+["']?`, 'g');
+    content = content.replace(regex, envVarLine);
+  } else {
+    // Add new lines
+    if (!content.endsWith('\n')) {
+      content += '\n';
+    }
+    content += `\n${commentLine}\n${envVarLine}\n`;
+  }
+
+  // Write updated content
+  await fs.writeFile(configFile, content, 'utf-8');
+
+  // Ensure proper permissions
+  await fs.chmod(configFile, 0o644);
+
+  return { updated: true, reason: status.needsUpdate ? 'updated' : 'added' };
+}
+
+/**
+ * Configure shell environment
+ */
+async function configureShell() {
+  const shell = detectShell();
+  const configFile = getShellConfigFile(shell);
+
+  await logInstall(`Detected shell: ${shell}`);
+  await logInstall(`Config file: ${configFile}`);
+
+  // Ensure config directory exists (for fish)
+  const configDir = path.dirname(configFile);
+  await fs.mkdir(configDir, { recursive: true });
+
+  // Update configuration
+  const result = await updateShellConfig(configFile, EXTENSION_DIR);
+
+  return { shell, configFile, ...result };
+}
+
+/**
+ * Main installation flow
+ */
+export async function installPro(args) {
+  console.log('\nChromeDebug PRO License Installer\n');
+
+  try {
+    // Create ChromeDebug directory
+    await fs.mkdir(CHROMEDEBUG_DIR, { recursive: true });
+
+    // Start logging
+    await logInstall('=== Installation Started ===');
+
+    // 1. Validate arguments
+    const parsedArgs = validateArguments(args);
+    if (!parsedArgs) {
+      return process.exit(1);
+    }
+
+    const { license, extensionPath } = parsedArgs;
+
+    // 2. Validate license key
+    console.log('Validating license key...');
+    if (!validateLicenseKey(license)) {
+      await logInstall(`Invalid license key: ${maskLicenseKey(license)}`, true);
+      return process.exit(1);
+    }
+    await logInstall(`License key validated: ${maskLicenseKey(license)}`);
+    console.log(` License key validated: ${maskLicenseKey(license)}\n`);
+
+    // 3. Pre-flight checks
+    if (!(await preflightChecks())) {
+      await logInstall('Pre-flight checks failed', true);
+      return process.exit(1);
+    }
+
+    // 4. Check for existing installation
+    const existing = await checkExistingInstallation();
+    if (existing.exists) {
+      const message = `
+Existing PRO installation found:
+- Installed: ${new Date(existing.installed_at).toLocaleDateString()}
+- Version: ${existing.extension_version}
+- License: ${maskLicenseKey(existing.license_key)}
+
+This will overwrite the existing installation.`;
+
+      promptConfirmation(message);
+      await logInstall('Overwriting existing installation');
+    }
+
+    // 5. Extract extension
+    console.log('Extracting PRO extension...');
+    const extensionInfo = await extractExtension(extensionPath, EXTENSION_DIR);
+    await logInstall(`Extension extracted: ${extensionInfo.name} v${extensionInfo.version}`);
+    console.log(` PRO extension extracted to ${EXTENSION_DIR}`);
+    console.log(`  Version: ${extensionInfo.version}\n`);
+
+    // Set extension directory permissions
+    await fs.chmod(EXTENSION_DIR, 0o755);
+
+    // 6. Save license information
+    console.log('Saving license information...');
+    await saveLicenseInfo(license, extensionInfo.version);
+    await logInstall(`License saved: ${maskLicenseKey(license)}`);
+    console.log(` License saved to ${LICENSE_FILE}\n`);
+
+    // 7. Configure shell environment
+    console.log('Configuring shell environment...');
+    let shellResult;
+    let shellConfigFailed = false;
+
+    try {
+      shellResult = await configureShell();
+      await logInstall(`Shell configured: ${shellResult.shell} (${shellResult.configFile})`);
+
+      if (shellResult.updated) {
+        console.log(` Shell configured: export ${ENV_VAR_NAME}="${EXTENSION_DIR}"`);
+        console.log(`  Config file: ${shellResult.configFile}`);
+        console.log(`  Backup saved: ${shellResult.configFile}.chromedebug-backup\n`);
+      } else {
+        console.log(` Shell already configured correctly\n`);
+      }
+    } catch (shellErr) {
+      shellConfigFailed = true;
+      await logInstall(`Shell configuration failed: ${shellErr.message}`, false);
+      console.log(`⚠ Could not automatically configure shell environment`);
+      console.log(`  Error: ${shellErr.message}\n`);
+    }
+
+    // 8. Success!
+    await logInstall('=== Installation Completed Successfully ===');
+
+    console.log('

















































');
+    console.log('PRO features are now active!');
+    console.log('

















































\n');
+
+    console.log('Next steps:');
+    console.log(`1. Restart your terminal or run: source ${shellResult.configFile}`);
+    console.log('2. Close any running Chrome instances');
+    console.log('3. Launch ChromeDebug MCP: chromedebug-mcp');
+    console.log('4. The PRO extension will be loaded automatically\n');
+
+    console.log('Verify installation:');
+    console.log(`  echo $${ENV_VAR_NAME}`);
+    console.log(`  (should output: ${EXTENSION_DIR})\n`);
+
+    console.log('Installation log: ' + INSTALL_LOG);
+    console.log('\nNeed help? https://github.com/dynamicupgrade/ChromeDebug/issues\n');
+
+  } catch (err) {
+    await logInstall(`Installation failed: ${err.message}`, true);
+    console.error('\n Installation failed\n');
+    console.error('Check the installation log for details: ' + INSTALL_LOG);
+    console.error('\nNeed help? https://github.com/dynamicupgrade/ChromeDebug/issues\n');
+    process.exit(1);
+  }
+}

package/chrome-extension/manifest.json

@@ -1,73 +0,0 @@
-{
-  "manifest_version": 3,
-  "name": "ChromeDebug MCP Assistant v2.1.3",
-  "version": "2.1.3",
-  "description": "ChromeDebug MCP visual element selector with function tracing [Build: 2025-10-16-v2.1.3]",
-  "permissions": [
-    "activeTab",
-    "scripting",
-    "tabs",
-    "storage",
-    "tabCapture",
-    "desktopCapture",
-    "notifications",
-    "offscreen"
-  ],
-  "host_permissions": [
-    "https://*.cloudfunctions.net/*"
-  ],
-  "action": {
-    "default_popup": "popup.html",
-    "default_icon": {
-      "16": "icon16.png",
-      "48": "icon48.png",
-      "128": "icon128.png"
-    }
-  },
-  "options_page": "options.html",
-  "content_scripts": [
-    {
-      "matches": [
-        "<all_urls>"
-      ],
-      "exclude_matches": [
-        "*://youtube.com/*",
-        "*://www.youtube.com/*",
-        "*://m.youtube.com/*",
-        "*://google.com/*",
-        "*://www.google.com/*",
-        "*://gmail.com/*",
-        "*://www.gmail.com/*",
-        "*://facebook.com/*",
-        "*://www.facebook.com/*",
-        "*://twitter.com/*",
-        "*://www.twitter.com/*",
-        "*://x.com/*",
-        "*://www.x.com/*",
-        "*://instagram.com/*",
-        "*://www.instagram.com/*"
-      ],
-      "js": [
-        "pako.min.js",
-        "web-vitals.iife.js",
-        "pii-redactor.js",
-        "data-buffer.js",
-        "performance-monitor.js",
-        "dom-tracker.js",
-        "network-tracker.js",
-        "function-tracker.js",
-        "content.js"
-      ],
-      "css": ["content.css"],
-      "run_at": "document_idle"
-    }
-  ],
-  "background": {
-    "service_worker": "background.js"
-  },
-  "icons": {
-    "16": "icon16.png",
-    "48": "icon48.png",
-    "128": "icon128.png"
-  }
-}