@deeeed/metamask-harness 0.77.0 → 0.79.0

package/adapters/extension/lib/chrome-args.cjs

@@ -1,365 +0,0 @@
-'use strict';
-const crypto = require('node:crypto');
-const fs = require('node:fs');
-const path = require('node:path');
-
-const RUNTIME_IDENTITY_FILENAME = 'extension-runtime-identity.json';
-const RUNTIME_NONCE_PREFIX = '--mm-harness-runtime-nonce=';
-const DETACHED_LAUNCH_UNPROVEN_FILENAME = '.mm-harness-detached-launch-unproven';
-// chrome-args.cjs — single source of truth for the remote-debugging launch flags
-// shared by BOTH extension launchers: the fresh spawn (launch-browser.cjs) and the
-// reopen path (ensure-browser.sh → reopen-browser.sh). Keeping the debug-port trio
-// here means `--remote-allow-origins` can never drift away from the port it scopes:
-// the two are declared once and always travel together. Without the allow-origins
-// entry Chrome 403s every browser DevTools WebSocket on the debug port and
-// `mm-harness debug` cannot attach a visible console.
-
-// The exact origin allowed is the locally-served bundled DevTools frontend, which
-// Chrome serves at http://127.0.0.1:<cdpPort>. Scoped to that origin — never `*`.
-function remoteDebuggingArgs(cdpPort) {
-  const port = Number(cdpPort);
-  if (!Number.isInteger(port) || port <= 0) {
-    throw new Error(`remoteDebuggingArgs: invalid cdp port: ${cdpPort}`);
-  }
-  return [
-    '--remote-debugging-address=127.0.0.1',
-    `--remote-debugging-port=${port}`,
-    `--remote-allow-origins=http://127.0.0.1:${port}`,
-  ];
-}
-
-// An isolated automation profile must never ask for or write credentials in the
-// operator's macOS login keychain. Chromium's mock keychain keeps profile-local
-// encryption deterministic and prevents modal prompts from blocking startup.
-function isolatedProfileArgs(platform = process.platform) {
-  return platform === 'darwin' ? ['--use-mock-keychain'] : [];
-}
-
-// Keep requestAnimationFrame, transitions, and input hit testing alive when the
-// slot-owned browser is occluded by the operator's other windows.
-function automationRuntimeArgs() {
-  return [
-    '--disable-background-timer-throttling',
-    '--disable-backgrounding-occluded-windows',
-    '--disable-renderer-backgrounding',
-  ];
-}
-
-function createRuntimeIdentityNonce() {
-  return crypto.randomBytes(32).toString('hex');
-}
-
-function runtimeIdentityArgs(nonce) {
-  if (!/^[a-f0-9]{64}$/u.test(nonce)) {
-    throw new Error('runtimeIdentityArgs: nonce must be 32 bytes encoded as lowercase hex');
-  }
-  return ['--enable-automation', `${RUNTIME_NONCE_PREFIX}${nonce}`];
-}
-
-function runtimeIdentityPath(runtimeDir) {
-  return path.join(path.resolve(runtimeDir), RUNTIME_IDENTITY_FILENAME);
-}
-
-function detachedLaunchUnprovenPath(profile) {
-  return path.join(path.resolve(profile), DETACHED_LAUNCH_UNPROVEN_FILENAME);
-}
-
-function validationPortQuarantineRoot() {
-  if (typeof process.getuid !== 'function') {
-    throw new Error('Extension validation port quarantine requires a POSIX user identity.');
-  }
-  const uid = process.getuid();
-  const root = path.join(fs.realpathSync('/tmp'), `mm-harness-extension-validation-${uid}`);
-  try {
-    fs.mkdirSync(root, { mode: 0o700 });
-  } catch (error) {
-    if (error.code !== 'EEXIST') throw error;
-  }
-  const stat = fs.lstatSync(root);
-  if (
-    stat.isSymbolicLink() ||
-    !stat.isDirectory() ||
-    stat.uid !== uid ||
-    (stat.mode & 0o777) !== 0o700
-  ) {
-    throw new Error(`Extension validation quarantine root is not an owner-only directory: ${root}`);
-  }
-  return root;
-}
-
-function validationPortQuarantinePath(port) {
-  const numericPort = Number(port);
-  if (!Number.isInteger(numericPort) || numericPort <= 0 || numericPort > 65535) {
-    throw new Error(`validationPortQuarantinePath: invalid cdp port: ${port}`);
-  }
-  return path.join(validationPortQuarantineRoot(), `port-${numericPort}.json`);
-}
-
-function readValidationPortQuarantine(port) {
-  const destination = validationPortQuarantinePath(port);
-  let descriptor;
-  try {
-    descriptor = fs.openSync(destination, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
-    const stat = fs.fstatSync(descriptor);
-    if (
-      !stat.isFile() ||
-      stat.uid !== process.getuid() ||
-      stat.size <= 0 ||
-      stat.size > 4_096 ||
-      (stat.mode & 0o777) !== 0o600
-    ) {
-      return { path: destination };
-    }
-    const value = JSON.parse(fs.readFileSync(descriptor, 'utf8'));
-    if (
-      value.schemaVersion !== 1 ||
-      value.port !== Number(port) ||
-      typeof value.profile !== 'string' ||
-      (value.lease !== undefined && !/^[a-f0-9]{64}$/u.test(value.lease))
-    ) {
-      return { path: destination };
-    }
-    return {
-      path: destination,
-      profile: value.profile,
-      ...(value.lease === undefined ? {} : { lease: value.lease }),
-    };
-  } catch (error) {
-    if (error.code === 'ENOENT') return null;
-    return { path: destination };
-  } finally {
-    if (descriptor !== undefined) fs.closeSync(descriptor);
-  }
-}
-
-function writeValidationPortQuarantine(port, profile, reason, allowExisting, lease) {
-  const destination = validationPortQuarantinePath(port);
-  const pending = path.join(
-    path.dirname(destination),
-    `.port-${Number(port)}.${process.pid}.${crypto.randomBytes(16).toString('hex')}.pending`,
-  );
-  let descriptor;
-  try {
-    descriptor = fs.openSync(
-      pending,
-      fs.constants.O_WRONLY |
-        fs.constants.O_CREAT |
-        fs.constants.O_EXCL |
-        fs.constants.O_NOFOLLOW,
-      0o600,
-    );
-    fs.fchmodSync(descriptor, 0o600);
-    fs.writeFileSync(descriptor, `${JSON.stringify({
-      schemaVersion: 1,
-      port: Number(port),
-      profile: path.resolve(profile),
-      reason: String(reason).slice(0, 1_024),
-      ...(lease === undefined ? {} : { lease }),
-    })}\n`, 'utf8');
-    fs.fsyncSync(descriptor);
-    fs.closeSync(descriptor);
-    descriptor = undefined;
-    fs.linkSync(pending, destination);
-    return destination;
-  } catch (error) {
-    if (allowExisting && error.code === 'EEXIST') return destination;
-    throw error;
-  } finally {
-    if (descriptor !== undefined) {
-      try {
-        fs.closeSync(descriptor);
-      } catch {}
-    }
-    try {
-      fs.unlinkSync(pending);
-    } catch (error) {
-      if (error.code !== 'ENOENT') throw error;
-    }
-  }
-}
-
-function markValidationPortLaunchUnproven(port, profile, lease) {
-  if (lease !== undefined && !/^[a-f0-9]{64}$/u.test(lease)) {
-    throw new Error('markValidationPortLaunchUnproven: invalid lease');
-  }
-  return writeValidationPortQuarantine(
-    port,
-    profile,
-    'A detached browser launch was submitted but ownership was not proven.',
-    false,
-    lease,
-  );
-}
-
-function quarantineValidationPort(port, profile, reason) {
-  return writeValidationPortQuarantine(port, profile, reason, true, undefined);
-}
-
-function clearValidationPortQuarantine(port, profile, lease) {
-  const quarantine = readValidationPortQuarantine(port);
-  if (!quarantine) return;
-  if (
-    quarantine.profile !== path.resolve(profile) ||
-    (quarantine.lease !== undefined && quarantine.lease !== lease)
-  ) {
-    throw new Error(`Extension validation port ${port} is quarantined for another or invalid profile.`);
-  }
-  fs.unlinkSync(quarantine.path);
-}
-
-function shellQuote(value) {
-  return `'${String(value).replaceAll("'", `'"'"'`)}'`;
-}
-
-function validationLaunchQuarantineError(port, ownerProfile, requestedProfile) {
-  const portMarker = validationPortQuarantinePath(port);
-  const profiles = [...new Set([ownerProfile, requestedProfile]
-    .filter((profile) => typeof profile === 'string')
-    .map((profile) => path.resolve(profile)))];
-  const markers = [
-    ...profiles.map(detachedLaunchUnprovenPath),
-    portMarker,
-  ];
-  const profileText = profiles.length > 0 ? ` or profile ${profiles.join(' or ')}` : '';
-  return new Error(
-    `Refusing to launch on CDP port ${port} because its detached browser state is quarantined. ` +
-      `Next: confirm no browser uses port ${port}${profileText}, then run: rm -- ${markers.map(shellQuote).join(' ')}`,
-  );
-}
-
-function writeDetachedLaunchMarker(profile, reason, allowExisting) {
-  const destination = detachedLaunchUnprovenPath(profile);
-  fs.mkdirSync(path.dirname(destination), { recursive: true });
-  let descriptor;
-  try {
-    descriptor = fs.openSync(
-      destination,
-      fs.constants.O_WRONLY |
-        fs.constants.O_CREAT |
-        fs.constants.O_EXCL |
-        fs.constants.O_NOFOLLOW,
-      0o600,
-    );
-    fs.fchmodSync(descriptor, 0o600);
-    fs.writeFileSync(descriptor, `${reason}\n`, 'utf8');
-    fs.fsyncSync(descriptor);
-    fs.closeSync(descriptor);
-    return destination;
-  } catch (error) {
-    if (descriptor !== undefined) {
-      try {
-        fs.closeSync(descriptor);
-      } catch {}
-    }
-    if (allowExisting && error.code === 'EEXIST') return destination;
-    throw error;
-  }
-}
-
-function markDetachedLaunchUnproven(profile) {
-  return writeDetachedLaunchMarker(
-    profile,
-    'A detached browser launch was submitted but ownership was not proven.',
-    false,
-  );
-}
-
-function quarantineDetachedLaunch(profile, reason) {
-  return writeDetachedLaunchMarker(profile, reason, true);
-}
-
-function hasDetachedLaunchUnproven(profile) {
-  return fs.lstatSync(detachedLaunchUnprovenPath(profile), { throwIfNoEntry: false }) !== undefined;
-}
-
-function clearDetachedLaunchUnproven(profile) {
-  const destination = detachedLaunchUnprovenPath(profile);
-  const stat = fs.lstatSync(destination, { throwIfNoEntry: false });
-  if (!stat) return;
-  if (stat.isSymbolicLink() || !stat.isFile()) {
-    throw new Error(`Detached launch marker is not a regular file: ${destination}`);
-  }
-  fs.unlinkSync(destination);
-}
-
-function removeRuntimeIdentity(runtimeDir) {
-  fs.rmSync(runtimeIdentityPath(runtimeDir), { force: true });
-}
-
-function writeRuntimeIdentity(runtimeDir, identity) {
-  assertRuntimeIdentity(identity);
-  const destination = runtimeIdentityPath(runtimeDir);
-  const directory = path.dirname(destination);
-  fs.mkdirSync(directory, { recursive: true });
-  const temporary = path.join(
-    directory,
-    `.${RUNTIME_IDENTITY_FILENAME}.${process.pid}.${crypto.randomBytes(8).toString('hex')}.tmp`,
-  );
-  let descriptor;
-  try {
-    descriptor = fs.openSync(
-      temporary,
-      fs.constants.O_WRONLY |
-        fs.constants.O_CREAT |
-        fs.constants.O_EXCL |
-        fs.constants.O_NOFOLLOW,
-      0o600,
-    );
-    fs.fchmodSync(descriptor, 0o600);
-    fs.writeFileSync(descriptor, `${JSON.stringify(identity)}\n`, 'utf8');
-    fs.fsyncSync(descriptor);
-    fs.closeSync(descriptor);
-    descriptor = undefined;
-    fs.renameSync(temporary, destination);
-  } catch (error) {
-    if (descriptor !== undefined) {
-      try {
-        fs.closeSync(descriptor);
-      } catch {}
-    }
-    fs.rmSync(temporary, { force: true });
-    throw error;
-  }
-}
-
-function assertRuntimeIdentity(identity) {
-  if (
-    !identity ||
-    !Number.isInteger(identity.port) ||
-    identity.port <= 0 ||
-    identity.port > 65535 ||
-    !Number.isInteger(identity.pid) ||
-    identity.pid <= 0 ||
-    !Number.isInteger(identity.startedAt) ||
-    identity.startedAt <= 0 ||
-    !/^[a-f0-9]{64}$/u.test(identity.nonce)
-  ) {
-    throw new Error('writeRuntimeIdentity: invalid runtime identity');
-  }
-}
-
-module.exports = {
-  DETACHED_LAUNCH_UNPROVEN_FILENAME,
-  RUNTIME_IDENTITY_FILENAME,
-  RUNTIME_NONCE_PREFIX,
-  automationRuntimeArgs,
-  clearDetachedLaunchUnproven,
-  clearValidationPortQuarantine,
-  createRuntimeIdentityNonce,
-  detachedLaunchUnprovenPath,
-  hasDetachedLaunchUnproven,
-  isolatedProfileArgs,
-  markDetachedLaunchUnproven,
-  markValidationPortLaunchUnproven,
-  quarantineDetachedLaunch,
-  quarantineValidationPort,
-  readValidationPortQuarantine,
-  remoteDebuggingArgs,
-  removeRuntimeIdentity,
-  runtimeIdentityArgs,
-  runtimeIdentityPath,
-  shellQuote,
-  validationLaunchQuarantineError,
-  validationPortQuarantinePath,
-  writeRuntimeIdentity,
-};

package/adapters/extension/lib/extension-id.cjs

@@ -1,36 +0,0 @@
-'use strict';
-
-const crypto = require('node:crypto');
-const fs = require('node:fs');
-const path = require('node:path');
-
-// Chromium extension IDs encode each SHA-256 nibble as a-p.
-const CHROMIUM_EXTENSION_ID_ALPHABET = 'abcdefghijklmnop';
-
-function extensionIdFromManifestKey(keyBase64) {
-  if (typeof keyBase64 !== 'string' || !keyBase64) return '';
-  const digest = crypto.createHash('sha256').update(Buffer.from(keyBase64, 'base64')).digest();
-  return [...digest.subarray(0, 16)]
-    .map((byte) => `${CHROMIUM_EXTENSION_ID_ALPHABET[byte >> 4]}${CHROMIUM_EXTENSION_ID_ALPHABET[byte & 0x0f]}`)
-    .join('');
-}
-
-function extensionIdFromManifestFile(manifestPath) {
-  try {
-    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-    return extensionIdFromManifestKey(manifest.key);
-  } catch {
-    return '';
-  }
-}
-
-function extensionIdFromExtensionDir(extensionDir) {
-  return extensionIdFromManifestFile(path.join(extensionDir, 'manifest.json'));
-}
-
-module.exports = {
-  CHROMIUM_EXTENSION_ID_ALPHABET,
-  extensionIdFromManifestKey,
-  extensionIdFromManifestFile,
-  extensionIdFromExtensionDir,
-};

package/adapters/extension/lib/macos-focus.cjs

@@ -1,108 +0,0 @@
-'use strict';
-
-// macOS focus helpers for launchers that start a headed browser in the
-// background. One owner (the launcher) and one decision: after the launch
-// settles, if the frontmost process is one of OUR browser pids, give the front
-// back to the app that had it, once, by pid. Anything else in front (the
-// operator's own Chrome included, whatever its bundle) is left alone. A restore
-// only activates an already-running app (never `open -a`, which can launch).
-// MM_HARNESS_FOCUS_HOLD=0 makes every function here a no-op (tests).
-
-const { execFileSync } = require('node:child_process');
-
-// Upper bound for one Launch Services query or activation.
-const LS_TIMEOUT_MS = 2000;
-// Activates a running app by pid; prints "missing" for a pid with no app.
-const ACTIVATE_BY_PID = [
-  'function run(argv) {',
-  "  ObjC.import('AppKit');",
-  '  const app = $.NSRunningApplication.runningApplicationWithProcessIdentifier(Number(argv[0]));',
-  "  if (!app || app.isNil()) return 'missing';",
-  "  return app.activateWithOptions($.NSApplicationActivateIgnoringOtherApps) ? 'ok' : 'failed';",
-  '}',
-].join('\n');
-
-function macFocusDisabled() {
-  return process.platform !== 'darwin' ||
-    process.env.MM_HARNESS_FOCUS_HOLD === '0' ||
-    process.env.MM_HARNESS_FOCUS_BROWSER === '1';
-}
-
-// At most one restore per launcher process.
-let restored = false;
-
-function lsappinfo(args) {
-  return execFileSync('lsappinfo', args, {
-    encoding: 'utf8',
-    env: { ...process.env },
-    stdio: ['ignore', 'pipe', 'ignore'],
-    timeout: LS_TIMEOUT_MS,
-  });
-}
-
-function parseLsappinfo(info) {
-  const pid = Number.parseInt((info.match(/\bpid\s*=\s*(\d+)/u) || info.match(/"pid"=(\d+)/u) || [])[1], 10);
-  const bundlePath = (info.match(/bundle path="([^"]+)"/u) || info.match(/"LSBundlePath"="([^"]+)"/u) || [])[1];
-  const name = (info.match(/^"([^"]+)"/mu) || info.match(/"LSDisplayName"="([^"]+)"/u) || [])[1];
-  if (!Number.isInteger(pid) || pid <= 0) return null;
-  return { pid, bundlePath: bundlePath || null, name: name || bundlePath || `pid ${pid}` };
-}
-
-// The frontmost app as { pid, bundlePath, name }, or null when unknown.
-function captureMacFrontmost() {
-  if (macFocusDisabled()) return null;
-  try {
-    const asn = lsappinfo(['front']).trim();
-    return asn ? parseLsappinfo(lsappinfo(['info', asn])) : null;
-  } catch {
-    // Best effort: lsappinfo missing, timed out, or the app exited.
-    return null;
-  }
-}
-
-function macFrontmostPid() {
-  return captureMacFrontmost()?.pid ?? null;
-}
-
-// Bring an already-running app to the front by pid. Never launches anything.
-function activateMacAppByPid(pid) {
-  if (macFocusDisabled() || !Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    return execFileSync('osascript', ['-l', 'JavaScript', '-e', ACTIVATE_BY_PID, String(pid)], {
-      encoding: 'utf8',
-      env: { ...process.env },
-      stdio: ['ignore', 'pipe', 'ignore'],
-      timeout: LS_TIMEOUT_MS,
-    }).trim() === 'ok';
-  } catch {
-    // Best effort: osascript failed or timed out; the operator keeps whatever is in front.
-    return false;
-  }
-}
-
-// One check, at most one restore: 'restored' when our browser had the front
-// and `previous` got it back, 'kept' when anything else is in front (left as
-// is), 'off' when focus handling is disabled or there is nothing to restore.
-// A click on the slot window right after launch can therefore be undone once.
-function restoreFrontmostIfOurs(previous, ourPids) {
-  if (macFocusDisabled() || restored || !Number.isInteger(previous?.pid) || previous.pid <= 0) return 'off';
-  const ours = new Set((ourPids || []).filter((pid) => Number.isInteger(pid) && pid > 0));
-  if (ours.size === 0 || ours.has(previous.pid)) return 'off';
-  const front = macFrontmostPid();
-  if (front === null || !ours.has(front)) return 'kept';
-  restored = true;
-  return activateMacAppByPid(previous.pid) ? 'restored' : 'kept';
-}
-
-function macBackgroundOpenArgs(application, chromeArgs) {
-  return ['-g', '-n', '-a', application, '--args', ...chromeArgs];
-}
-
-module.exports = {
-  activateMacAppByPid,
-  captureMacFrontmost,
-  macBackgroundOpenArgs,
-  macFocusDisabled,
-  macFrontmostPid,
-  restoreFrontmostIfOurs,
-};

package/adapters/extension/lib/playwright-cdp.cjs

@@ -1,50 +0,0 @@
-'use strict';
-
-const path = require('node:path');
-const { createRequire } = require('node:module');
-
-function loadChromium() {
-  const runtimeRequire = createRequire(path.join(process.cwd(), 'package.json'));
-  try {
-    return runtimeRequire('@playwright/test').chromium;
-  } catch {
-    return runtimeRequire('playwright').chromium;
-  }
-}
-
-async function connectBrowserViaCdp(endpoint) {
-  return loadChromium().connectOverCDP(endpoint);
-}
-
-function buildEvaluationExpression(callbackOrExpression, argument) {
-  if (typeof callbackOrExpression === 'string') return callbackOrExpression;
-  if (typeof callbackOrExpression !== 'function') {
-    throw new TypeError('CDP evaluation requires a function or expression string.');
-  }
-  return argument === undefined
-    ? `(${callbackOrExpression.toString()})()`
-    : `(${callbackOrExpression.toString()})(${JSON.stringify(argument)})`;
-}
-
-async function evaluatePageViaCdp(page, callbackOrExpression, argument) {
-  const session = await page.context().newCDPSession(page);
-  try {
-    const response = await session.send('Runtime.evaluate', {
-      expression: buildEvaluationExpression(callbackOrExpression, argument),
-      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(() => {});
-  }
-}
-
-module.exports = { buildEvaluationExpression, connectBrowserViaCdp, evaluatePageViaCdp };