@deeeed/metamask-harness 0.28.0 → 0.29.0

package/dist/adapters/extension/runtime.js

@@ -1,7 +1,13 @@
 import { spawn } from "node:child_process";
 import fs from "node:fs";
+import { createRequire } from "node:module";
 import path from "node:path";
-import { importRecipeHarnessRuntimeBrowserExtension, importRecipeHarnessRuntimeCdp, recipeRuntimeDir, resolveLocalProtocolRoot, resolveRequiredLocalProtocolRoot, runnerDir } from "../../paths.js";
+import { importRecipeHarnessRuntimeBrowserExtension, importRecipeHarnessRuntimeCdp, recipeHarnessPath, recipeRuntimeDir, resolveLocalProtocolRoot, runnerDir } from "../../paths.js";
+import { profileProcessPids } from "./validation-process-ownership.js";
+const require2 = createRequire(import.meta.url);
+const { detachedLaunchUnprovenPath, hasDetachedLaunchUnproven, shellQuote } = require2(
+  "../../../adapters/extension/lib/chrome-args.cjs"
+);
 const {
   CdpSession,
   jsonGet,
@@ -24,6 +30,7 @@ async function prepareExtensionRuntime(options) {
       projectRoot,
       cdpPort,
       slotId: slot.id,
+      launchTimeoutMs: options.validationLaunchTimeoutMs ?? 18e4,
       validationRuntimeDir: options.validationRuntimeDir ?? `${recipeRuntimeDir()}/validation-${cdpPort}`
     });
   }
@@ -323,27 +330,115 @@ function resolveExtensionSlot(projectRoot, requestedSlot) {
   return null;
 }
 async function launchHostValidationBrowser(options) {
-  const protocolRoot = resolveRequiredLocalProtocolRoot("Extension validation browser launch");
-  const script = path.join(protocolRoot, "projects/metamask-extension-farm/setup/launch-validation-browser.sh");
+  const script = recipeHarnessPath(options.projectRoot, "extension", "scripts", "live.sh");
   if (!fs.existsSync(script)) {
     throw new Error(`Extension validation launcher not found: ${script}`);
   }
-  await killCdpPort(options.cdpPort);
-  const result = await runProcess("bash", [
-    script,
-    options.slotId,
+  const validationRuntimeBaseDir = path.relative(
+    options.projectRoot,
+    path.resolve(options.projectRoot, options.validationRuntimeDir)
+  );
+  const escapesCheckout = !validationRuntimeBaseDir || validationRuntimeBaseDir === ".." || validationRuntimeBaseDir.startsWith(`..${path.sep}`) || path.isAbsolute(validationRuntimeBaseDir);
+  if (escapesCheckout) {
+    throw new Error(`Extension validation runtime must stay inside the target checkout: ${options.validationRuntimeDir}`);
+  }
+  const validationRuntimeBasePath = path.join(options.projectRoot, validationRuntimeBaseDir);
+  let currentPath = options.projectRoot;
+  for (const segment of validationRuntimeBaseDir.split(path.sep)) {
+    currentPath = path.join(currentPath, segment);
+    const currentStat = fs.lstatSync(currentPath, { throwIfNoEntry: false });
+    if (!currentStat) break;
+    if (currentStat.isSymbolicLink()) {
+      throw new Error(`Extension validation runtime must stay inside the target checkout: ${options.validationRuntimeDir}`);
+    }
+  }
+  fs.mkdirSync(validationRuntimeBasePath, { recursive: true });
+  const realRuntimeBaseDir = path.relative(
+    fs.realpathSync(options.projectRoot),
+    fs.realpathSync(validationRuntimeBasePath)
+  );
+  if (!realRuntimeBaseDir || realRuntimeBaseDir === ".." || realRuntimeBaseDir.startsWith(`..${path.sep}`) || path.isAbsolute(realRuntimeBaseDir)) {
+    throw new Error(`Extension validation runtime must stay inside the target checkout: ${options.validationRuntimeDir}`);
+  }
+  const validationRuntimeDir = path.join(validationRuntimeBaseDir, `port-${options.cdpPort}`);
+  const validationRuntimePath = path.join(options.projectRoot, validationRuntimeDir);
+  if (fs.lstatSync(validationRuntimePath, { throwIfNoEntry: false })?.isSymbolicLink()) {
+    throw new Error(`Extension validation runtime must stay inside the target checkout: ${options.validationRuntimeDir}`);
+  }
+  fs.mkdirSync(validationRuntimePath, { recursive: true });
+  const supervisor = await startValidationLaunchSupervisor(options.cdpPort);
+  try {
+    return await launchLockedValidationBrowser({
+      ...options,
+      script,
+      supervisor,
+      validationRuntimeDir,
+      validationRuntimePath
+    });
+  } finally {
+    await supervisor.close();
+  }
+}
+async function launchLockedValidationBrowser(options) {
+  const { validationRuntimeDir, validationRuntimePath } = options;
+  const walletFixtureDestination = path.join(validationRuntimePath, "wallet-fixture.json");
+  const validationProfileRoot = path.join(validationRuntimePath, "validation-profile-pw");
+  const validationArtifactsRoot = path.join(validationRuntimePath, "live");
+  for (const destination of [walletFixtureDestination, validationProfileRoot, validationArtifactsRoot]) {
+    if (fs.lstatSync(destination, { throwIfNoEntry: false })?.isSymbolicLink()) {
+      throw new Error(`Extension validation runtime must stay inside the target checkout: ${options.validationRuntimeDir}`);
+    }
+  }
+  fs.mkdirSync(validationProfileRoot, { recursive: true });
+  fs.mkdirSync(validationArtifactsRoot, { recursive: true });
+  assertNoQuarantinedValidationProfiles(validationProfileRoot);
+  await stopOwnedCdpListener(options.cdpPort, [
+    validationRuntimePath,
+    path.join(options.projectRoot, recipeRuntimeDir())
+  ]);
+  assertNoLiveValidationProfileOwners(validationProfileRoot);
+  pruneValidationRuns(validationProfileRoot, 0);
+  pruneValidationRuns(validationArtifactsRoot, 4);
+  const validationProfilePath = fs.mkdtempSync(path.join(validationProfileRoot, "run-"));
+  const validationArtifactsPath = fs.mkdtempSync(path.join(validationArtifactsRoot, "run-"));
+  if (fs.existsSync(walletFixtureDestination)) fs.unlinkSync(walletFixtureDestination);
+  fs.copyFileSync(
+    path.join(options.projectRoot, recipeRuntimeDir(), "wallet-fixture.json"),
+    walletFixtureDestination,
+    fs.constants.COPYFILE_EXCL
+  );
+  const result = await options.supervisor.run("bash", [
+    options.script,
+    "--target",
+    options.projectRoot,
     "--cdp-port",
     String(options.cdpPort),
-    "--runtime-dir",
-    options.validationRuntimeDir,
-    "--no-landing"
+    "--launch-existing-dist",
+    "--chrome-user-data-dir",
+    validationProfilePath,
+    "--artifacts-dir",
+    validationArtifactsPath
   ], {
-    cwd: protocolRoot,
-    env: process.env,
-    timeoutMs: 18e4
-  });
+    cwd: options.projectRoot,
+    env: {
+      ...process.env,
+      MM_HARNESS_BIN: path.join(runnerDir, "bin/mm-harness"),
+      PLAYWRIGHT_BROWSERS_PATH: path.join(
+        options.projectRoot,
+        recipeRuntimeDir(),
+        "ms-playwright"
+      ),
+      RECIPE_RUNTIME_DIR: validationRuntimeDir
+    },
+    profile: validationProfilePath
+  }, options.launchTimeoutMs);
+  if (result.error) {
+    throw new Error(`Extension validation launcher supervision failed: ${result.error}
+${result.stdout}
+${result.stderr}`);
+  }
   if (result.timedOut) {
-    throw new Error(`Extension validation launcher timed out after 180000ms.
+    throw new Error(`Extension validation launcher timed out after ${options.launchTimeoutMs}ms.
 ${result.stdout}
 ${result.stderr}`);
   }
@@ -352,27 +447,192 @@ ${result.stderr}`);
 ${result.stdout}
 ${result.stderr}`);
   }
+  const identity = readValidationRuntimeIdentity(validationRuntimePath, options.cdpPort);
+  const listenerPids = await inspectCdpListenerPids(options.cdpPort);
+  if (!identity || listenerPids.length !== 1 || listenerPids[0] !== identity.pid || !profileProcessPids(validationProfilePath).includes(identity.pid) || !await browserEchoesRuntimeNonce(options.cdpPort, identity.nonce)) {
+    throw new Error("Extension validation launcher exited without a live nonce-owned browser.");
+  }
+  await options.supervisor.release(true);
   return {
     launched: true,
     slotId: options.slotId,
     cdpPort: options.cdpPort,
-    runtimeDir: options.validationRuntimeDir,
+    runtimeDir: validationRuntimeDir,
     stdout: result.stdout
   };
 }
+async function startValidationLaunchSupervisor(cdpPort) {
+  const supervisorPath = path.join(runnerDir, "adapters/extension/lib/validation-launch-supervisor.cjs");
+  const child = spawn(process.execPath, [supervisorPath, String(cdpPort)], {
+    cwd: runnerDir,
+    env: process.env,
+    stdio: ["ignore", "pipe", "pipe", "ipc"]
+  });
+  let stdout = "";
+  let stderr = "";
+  let ready = false;
+  let runStarted = false;
+  let resultSettled = false;
+  let released = false;
+  let releaseError;
+  let resolveResult;
+  let rejectResult;
+  let resolveReady;
+  let rejectReady;
+  const readyPromise = new Promise((resolve, reject) => {
+    resolveReady = resolve;
+    rejectReady = reject;
+  });
+  const exitPromise = new Promise((resolve) => {
+    child.once("exit", (exitCode, signalCode) => resolve({ exitCode, signalCode }));
+  });
+  child.stdout.on("data", (chunk) => {
+    stdout += chunk;
+  });
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk;
+  });
+  child.on("message", (message) => {
+    if (message?.type === "ready") {
+      ready = true;
+      resolveReady?.();
+      return;
+    }
+    if (message?.type === "error") {
+      const error = new Error(String(message.message || "Extension validation supervisor failed."));
+      if (!ready) rejectReady?.(error);
+      else rejectResult?.(error);
+      return;
+    }
+    if (message?.type === "result") {
+      resultSettled = true;
+      resolveResult?.({
+        exitCode: typeof message.exitCode === "number" ? message.exitCode : null,
+        timedOut: message.timedOut === true,
+        ...typeof message.error === "string" ? { error: message.error } : {}
+      });
+      return;
+    }
+    if (message?.type === "release-error") {
+      releaseError = new Error(String(message.message || "Extension validation supervisor cleanup failed."));
+    }
+  });
+  child.once("error", (error) => {
+    if (!ready) rejectReady?.(error);
+    else rejectResult?.(error);
+  });
+  child.once("exit", (exitCode) => {
+    const error = new Error(`Extension validation supervisor exited with ${exitCode}.
+${stdout}
+${stderr}`);
+    if (!ready) rejectReady?.(error);
+    else if (runStarted && !resultSettled) rejectResult?.(error);
+  });
+  await readyPromise;
+  return {
+    async run(command, args, options, timeoutMs) {
+      if (runStarted) throw new Error("Extension validation supervisor already launched.");
+      runStarted = true;
+      const resultPromise = new Promise((resolve, reject) => {
+        resolveResult = resolve;
+        rejectResult = reject;
+      });
+      child.send({
+        type: "run",
+        command,
+        args,
+        cwd: options.cwd,
+        env: options.env,
+        profile: options.profile,
+        timeoutMs
+      });
+      const result = await resultPromise;
+      return { ...result, stdout, stderr };
+    },
+    async release(preserveProfileOwner) {
+      if (released) return;
+      released = true;
+      if (child.connected) child.send({ type: "release", preserveProfileOwner });
+      const exit = await exitPromise;
+      if (releaseError) throw releaseError;
+      if (exit.exitCode !== 0) {
+        throw new Error(`Extension validation supervisor exited with ${exit.exitCode ?? exit.signalCode}.
+${stdout}
+${stderr}`);
+      }
+    },
+    async close() {
+      if (released) return;
+      released = true;
+      if (child.exitCode === null && child.signalCode === null && child.connected) {
+        child.send(runStarted ? { type: "release", preserveProfileOwner: false } : { type: "cancel" });
+      }
+      const exit = await exitPromise;
+      if (releaseError) throw releaseError;
+      if (exit.exitCode !== 0) {
+        throw new Error(`Extension validation supervisor exited with ${exit.exitCode ?? exit.signalCode}.
+${stdout}
+${stderr}`);
+      }
+    }
+  };
+}
+function processExists(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+function assertNoQuarantinedValidationProfiles(profileRoot) {
+  for (const name of fs.readdirSync(profileRoot).filter((entry) => entry.startsWith("run-"))) {
+    const profile = path.join(profileRoot, name);
+    if (!fs.lstatSync(profile, { throwIfNoEntry: false })?.isDirectory()) continue;
+    if (!hasDetachedLaunchUnproven(profile)) continue;
+    const marker = detachedLaunchUnprovenPath(profile);
+    throw new Error(
+      `Extension validation will not prune the quarantined profile ${profile}. Next: confirm no process uses that profile, then run: rm -- ${shellQuote(marker)}`
+    );
+  }
+}
+function assertNoLiveValidationProfileOwners(profileRoot) {
+  for (const name of fs.readdirSync(profileRoot).filter((entry) => entry.startsWith("run-"))) {
+    const profile = path.join(profileRoot, name);
+    if (!fs.lstatSync(profile, { throwIfNoEntry: false })?.isDirectory()) continue;
+    const pids = profileProcessPids(profile);
+    if (pids.length > 0) {
+      throw new Error(
+        `Extension validation will not prune the live profile ${profile} (pid ${pids.join(", ")}). Next: stop that browser and rerun the validation.`
+      );
+    }
+  }
+}
+function pruneValidationRuns(root, keep) {
+  const runs = fs.readdirSync(root).filter((name) => name.startsWith("run-")).map((name) => {
+    const entryPath = path.join(root, name);
+    return { entryPath, mtimeMs: fs.lstatSync(entryPath).mtimeMs };
+  }).sort((left, right) => right.mtimeMs - left.mtimeMs || right.entryPath.localeCompare(left.entryPath));
+  for (const { entryPath } of runs.slice(keep)) {
+    const entryStat = fs.lstatSync(entryPath, { throwIfNoEntry: false });
+    if (!entryStat) continue;
+    if (entryStat.isSymbolicLink() || !entryStat.isDirectory()) fs.unlinkSync(entryPath);
+    else fs.rmSync(entryPath, { recursive: true, force: true });
+  }
+}
 function runProcess(command, args, options) {
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, { cwd: options.cwd, env: options.env, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
     let settled = false;
+    let didTimeout = false;
+    let killTimer;
     const timeout = options.timeoutMs ? setTimeout(() => {
       if (settled) return;
-      settled = true;
+      didTimeout = true;
       child.kill("SIGTERM");
-      const killTimer = setTimeout(() => child.kill("SIGKILL"), 1e3);
-      child.once("close", () => clearTimeout(killTimer));
-      resolve({ exitCode: null, stdout, stderr, timedOut: true });
+      killTimer = setTimeout(() => child.kill("SIGKILL"), 1e3);
     }, options.timeoutMs) : void 0;
     child.stdout.on("data", (chunk) => {
       stdout += chunk;
@@ -384,23 +644,106 @@ function runProcess(command, args, options) {
       if (settled) return;
       settled = true;
       if (timeout) clearTimeout(timeout);
+      if (killTimer) clearTimeout(killTimer);
       reject(error);
     });
     child.on("close", (exitCode) => {
       if (settled) return;
       settled = true;
       if (timeout) clearTimeout(timeout);
-      resolve({ exitCode, stdout, stderr, timedOut: false });
+      if (killTimer) clearTimeout(killTimer);
+      resolve({ exitCode, stdout, stderr, timedOut: didTimeout });
     });
   });
 }
-async function killCdpPort(cdpPort) {
+async function stopOwnedCdpListener(cdpPort, runtimePaths) {
   if (process.platform !== "darwin" && process.platform !== "linux") return;
-  await runProcess("bash", ["-lc", `lsof -ti tcp:${cdpPort} -sTCP:LISTEN | xargs -r kill -TERM || true; sleep 1; lsof -ti tcp:${cdpPort} -sTCP:LISTEN | xargs -r kill -KILL || true`], {
+  let listenerPids = await inspectCdpListenerPids(cdpPort);
+  if (listenerPids.length === 0) return;
+  const identity = runtimePaths.map((runtimePath) => readValidationRuntimeIdentity(runtimePath, cdpPort)).find((candidate) => candidate?.pid === listenerPids[0]);
+  if (!identity || listenerPids.length !== 1 || listenerPids[0] !== identity.pid || !await browserEchoesRuntimeNonce(cdpPort, identity.nonce)) {
+    throw new Error(`Extension validation will not stop an unowned CDP listener on port ${cdpPort}.`);
+  }
+  try {
+    process.kill(identity.pid, "SIGTERM");
+  } catch (error) {
+    if (error.code !== "ESRCH") throw error;
+  }
+  const termDeadline = Date.now() + 1e3;
+  do {
+    await sleep(50);
+    listenerPids = await inspectCdpListenerPids(cdpPort);
+  } while ((listenerPids.length > 0 || processExists(identity.pid)) && Date.now() < termDeadline);
+  if (listenerPids.length > 0 || processExists(identity.pid)) {
+    try {
+      process.kill(identity.pid, "SIGKILL");
+    } catch (error) {
+      if (error.code !== "ESRCH") throw error;
+    }
+    const killDeadline = Date.now() + 1e3;
+    do {
+      await sleep(50);
+      listenerPids = await inspectCdpListenerPids(cdpPort);
+    } while ((listenerPids.length > 0 || processExists(identity.pid)) && Date.now() < killDeadline);
+  }
+  if (listenerPids.length > 0 || processExists(identity.pid)) {
+    throw new Error(`Extension validation could not stop its CDP listener on port ${cdpPort}.`);
+  }
+}
+async function inspectCdpListenerPids(cdpPort) {
+  const result = await runProcess("lsof", ["-ti", `tcp:${cdpPort}`, "-sTCP:LISTEN"], {
     cwd: runnerDir,
     env: process.env,
-    timeoutMs: 1e4
+    timeoutMs: 5e3
   });
+  const noListener = result.exitCode === 1 && !result.stdout.trim() && !result.stderr.trim();
+  if (result.timedOut || result.exitCode !== 0 && !noListener) {
+    throw new Error(`Extension validation could not inspect the CDP listener on port ${cdpPort}.`);
+  }
+  const pids = result.stdout.trim() ? result.stdout.trim().split(/\s+/u).map(Number) : [];
+  if (pids.some((pid) => !Number.isInteger(pid) || pid <= 0)) {
+    throw new Error(`Extension validation received invalid CDP listener ownership for port ${cdpPort}.`);
+  }
+  return [...new Set(pids)];
+}
+function readValidationRuntimeIdentity(validationRuntimePath, cdpPort) {
+  const identityPath = path.join(validationRuntimePath, "extension-runtime-identity.json");
+  let descriptor;
+  try {
+    descriptor = fs.openSync(identityPath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+    const stat = fs.fstatSync(descriptor);
+    if (!stat.isFile() || stat.size <= 0 || stat.size > 4096 || (stat.mode & 63) !== 0) return null;
+    const parsed = JSON.parse(fs.readFileSync(descriptor, "utf8"));
+    if (parsed.port !== cdpPort || !Number.isInteger(parsed.pid) || Number(parsed.pid) <= 0 || typeof parsed.nonce !== "string" || !/^[a-f0-9]{64}$/u.test(parsed.nonce)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  } finally {
+    if (descriptor !== void 0) fs.closeSync(descriptor);
+  }
+}
+async function browserEchoesRuntimeNonce(cdpPort, nonce) {
+  let session;
+  try {
+    const version = await jsonGet(`http://127.0.0.1:${cdpPort}/json/version`, { timeoutMs: 2e3 });
+    if (typeof version.webSocketDebuggerUrl !== "string") return false;
+    session = await CdpSession.connect(version.webSocketDebuggerUrl, { timeoutMs: 2e3 });
+    const result = await boundedCdpCall(
+      session,
+      "Browser.getBrowserCommandLine",
+      {},
+      2e3
+    );
+    if (!Array.isArray(result.arguments)) return false;
+    const expected = `--mm-harness-runtime-nonce=${nonce}`;
+    return result.arguments.filter((argument) => argument === expected).length === 1;
+  } catch {
+    return false;
+  } finally {
+    session?.close();
+  }
 }
 function safeExtensionId(target) {
   try {

package/dist/adapters/extension/validation-process-ownership.js

@@ -0,0 +1,10 @@
+import { createRequire } from "node:module";
+const require2 = createRequire(import.meta.url);
+const processOwnership = require2(
+  "../../../adapters/extension/lib/validation-process-ownership.cjs"
+);
+const { profileProcessPids, stopProfileProcesses } = processOwnership;
+export {
+  profileProcessPids,
+  stopProfileProcesses
+};

package/dist/cli-commands.js

@@ -8,6 +8,7 @@ const SPEC = {
     { name: "help", aliases: ["-h", "--help"], desc: "Show usage" }
   ],
   shared: [
+    { name: "setup-base", desc: "Bootstrap numbered product checkouts", flags: ["--dir", "--counts", "--only", "--dry-run", "--force", "--json", "--show-config", "--reset-config", "--skip-harness-update"] },
     { name: "status", aliases: ["health", "home"], desc: "Home status + next commands", flags: ["--json", "--fast"] },
     { name: "ports", desc: "Slot ports and runtime paths", flags: ["--json"] },
     { name: "up", desc: "Decide + run minimum work to reach ready", flags: ["--json", "--dry-run"] },

package/dist/command-contract.js

@@ -50,6 +50,18 @@ const REMOVED_OPTION_REPLACEMENTS = {
   "--record": "--record-video"
 };
 const PUBLIC_COMMAND_CONTRACTS = {
+  "setup-base": {
+    options: options(HELP, JSON, {
+      "--dir": value(),
+      "--counts": value(),
+      "--only": value(),
+      "--dry-run": bool(),
+      "--force": bool(),
+      "--show-config": bool(),
+      "--reset-config": bool(),
+      "--skip-harness-update": bool()
+    })
+  },
   status: {
     aliases: ["health", "home"],
     options: options(HELP, JSON, TARGET, DEVICE, {