chrome-devtools-mcp-for-extension 0.6.5 → 0.7.0

package/README.md

@@ -443,13 +443,41 @@ interface ManifestValidation {
 - `--load-extension` may be restricted in newer Chrome versions
 - **Solution**: Use system profile (default) instead of `--loadExtension` flag
 
-## Concurrent Chrome Usage
+## Dedicated Profile Architecture
 
-**Can I use Chrome while the MCP server is running?**
+**How does the MCP server handle Chrome profiles?**
 
-Yes! The MCP server can run alongside your regular Chrome browser. Chrome is robust enough to handle concurrent access to the same profile.
+The MCP server uses a **dedicated profile with symlinks** to provide the best of both worlds:
 
-**Note:** If you experience any issues with concurrent usage, you can use the `--isolated` flag to run with a separate profile:
+### What Gets Shared (via Symlinks)
+- ✅ **Extensions**: Your installed Chrome extensions are accessible via symlink
+- ✅ **Bookmarks**: Your bookmarks are shared (read-only)
+
+### What Stays Private (Dedicated Profile)
+- 🔒 **Cookies & Login State**: Separate login state for security
+- 🔒 **Browsing History**: Independent history
+- 🔒 **Preferences**: MCP-specific settings
+
+### Profile Location
+```
+~/.cache/chrome-devtools-mcp/chrome-profile-dedicated/
+└── Default/
+    ├── Extensions/    → (symlink to system Chrome)
+    ├── Bookmarks      → (symlink to system Chrome)
+    ├── Cookies        (dedicated)
+    └── ...
+```
+
+### First Launch
+- **Initial setup**: Extensions and bookmarks are automatically linked
+- **Google Login required**: You'll need to log in once (login state is not shared from your main Chrome)
+- **Subsequent launches**: Login state is preserved in the dedicated profile
+
+### Concurrent Usage
+✅ **Yes!** The MCP server runs alongside your regular Chrome browser without conflicts. Each uses its own profile directory.
+
+### Isolated Mode
+For testing or if you prefer a completely empty profile:
 ```bash
 npx chrome-devtools-mcp-for-extension@latest --isolated
 ```

package/build/src/browser.js

@@ -7,7 +7,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import puppeteer from 'puppeteer-core';
-import { detectSystemChromeProfile, detectAnySystemChromeProfile, } from './system-profile.js';
+import { setupDedicatedProfile } from './profile-manager.js';
 let browser;
 const ignoredPrefixes = new Set([
     'chrome://',
@@ -42,21 +42,6 @@ async function ensureBrowserConnected(browserURL) {
     });
     return browser;
 }
-/**
- * Get the last used Chrome profile directory name from Local State
- */
-function getLastUsedProfile(userDataDir) {
-    const localStatePath = path.join(userDataDir, 'Local State');
-    try {
-        const localStateContent = fs.readFileSync(localStatePath, 'utf8');
-        const localState = JSON.parse(localStateContent);
-        return localState?.profile?.last_used || 'Default';
-    }
-    catch (error) {
-        console.warn(`Could not read Local State: ${error instanceof Error ? error.message : String(error)}`);
-        return 'Default';
-    }
-}
 function scanExtensionsDirectory(extensionsDir) {
     const extensionPaths = [];
     try {
@@ -250,25 +235,21 @@ export async function launch(options) {
     let usingSystemProfile = false;
     let profileDirectory = 'Default';
     if (!isolated && !userDataDir) {
-        // Try to use system Chrome profile directly
-        const systemProfile = detectSystemChromeProfile(channel) || detectAnySystemChromeProfile();
-        if (systemProfile) {
-            // Use system profile directly for better user experience
-            userDataDir = systemProfile.path;
-            usingSystemProfile = true;
-            // Detect last used profile directory
-            profileDirectory = getLastUsedProfile(userDataDir);
-            console.error(`✅ Using system Chrome profile: ${systemProfile.channel}`);
-            console.error(`   Path: ${userDataDir}`);
-            console.error(`   Profile Directory: ${profileDirectory}`);
+        // Use dedicated profile with symlinks to system extensions and bookmarks
+        try {
+            const dedicatedProfile = await setupDedicatedProfile(channel);
+            userDataDir = dedicatedProfile.userDataDir;
+            profileDirectory = dedicatedProfile.profileDirectory;
+            usingSystemProfile = false; // Using dedicated profile, not system profile
         }
-        else {
-            // Fallback to isolated profile if no system Chrome found
+        catch (error) {
+            // Fallback to isolated profile if setup fails
+            console.error(`⚠️  Failed to setup dedicated profile: ${error instanceof Error ? error.message : String(error)}`);
             userDataDir = path.join(os.homedir(), '.cache', 'chrome-devtools-mcp', profileDirName);
             await fs.promises.mkdir(userDataDir, {
                 recursive: true,
             });
-            console.error(`📁 Using isolated profile (no system Chrome found)`);
+            console.error(`📁 Using isolated profile (fallback)`);
         }
     }
     const args = [

package/build/src/profile-manager.js

@@ -0,0 +1,150 @@
+/**
+ * Profile Manager for Chrome DevTools MCP
+ *
+ * This module manages dedicated Chrome profiles that use symlinks to share
+ * Extensions and Bookmarks from the system Chrome profile while maintaining
+ * isolated Cookies, Login Data, and Preferences.
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+/**
+ * Detect system Chrome profile for a specific channel
+ */
+function detectSystemChromeProfile(channel) {
+    const home = os.homedir();
+    const chromePaths = {
+        stable: path.join(home, 'Library/Application Support/Google/Chrome'),
+        beta: path.join(home, 'Library/Application Support/Google/Chrome Beta'),
+        canary: path.join(home, 'Library/Application Support/Google/Chrome Canary'),
+        dev: path.join(home, 'Library/Application Support/Google/Chrome Dev'),
+    };
+    const targetChannel = channel || 'stable';
+    const chromePath = chromePaths[targetChannel];
+    if (chromePath && fs.existsSync(chromePath)) {
+        return { path: chromePath, channel: targetChannel };
+    }
+    return null;
+}
+/**
+ * Detect any available system Chrome profile
+ */
+function detectAnySystemChromeProfile() {
+    const channels = ['stable', 'beta', 'dev', 'canary'];
+    for (const channel of channels) {
+        const profile = detectSystemChromeProfile(channel);
+        if (profile) {
+            return profile;
+        }
+    }
+    return null;
+}
+/**
+ * Get the last used profile directory name from Local State
+ */
+function getLastUsedProfile(userDataDir) {
+    const localStatePath = path.join(userDataDir, 'Local State');
+    try {
+        const localStateContent = fs.readFileSync(localStatePath, 'utf-8');
+        const localState = JSON.parse(localStateContent);
+        const lastUsed = localState?.profile?.last_used;
+        if (lastUsed && typeof lastUsed === 'string') {
+            return lastUsed;
+        }
+    }
+    catch (error) {
+        // Ignore errors, will use default
+    }
+    return 'Default';
+}
+/**
+ * Create or update a symlink safely
+ *
+ * @param target - The target path that the symlink should point to
+ * @param linkPath - The path where the symlink should be created
+ */
+function createSymlinkSafe(target, linkPath) {
+    // Check if target exists
+    if (!fs.existsSync(target)) {
+        console.error(`⚠️  Symlink target does not exist: ${target}`);
+        return;
+    }
+    // If link already exists and points to the correct target, skip
+    if (fs.existsSync(linkPath)) {
+        try {
+            const currentTarget = fs.readlinkSync(linkPath);
+            if (currentTarget === target) {
+                // Already correctly linked
+                return;
+            }
+            // Remove old symlink
+            fs.unlinkSync(linkPath);
+        }
+        catch (error) {
+            // Not a symlink, remove the file/directory
+            if (fs.lstatSync(linkPath).isDirectory()) {
+                fs.rmSync(linkPath, { recursive: true, force: true });
+            }
+            else {
+                fs.unlinkSync(linkPath);
+            }
+        }
+    }
+    // Create new symlink
+    fs.symlinkSync(target, linkPath, 'dir');
+    console.error(`🔗 Created symlink: ${path.basename(linkPath)} -> ${target}`);
+}
+/**
+ * Setup a dedicated Chrome profile with symlinks to system profile
+ *
+ * This function:
+ * 1. Detects the system Chrome profile
+ * 2. Creates a dedicated profile directory
+ * 3. Creates symlinks for Extensions and Bookmarks
+ * 4. Returns the dedicated profile information
+ *
+ * @param channel - Chrome channel to use (stable, beta, canary, dev)
+ * @returns Dedicated profile information
+ */
+export async function setupDedicatedProfile(channel) {
+    // Detect system Chrome profile
+    const systemProfile = detectSystemChromeProfile(channel) || detectAnySystemChromeProfile();
+    if (!systemProfile) {
+        throw new Error('No system Chrome profile found. Please install Chrome and run it at least once.');
+    }
+    // Get the last used profile directory
+    const profileDirectory = getLastUsedProfile(systemProfile.path);
+    const systemProfileDir = path.join(systemProfile.path, profileDirectory);
+    // Create dedicated profile directory
+    const dedicatedUserDataDir = path.join(os.homedir(), '.cache', 'chrome-devtools-mcp', 'chrome-profile-dedicated');
+    await fs.promises.mkdir(dedicatedUserDataDir, { recursive: true });
+    const dedicatedProfileDir = path.join(dedicatedUserDataDir, profileDirectory);
+    await fs.promises.mkdir(dedicatedProfileDir, { recursive: true });
+    console.error('📁 Dedicated Profile Setup:');
+    console.error(`   System Profile: ${systemProfileDir}`);
+    console.error(`   Dedicated Profile: ${dedicatedProfileDir}`);
+    console.error(`   Profile Directory: ${profileDirectory}`);
+    // Create symlinks for shared resources
+    const symlinkTargets = [
+        { name: 'Extensions', required: false },
+        { name: 'Bookmarks', required: false },
+    ];
+    for (const { name, required } of symlinkTargets) {
+        const targetPath = path.join(systemProfileDir, name);
+        const linkPath = path.join(dedicatedProfileDir, name);
+        if (fs.existsSync(targetPath)) {
+            createSymlinkSafe(targetPath, linkPath);
+        }
+        else if (required) {
+            console.error(`⚠️  Required item not found: ${name}`);
+        }
+    }
+    console.error('✅ Dedicated profile setup complete');
+    console.error('   First launch will require Google login (login state is not shared)');
+    return {
+        userDataDir: dedicatedUserDataDir,
+        profileDirectory,
+        systemProfilePath: systemProfileDir,
+        channel: systemProfile.channel,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-devtools-mcp-for-extension",
-  "version": "0.6.5",
+  "version": "0.7.0",
   "description": "MCP server for Chrome extension development with Web Store automation. Fork of chrome-devtools-mcp with extension-specific tools.",
   "type": "module",
   "bin": "./build/src/index.js",