@deeeed/metamask-harness 0.28.0 → 0.29.0

package/adapters/extension/lib/validation-process-ownership.cjs

@@ -0,0 +1,69 @@
+'use strict';
+
+const { execFileSync } = require('node:child_process');
+
+function commandHasExactProfile(command, profile) {
+  const expected = `--user-data-dir=${profile}`;
+  let offset = command.indexOf(expected);
+  while (offset !== -1) {
+    const before = offset === 0 ? '' : command[offset - 1];
+    const after = command[offset + expected.length] || '';
+    if ((!before || /\s/u.test(before)) && (!after || /\s/u.test(after))) return true;
+    offset = command.indexOf(expected, offset + 1);
+  }
+  return false;
+}
+
+function profileProcessPids(profile) {
+  const output = execFileSync('ps', ['-ww', '-axo', 'pid=,command='], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+  });
+  const pids = [];
+  for (const line of output.split('\n')) {
+    const match = line.match(/^\s*(\d+)\s+(.*)$/u);
+    if (!match || !commandHasExactProfile(match[2], profile)) continue;
+    const pid = Number(match[1]);
+    if (pid !== process.pid && pid !== process.ppid) pids.push(pid);
+  }
+  return [...new Set(pids)];
+}
+
+function signalPids(pids, signal) {
+  for (const pid of pids) {
+    try {
+      process.kill(pid, signal);
+    } catch (error) {
+      if (error.code !== 'ESRCH') throw error;
+    }
+  }
+}
+
+function delay(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+async function stopProfileProcesses(profile, { quietMs = 0, timeoutMs = 5_000 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  let quietSince = Date.now();
+  let ownersSince = 0;
+  while (Date.now() < deadline) {
+    const pids = profileProcessPids(profile);
+    if (pids.length === 0) {
+      ownersSince = 0;
+      if (Date.now() - quietSince >= quietMs) return;
+    } else {
+      if (ownersSince === 0) ownersSince = Date.now();
+      quietSince = Date.now();
+      signalPids(pids, Date.now() - ownersSince >= 500 ? 'SIGKILL' : 'SIGTERM');
+    }
+    await delay(50);
+  }
+  const remaining = profileProcessPids(profile);
+  if (remaining.length > 0) {
+    throw new Error(`Extension validation profile processes survived cleanup: ${remaining.join(', ')}.`);
+  }
+  throw new Error(`Extension validation profile did not remain quiescent for ${quietMs}ms.`);
+}
+
+module.exports = { profileProcessPids, stopProfileProcesses };

package/adapters/extension/reattach.sh

@@ -126,6 +126,7 @@ const fs = require('node:fs');
 const path = require('node:path');
 const { extensionIdFromManifestFile } = require(path.join(process.env.SCRIPT_DIR, 'lib/extension-id.cjs'));
 const { readSlotId, applyPersistentSlotTitle } = require(path.join(process.env.SCRIPT_DIR, 'lib/slot-title.cjs'));
+const { evaluatePageViaCdp } = require(path.join(process.env.SCRIPT_DIR, 'lib/playwright-cdp.cjs'));
 
 const port = process.env.CDP_PORT;
 const target = process.env.TARGET;
@@ -198,7 +199,7 @@ async function connect() {
 
 async function stampSlotTitle(page) {
   if (!slotId || !page) return;
-  await page.evaluate(applyPersistentSlotTitle, slotId).catch(() => {
+  await evaluatePageViaCdp(page, applyPersistentSlotTitle, slotId).catch(() => {
     // Best-effort operator affordance; reload success is verified by CDP state.
   });
 }

package/adapters/extension/sidepanel-toggle.sh

@@ -239,7 +239,7 @@ open_sidepanel() {
     exit 4
   fi
 
-  CDP_PORT="$CDP_PORT" EXT_ID="$ext_id" node <<'NODE'
+  CDP_PORT="$CDP_PORT" EXT_ID="$ext_id" SCRIPT_DIR="$SCRIPT_DIR" node <<'NODE'
 const { chromium } = require('playwright');
 
 (async () => {
@@ -247,105 +247,23 @@ const { chromium } = require('playwright');
   const extId = process.env.EXT_ID;
   const browser = await chromium.connectOverCDP(`http://127.0.0.1:${port}`);
   const context = browser.contexts()[0];
-  let page = context
-    .pages()
-    .find(
-      (candidate) =>
-        candidate.url().startsWith(`chrome-extension://${extId}/`) &&
-        !candidate.url().includes('/sidepanel.html'),
-    );
-
-  if (!page) {
-    page = await context.newPage();
-    await page.goto(`chrome-extension://${extId}/home.html`, {
+  const page = await context.newPage();
+  try {
+    await page.goto(`chrome-extension://${extId}/popup-init.html`, {
       waitUntil: 'domcontentloaded',
       timeout: 15000,
     });
-  }
-
-  if (process.env.MM_HARNESS_FOCUS_BROWSER === '1') {
-    await page.bringToFront();
-  }
-  const result = await page.evaluate(async () => {
-    const currentWindow = await chrome.windows.getCurrent();
-    const id = '__recipe_open_sidepanel__';
-    document.getElementById(id)?.remove();
-    const button = document.createElement('button');
-    button.id = id;
-    button.textContent = 'open sidepanel';
-    button.style.cssText =
-      'position:fixed;left:8px;top:8px;z-index:2147483647';
-    button.onclick = async () => {
-      try {
-        await chrome.sidePanel.open({ windowId: currentWindow.id });
-        button.dataset.result = `ok:${currentWindow.id}`;
-      } catch (error) {
-        button.dataset.result = `error:${
-          error && error.message ? error.message : String(error)
-        }`;
-      }
-    };
-    document.documentElement.appendChild(button);
-    return { windowId: currentWindow.id };
-  });
-
-  // This harness-owned button exists only to provide Chrome's trusted user
-  // gesture. Its visual layout is irrelevant and can be occluded by the app's
-  // full-screen loading surface, so do not wait on Playwright actionability.
-  await page.locator('#__recipe_open_sidepanel__').click({ timeout: 5000, force: true });
-  const clickResult = await page
-    .locator('#__recipe_open_sidepanel__')
-    .evaluate((button) => button.dataset.result || '');
-  if (!clickResult.startsWith('ok:')) {
-    throw new Error(
-      `chrome.sidePanel.open failed for window ${result.windowId}: ${clickResult}`,
-    );
-  }
-  await page.evaluate(() => {
-    document.getElementById('__recipe_open_sidepanel__')?.remove();
-  });
-
-  const deadline = Date.now() + 5000;
-  let sidepanelPage;
-  while (Date.now() < deadline) {
-    sidepanelPage = context
-      .pages()
-      .find((candidate) => candidate.url().startsWith(`chrome-extension://${extId}/`) && candidate.url().includes('/sidepanel.html'));
-    if (sidepanelPage) break;
-    await new Promise((resolve) => setTimeout(resolve, 200));
-  }
-
-  // Only collapse fullscreen extension tabs after Chrome exposes the sidepanel
-  // target. chrome.sidePanel.open can return before the panel page appears; if we
-  // close home first, a slow/failed panel leaves the operator with no visible
-  // wallet page and the next readiness probe has to reopen from scratch.
-  if (sidepanelPage) {
-    for (const candidate of context.pages()) {
-      if (
-        candidate.url().startsWith(`chrome-extension://${extId}/`) &&
-        !candidate.url().includes('/sidepanel.html')
-      ) {
-        try {
-          await candidate.close();
-        } catch (error) {
-          console.warn(
-            `[sidepanel] extension page close failed after successful open: ${
-              error && error.message ? error.message : error
-            }`,
-          );
-        }
-      }
-    }
-  }
-  const dappPage = context
-    .pages()
-    .find((candidate) => candidate.url().startsWith('http://') || candidate.url().startsWith('https://'));
-  if (dappPage && process.env.MM_HARNESS_FOCUS_BROWSER === '1') {
-    try {
-      await dappPage.bringToFront();
-    } catch {
-      // focus is cosmetic; the panel is already open
+    if (process.env.MM_HARNESS_FOCUS_BROWSER === '1') {
+      await page.bringToFront();
     }
+    const menu = page.locator('[data-testid="account-options-menu-button"]');
+    await menu.waitFor({ state: 'visible', timeout: 15000 });
+    await menu.click({ timeout: 5000 });
+    const toggle = page.locator('[data-testid="global-menu-toggle-view"]');
+    await toggle.waitFor({ state: 'visible', timeout: 10000 });
+    await toggle.click({ timeout: 5000 });
+  } finally {
+    if (!page.isClosed()) await page.close();
   }
   if (typeof browser.disconnect === 'function') {
     await browser.disconnect();

package/adapters/extension/wallet-fixture-state.cjs

@@ -21,6 +21,7 @@ const fs = require('node:fs');
 const http = require('node:http');
 const path = require('node:path');
 const { extensionIdFromManifestKey } = require('./lib/extension-id.cjs');
+const { evaluatePageViaCdp } = require('./lib/playwright-cdp.cjs');
 
 const EOA_METHODS = [
   'personal_sign',
@@ -708,7 +709,7 @@ async function waitForWalletScreen(page) {
   const unlockSelector = '[data-testid="unlock-password"]';
   const deadline = Date.now() + 45000;
   while (Date.now() < deadline) {
-    const fatalStartup = await evaluateViaCdp(page, () => {
+    const fatalStartup = await evaluatePageViaCdp(page, () => {
       const text = document.body?.innerText || '';
       return text.includes('MetaMask had trouble starting') ? text.slice(0, 500) : null;
     })
@@ -732,36 +733,12 @@ async function waitForWalletScreen(page) {
   return { state: 'unknown', selector: null };
 }
 
-async function evaluateViaCdp(page, callback, argument) {
-  const session = await page.context().newCDPSession(page);
-  const invocation = argument === undefined
-    ? `(${callback.toString()})()`
-    : `(${callback.toString()})(${JSON.stringify(argument)})`;
-  try {
-    const response = await session.send('Runtime.evaluate', {
-      expression: invocation,
-      awaitPromise: true,
-      returnByValue: true,
-    });
-    if (response.exceptionDetails) {
-      const detail =
-        response.exceptionDetails.exception?.description ??
-        response.exceptionDetails.text ??
-        'unknown evaluation failure';
-      throw new Error(`CDP evaluation failed: ${detail}`);
-    }
-    return response.result?.value;
-  } finally {
-    await session.detach().catch(() => {});
-  }
-}
-
 async function attemptUnlock(page, password) {
   // Selector ladder: current testids first, then the generic selectors the CDP
   // unlock action uses (proven against the same build). A freshly seeded vault
   // can also still be initializing, so a single attempt is not conclusive —
   // the caller retries.
-  const filled = await evaluateViaCdp(page, (pw) => {
+  const filled = await evaluatePageViaCdp(page, (pw) => {
     const input =
       document.querySelector('[data-testid="unlock-password"]') ??
       document.querySelector('input[type="password"]');
@@ -776,7 +753,7 @@ async function attemptUnlock(page, password) {
     return true;
   }, password);
   if (!filled) return false;
-  return evaluateViaCdp(page, () => {
+  return evaluatePageViaCdp(page, () => {
     const button =
       document.querySelector('[data-testid="unlock-submit"]') ??
       document.querySelector('button[type="submit"]') ??
@@ -807,7 +784,7 @@ async function unlockIfNeeded(page, password) {
 }
 
 async function readLiveAccounts(page) {
-  const raw = await evaluateViaCdp(page, async () => {
+  const raw = await evaluatePageViaCdp(page, async () => {
     const metamask = (await window.stateHooks?.getCleanAppState?.())?.metamask || {};
     const accts = metamask.internalAccounts || {};
     const byId = accts.accounts || {};
@@ -931,7 +908,7 @@ async function applyAccountNames(page, expectedAccounts) {
     if (!account.name || !account.address.startsWith('0x')) {
       continue;
     }
-    await evaluateViaCdp(
+    await evaluatePageViaCdp(
       page,
       async ({ address, name }) => {
         const metamask = (await window.stateHooks?.getCleanAppState?.())?.metamask || {};
@@ -964,7 +941,7 @@ async function applySelectedAccount(page, expectedSelected) {
   if (!expectedSelected?.address) {
     return;
   }
-  await evaluateViaCdp(
+  await evaluatePageViaCdp(
     page,
     async ({ address }) => {
       const accounts =
@@ -1039,7 +1016,7 @@ async function seedCdp(args) {
   }
 
   try {
-    await evaluateViaCdp(page, async (state) => {
+    await evaluatePageViaCdp(page, async (state) => {
       await chrome.storage.local.set(state);
     }, versionedState);
   } catch (error) {

package/adapters/manifest.json

@@ -534,6 +534,22 @@
       "purpose": "Detached, silent registry probe used by the daily passive update notice.",
       "inputs": "<cache-file> <timeout-ms> [registry-endpoint]",
       "outputs": "atomic update-cache refresh; always silent and best-effort"
+    },
+    {
+      "id": "lib/private-atomic-write",
+      "entry": "adapters/shared/private-atomic-write.cjs",
+      "kind": "lib",
+      "purpose": "Publish private setup state through a no-follow temporary file and atomic rename.",
+      "inputs": "target path and file bytes on stdin",
+      "outputs": "owner-only target file"
+    },
+    {
+      "id": "lib/setup-base",
+      "entry": "adapters/shared/setup-base.sh",
+      "kind": "lib",
+      "purpose": "Bootstrap numbered MetaMask checkouts through the setup-base command.",
+      "inputs": "setup-base command arguments",
+      "outputs": "numbered checkouts, saved preferences, and run summary"
     }
   ]
 }

package/adapters/shared/private-atomic-write.cjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+const fs = require('node:fs');
+const path = require('node:path');
+
+const target = path.resolve(process.argv[2] || '');
+if (!process.argv[2]) {
+  process.stderr.write('private-atomic-write: target path is required\n');
+  process.exit(2);
+}
+
+let bytes = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => {
+  bytes += chunk;
+});
+process.stdin.on('end', () => {
+  const parent = path.dirname(target);
+  fs.mkdirSync(parent, { recursive: true, mode: 0o700 });
+
+  const temporary = path.join(
+    parent,
+    `.${path.basename(target)}.${process.pid}.${Date.now()}.tmp`,
+  );
+  let descriptor;
+  try {
+    descriptor = fs.openSync(
+      temporary,
+      fs.constants.O_CREAT |
+        fs.constants.O_EXCL |
+        fs.constants.O_WRONLY |
+        (fs.constants.O_NOFOLLOW || 0),
+      0o600,
+    );
+    fs.writeFileSync(descriptor, bytes);
+    fs.fsyncSync(descriptor);
+    fs.closeSync(descriptor);
+    descriptor = undefined;
+    fs.renameSync(temporary, target);
+  } finally {
+    if (descriptor !== undefined) fs.closeSync(descriptor);
+    try {
+      fs.unlinkSync(temporary);
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+    }
+  }
+});