@mozilla/firefox-devtools-mcp-moz 0.9.3

package/scripts/test-mozlog.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+import { FirefoxDevTools } from '../dist/index.js';
+import { readFileSync, existsSync } from 'fs';
+
+async function test() {
+  console.log('=== Test: MOZ_LOG and Script Injection (headless) ===\n');
+
+  const logFile = '/tmp/firefox-mozlog-test.log';
+
+  const firefox = new FirefoxDevTools({
+    headless: true,
+    firefoxPath: process.env.FIREFOX_PATH,
+    env: {
+      MOZ_LOG: 'timestamp,sync,nsHttp:5',
+    },
+    logFile,
+  });
+
+  await firefox.connect();
+  console.log('✓ Firefox started in headless mode with MOZ_LOG');
+  console.log(`  Log file: ${logFile}`);
+
+  // Test content script evaluation
+  console.log('\n--- Testing content script evaluation ---');
+  await firefox.navigate('https://example.com');
+  console.log('✓ Navigated to example.com');
+
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+
+  try {
+    const title = await firefox.evaluate('return document.title');
+    console.log(`✓ Content script: document.title = "${title}"`);
+  } catch (err) {
+    console.log(`✗ Content script evaluation failed: ${err.message}`);
+  }
+
+  try {
+    const url = await firefox.evaluate('return window.location.href');
+    console.log(`✓ Content script: window.location.href = "${url}"`);
+  } catch (err) {
+    console.log(`✗ Failed to access window.location: ${err.message}`);
+  }
+
+  try {
+    const headings = await firefox.evaluate('return document.querySelectorAll("h1").length');
+    console.log(`✓ Content script: found ${headings} h1 elements`);
+  } catch (err) {
+    console.log(`✗ Failed to query DOM: ${err.message}`);
+  }
+
+  // Navigate to another page
+  await firefox.navigate('https://mozilla.org');
+  console.log('✓ Navigated to mozilla.org');
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+
+  try {
+    const title2 = await firefox.evaluate('return document.title');
+    console.log(`✓ Content script: document.title = "${title2}"`);
+  } catch (err) {
+    console.log(`✗ Content script evaluation failed: ${err.message}`);
+  }
+
+  // Check log file
+  console.log('\n--- Checking MOZ_LOG output ---');
+
+  await new Promise((resolve) => setTimeout(resolve, 1000));
+
+  await firefox.close();
+  console.log('✓ Firefox closed');
+
+  // Give a moment for log file to be flushed
+  await new Promise((resolve) => setTimeout(resolve, 1000));
+
+  if (existsSync(logFile)) {
+    try {
+      const logContent = readFileSync(logFile, 'utf8');
+      const lines = logContent.split('\n').filter((l) => l.trim());
+      console.log(`✓ Log file exists with ${lines.length} lines`);
+
+      // Check for HTTP logging
+      const httpLines = lines.filter((l) => l.includes('nsHttp'));
+      console.log(`  Found ${httpLines.length} nsHttp log lines`);
+
+      if (httpLines.length > 0) {
+        console.log('  Sample HTTP log lines:');
+        httpLines.slice(0, 3).forEach((line) => {
+          console.log(`    ${line.substring(0, 100)}`);
+        });
+      }
+
+      // Check for timestamps
+      const timestampLines = lines.filter((l) => /^\d{4}-\d{2}-\d{2}/.test(l));
+      console.log(`  Found ${timestampLines.length} timestamped lines`);
+    } catch (err) {
+      console.log(`✗ Could not read log file: ${err.message}`);
+    }
+  } else {
+    console.log(`✗ Log file does not exist: ${logFile}`);
+  }
+
+  console.log('\n✓ All feature tests completed!');
+  console.log('\nNote: Privileged context evaluation requires:');
+  console.log('  - MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1 env var');
+  console.log('  - Using restart_firefox tool or npm run inspector');
+}
+
+test().catch((err) => {
+  console.error('\nTest failed:', err);
+  console.error(err.stack);
+  process.exit(1);
+});

package/scripts/test-navigation.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+import { FirefoxDevTools } from '../dist/index.js';
+
+async function test() {
+  console.log('=== Test: Start Firefox and navigate ===\n');
+
+  const firefox = new FirefoxDevTools({
+    headless: false,
+    firefoxPath: process.env.FIREFOX_PATH,
+  });
+
+  await firefox.connect();
+  console.log('✓ Firefox started');
+
+  await firefox.navigate('https://example.com');
+  console.log('✓ Navigated to example.com');
+
+  await new Promise(resolve => setTimeout(resolve, 2000));
+
+  await firefox.navigate('https://mozilla.org');
+  console.log('✓ Navigated to mozilla.org');
+
+  await new Promise(resolve => setTimeout(resolve, 2000));
+
+  await firefox.refreshTabs();
+  const tabs = firefox.getTabs();
+  console.log(`✓ Listed tabs: ${tabs.length} tab(s)`);
+  if (tabs.length > 0) {
+    console.log(`  Current URL: ${tabs[0].url}`);
+    console.log(`  Current title: ${tabs[0].title || 'N/A'}`);
+  }
+
+  await new Promise(resolve => setTimeout(resolve, 2000));
+
+  await firefox.navigate('https://www.w3.org');
+  console.log('✓ Navigated to w3.org');
+
+  await new Promise(resolve => setTimeout(resolve, 2000));
+
+  await firefox.refreshTabs();
+  const tabsAfter = firefox.getTabs();
+  console.log(`✓ Listed tabs again: ${tabsAfter.length} tab(s)`);
+  if (tabsAfter.length > 0) {
+    console.log(`  Current URL: ${tabsAfter[0].url}`);
+  }
+
+  await firefox.close();
+  console.log('\n✓ Basic navigation tests passed!');
+  console.log('\nNote: To test restart_firefox with logs, use the MCP inspector:');
+  console.log('  npm run inspector');
+}
+
+test().catch(err => {
+  console.error('\nTest failed:', err);
+  process.exit(1);
+});

package/scripts/test-privileged-context.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+
+import { FirefoxDevTools } from '../dist/index.js';
+
+async function test() {
+  console.log('=== Test: Privileged Context Script Evaluation (headless) ===\n');
+
+  const firefox = new FirefoxDevTools({
+    headless: true,
+    firefoxPath: process.env.FIREFOX_PATH,
+    env: {
+      MOZ_REMOTE_ALLOW_SYSTEM_ACCESS: '1',
+    },
+  });
+
+  await firefox.connect();
+  console.log('✓ Firefox started with MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1');
+
+  // Test content script first
+  console.log('\n--- Testing content script (default context) ---');
+  await firefox.navigate('https://example.com');
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+
+  try {
+    const title = await firefox.evaluate('return document.title');
+    console.log(`✓ Content context: document.title = "${title}"`);
+  } catch (err) {
+    console.log(`✗ Content script failed: ${err.message}`);
+  }
+
+  // Now test privileged context via BiDi with moz:scope
+  console.log('\n--- Testing privileged context listing ---');
+
+  try {
+    // Use BiDi to list privileged contexts with moz:scope
+    const result = await firefox.sendBiDiCommand('browsingContext.getTree', {
+      'moz:scope': 'chrome',
+    });
+
+    const contexts = result.contexts || [];
+    console.log(`✓ Listed ${contexts.length} privileged context(s) via BiDi`);
+
+    if (contexts.length > 0) {
+      console.log('  Sample privileged contexts:');
+      contexts.slice(0, 3).forEach((ctx) => {
+        console.log(`    ${ctx.context}: ${ctx.url || '(no url)'}`);
+      });
+
+      // Try to evaluate in privileged context
+      console.log('\n--- Testing privileged script execution ---');
+
+      const driver = firefox.getDriver();
+      const firstContext = contexts[0];
+
+      // Switch to chrome browsing context
+      await driver.switchTo().window(firstContext.context);
+      console.log(`✓ Switched to privileged context: ${firstContext.context}`);
+
+      // Set Marionette context to chrome
+      try {
+        await driver.setContext('chrome');
+        console.log('✓ Set Marionette context to "chrome"');
+
+        // Now try to evaluate chrome-privileged script
+        const appName = await driver.executeScript('return Services.appinfo.name;');
+        console.log(`✓ Privileged script: Services.appinfo.name = "${appName}"`);
+
+        const version = await driver.executeScript('return Services.appinfo.version;');
+        console.log(`✓ Privileged script: Services.appinfo.version = "${version}"`);
+
+        const buildID = await driver.executeScript('return Services.appinfo.appBuildID;');
+        console.log(`✓ Privileged script: Services.appinfo.appBuildID = "${buildID}"`);
+
+        console.log('\n✅ Privileged context evaluation WORKS!');
+      } catch (err) {
+        console.log(`✗ Failed to set privileged context: ${err.message}`);
+        console.log('  Your Firefox build may not support privileged context');
+      }
+    } else {
+      console.log('  No privileged contexts found (requires dev/nightly build)');
+    }
+  } catch (err) {
+    if (err.message && err.message.includes('UnsupportedOperationError')) {
+      console.log('✗ Privileged context not supported by this Firefox build');
+      console.log('  Requires Firefox Nightly or custom build');
+    } else {
+      console.log(`✗ Privileged context test failed: ${err.message}`);
+    }
+  }
+
+  await firefox.close();
+  console.log('\n✓ Test completed');
+}
+
+test().catch((err) => {
+  console.error('\nTest failed:', err);
+  console.error(err.stack);
+  process.exit(1);
+});

package/scripts/test-screenshot.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+
+/**
+ * Test script for screenshot functionality (Task 22)
+ * Tests: takeScreenshotPage, takeScreenshotByUid
+ * Saves screenshots to temp/ directory for visual inspection
+ */
+
+import { FirefoxDevTools } from '../dist/index.js';
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+import {
+  loadHTML,
+  waitShort,
+  shouldRunOnlineTests,
+  skipOnlineTest,
+} from './_helpers/page-loader.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const TEMP_DIR = join(__dirname, '../temp');
+
+async function saveScreenshot(base64Data, filename) {
+  // Ensure temp directory exists
+  await mkdir(TEMP_DIR, { recursive: true });
+
+  // Convert base64 to buffer and save
+  const buffer = Buffer.from(base64Data, 'base64');
+  const filepath = join(TEMP_DIR, filename);
+  await writeFile(filepath, buffer);
+
+  console.log(`   💾 Saved: ${filepath} (${(buffer.length / 1024).toFixed(2)} KB)`);
+  return filepath;
+}
+
+async function main() {
+  console.log('📷 Testing Screenshot Functionality...\n');
+
+  const firefox = new FirefoxDevTools({
+    firefoxPath: process.env.FIREFOX_PATH,
+    headless: false,
+    startUrl: 'about:blank',
+  });
+
+  try {
+    console.log('📡 Connecting to Firefox...');
+    await firefox.connect();
+    console.log('✅ Connected!\n');
+
+    // Online tests (optional)
+    if (shouldRunOnlineTests()) {
+      // Test 1: Screenshot of example.com
+      console.log('🌐 Test 1: Full page screenshot (example.com)');
+      await firefox.navigate('https://example.com');
+      await waitShort(2000);
+
+      const examplePageScreenshot = await firefox.takeScreenshotPage();
+      await saveScreenshot(examplePageScreenshot, 'screenshot-example-page.png');
+      console.log(`   ✅ Screenshot captured (${examplePageScreenshot.length} chars base64)\n`);
+
+      // Test 2: Screenshot of specific element (heading)
+      console.log('🎯 Test 2: Element screenshot (h1 heading)');
+      const snapshot1 = await firefox.takeSnapshot();
+      const h1Node = snapshot1.json.root.children?.find((n) => n.tag === 'h1');
+
+      if (h1Node && h1Node.uid) {
+        console.log(`   Found: <h1> with UID ${h1Node.uid}`);
+        const h1Screenshot = await firefox.takeScreenshotByUid(h1Node.uid);
+        await saveScreenshot(h1Screenshot, 'screenshot-example-h1.png');
+        console.log(`   ✅ Element screenshot captured (${h1Screenshot.length} chars base64)\n`);
+      } else {
+        console.log('   ⚠️ No h1 element found\n');
+      }
+    } else {
+      skipOnlineTest('Online screenshot tests (example.com)');
+    }
+
+    // Test 3: Custom HTML page with styled elements (OFFLINE)
+    console.log('🎨 Test 3: Custom styled page (offline)');
+
+    await loadHTML(
+      firefox,
+      `
+<head><title>Screenshot Test</title><style>
+body { font-family: Arial; padding: 40px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); margin: 0; min-height: 100vh; }
+.card { background: white; border-radius: 12px; padding: 30px; box-shadow: 0 20px 60px rgba(0,0,0,0.3); max-width: 600px; margin: 0 auto; }
+h1 { color: #667eea; margin: 0 0 20px 0; font-size: 36px; }
+.button { background: #667eea; color: white; padding: 15px 30px; border: none; border-radius: 8px; font-size: 18px; cursor: pointer; display: inline-block; margin: 10px 5px; box-shadow: 0 4px 15px rgba(102, 126, 234, 0.4); }
+.button:hover { transform: translateY(-2px); box-shadow: 0 6px 20px rgba(102, 126, 234, 0.6); }
+p { color: #555; line-height: 1.6; font-size: 16px; }
+</style></head><body>
+<div class="card">
+<h1 id="title">🎯 Screenshot Test Page</h1>
+<p id="description">This is a beautifully styled test page for screenshot functionality. The gradient background and card design showcase visual capture capabilities.</p>
+<button class="button" id="btn1">Primary Action</button>
+<button class="button" id="btn2">Secondary Action</button>
+</div>
+</body>
+`
+    );
+
+    await waitShort(500);
+
+    const customPageScreenshot = await firefox.takeScreenshotPage();
+    await saveScreenshot(customPageScreenshot, 'screenshot-custom-page.png');
+    console.log(`   ✅ Full page screenshot captured\n`);
+
+    // Test 4: Screenshot of styled elements using UID
+    console.log('🎨 Test 4: Individual styled elements (via UID)');
+
+    const snapshot = await firefox.takeSnapshot();
+
+    // Find h1 element
+    const findElement = (node, tag) => {
+      if (node.tag === tag) return node;
+      if (node.children) {
+        for (const child of node.children) {
+          const found = findElement(child, tag);
+          if (found) return found;
+        }
+      }
+      return null;
+    };
+
+    const h1 = findElement(snapshot.json.root, 'h1');
+    if (h1 && h1.uid) {
+      const h1Screenshot = await firefox.takeScreenshotByUid(h1.uid);
+      await saveScreenshot(h1Screenshot, 'screenshot-custom-h1.png');
+      console.log(`   ✅ H1 screenshot captured via UID`);
+    }
+
+    // Find first button
+    const button = findElement(snapshot.json.root, 'button');
+    if (button && button.uid) {
+      const buttonScreenshot = await firefox.takeScreenshotByUid(button.uid);
+      await saveScreenshot(buttonScreenshot, 'screenshot-custom-button.png');
+      console.log(`   ✅ Button screenshot captured via UID\n`);
+    }
+
+    // Test 5: Screenshot using direct CSS selectors (fallback method)
+    console.log('🎨 Test 5: Individual styled elements (via CSS selectors)');
+
+    try {
+      // Get element via evaluate and take screenshot using WebDriver directly
+      const driver = firefox.getDriver();
+
+      // Screenshot title
+      const titleEl = await driver.findElement({ css: '#title' });
+      await driver.executeScript('arguments[0].scrollIntoView({block: "center"});', titleEl);
+      await waitShort(200);
+      const titleScreenshot = await titleEl.takeScreenshot();
+      await saveScreenshot(titleScreenshot, 'screenshot-custom-title.png');
+      console.log(`   ✅ Title screenshot captured`);
+
+      // Screenshot second button (avoid conflict with UID test)
+      const buttonEl = await driver.findElement({ css: '#btn2' });
+      await driver.executeScript('arguments[0].scrollIntoView({block: "center"});', buttonEl);
+      await waitShort(200);
+      const buttonScreenshot = await buttonEl.takeScreenshot();
+      await saveScreenshot(buttonScreenshot, 'screenshot-custom-button2.png');
+      console.log(`   ✅ Button screenshot captured`);
+
+      // Screenshot card container
+      const cardEl = await driver.findElement({ css: '.card' });
+      await driver.executeScript('arguments[0].scrollIntoView({block: "center"});', cardEl);
+      await waitShort(200);
+      const cardScreenshot = await cardEl.takeScreenshot();
+      await saveScreenshot(cardScreenshot, 'screenshot-custom-card.png');
+      console.log(`   ✅ Card screenshot captured\n`);
+    } catch (error) {
+      console.log(`   ⚠️ Element screenshot failed: ${error.message}\n`);
+    }
+
+    console.log('✅ All screenshot tests completed! 🎉');
+    console.log(`\n📁 Screenshots saved to: ${TEMP_DIR}\n`);
+
+  } catch (error) {
+    console.error('❌ Test failed:', error.message);
+    if (error.stack) console.error(error.stack);
+    process.exit(1);
+  } finally {
+    console.log('🧹 Closing...');
+    await firefox.close();
+    console.log('✅ Done');
+  }
+}
+
+main().catch(console.error);