@deeeed/metamask-harness 0.79.0 → 0.80.0

package/dist/library-provenance.js

@@ -1,33 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-const execFileAsync = promisify(execFile);
-async function gitLibraryProvenance(root) {
-  try {
-    const { stdout: tracked } = await execFileAsync("git", ["-C", root, "ls-files", "--", "."], {
-      encoding: "utf8",
-      timeout: 5e3
-    });
-    if (!tracked.trim()) return {};
-    const [{ stdout: revision }, { stdout: status }] = await Promise.all([
-      execFileAsync("git", ["-C", root, "rev-parse", "HEAD"], {
-        encoding: "utf8",
-        timeout: 5e3
-      }),
-      execFileAsync(
-        "git",
-        ["-C", root, "status", "--porcelain=v1", "--untracked-files=normal", "--", "."],
-        {
-          encoding: "utf8",
-          timeout: 5e3
-        }
-      )
-    ]);
-    const trimmedRevision = revision.trim();
-    return trimmedRevision ? { revision: trimmedRevision, dirty: status.trim().length > 0 } : {};
-  } catch {
-    return {};
-  }
-}
-export {
-  gitLibraryProvenance
-};

package/dist/live-adapter-contract.js

@@ -1,380 +0,0 @@
-import { recordCommandOutput } from "./command-journal.js";
-import { trackCheckoutChild } from "./checkout-lock.js";
-import { createHash } from "node:crypto";
-import { access, mkdtemp, readFile, realpath, rm, writeFile } from "node:fs/promises";
-import { existsSync, readFileSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { spawn } from "node:child_process";
-import { pathToFileURL } from "node:url";
-import { build } from "esbuild";
-import { init, parse } from "es-module-lexer";
-import { resolveRequiredLocalProtocolRoot, runnerDir } from "./paths.js";
-import { adapterRegistry } from "./adapters/registry.js";
-import { getAdapterSurface } from "./adapters/surface.js";
-import { serializeTrustedMutationContext } from "./funding-execution-context.js";
-function actionFileStem(action) {
-  return String(action).replace(/[^a-zA-Z0-9._-]/g, "_");
-}
-function actionParts(action) {
-  const parts = String(action).split(".").filter(Boolean);
-  if (parts.length >= 3 && parts[0] === "metamask") {
-    return { family: parts[1], localName: parts.slice(2).join(".") };
-  }
-  if (parts.length >= 2) {
-    return { family: parts[0], localName: parts.slice(1).join(".") };
-  }
-  return { family: "actions", localName: String(action) };
-}
-function candidateStems(action) {
-  const stem = actionFileStem(action);
-  const { localName } = actionParts(action);
-  const localStem = actionFileStem(localName);
-  const stems = [stem];
-  if (localStem && localStem !== stem) stems.push(localStem);
-  return stems;
-}
-function candidateFamilies(action) {
-  const { family } = actionParts(action);
-  const families = [family];
-  return [...new Set(families)];
-}
-function candidatePaths(platform, action, runtimeEnv = process.env) {
-  const stems = candidateStems(action);
-  const families = candidateFamilies(action);
-  const declaredRoot = declaredActionRoot(
-    runtimeEnv.METAMASK_RECIPE_ACTION_SOURCE_MAP ?? process.env.METAMASK_RECIPE_ACTION_SOURCE_MAP,
-    action
-  );
-  const roots = [...new Set((declaredRoot ? [declaredRoot] : [
-    runtimeEnv.METAMASK_RECIPE_LIVE_ADAPTER_DIR ?? process.env.METAMASK_RECIPE_LIVE_ADAPTER_DIR,
-    path.join(runnerDir, "library/actions")
-  ]).filter((entry) => Boolean(entry)))];
-  const files = [];
-  for (const root of roots) {
-    for (const family of families) {
-      for (const candidateStem of stems) {
-        pushCandidateFiles(files, root, platform, family, candidateStem);
-      }
-      pushDomainDispatcherFiles(files, root, platform, family);
-    }
-  }
-  return files;
-}
-function declaredActionRoot(raw, action) {
-  if (!raw) return void 0;
-  try {
-    const parsed = JSON.parse(raw);
-    const root = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed[action] : void 0;
-    return typeof root === "string" && root.length > 0 ? root : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function pushCandidateFiles(files, root, platform, family, stem) {
-  files.push(path.join(root, platform, family, `${stem}.mjs`));
-  files.push(path.join(root, "shared", family, `${stem}.mjs`));
-}
-function pushDomainDispatcherFiles(files, root, platform, family) {
-  files.push(path.join(root, platform, family, `${family}.mjs`));
-  files.push(path.join(root, "shared", family, `${family}.mjs`));
-}
-async function firstExecutablePath(paths) {
-  for (const file of paths) {
-    try {
-      await access(file);
-      return file;
-    } catch (error) {
-      if (error.code !== "ENOENT") throw error;
-    }
-  }
-  return null;
-}
-function runProcess(command, args, options) {
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    const child = spawn(command, args, {
-      cwd: options.cwd,
-      env: options.env,
-      stdio: [options.stdin == null ? "ignore" : "pipe", "pipe", "pipe"]
-    });
-    if (child.pid) trackCheckoutChild(options.cwd, child.pid);
-    if (options.stdin != null) {
-      child.stdin.on("error", (error) => {
-        if (error.code === "EPIPE" || settled) return;
-        settled = true;
-        reject(error);
-      });
-      child.stdin.end(options.stdin);
-    }
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk;
-      recordCommandOutput(chunk);
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk;
-      recordCommandOutput(chunk);
-    });
-    const timeout = options.timeoutMs ? setTimeout(() => {
-      if (settled) return;
-      settled = true;
-      child.kill("SIGTERM");
-      const killTimer = setTimeout(() => child.kill("SIGKILL"), 1e3);
-      child.once("close", () => clearTimeout(killTimer));
-      resolve({ exitCode: null, stdout, stderr, timedOut: true });
-    }, options.timeoutMs) : void 0;
-    child.on("error", (error) => {
-      if (settled) return;
-      settled = true;
-      if (timeout) clearTimeout(timeout);
-      reject(error);
-    });
-    child.on("close", (exitCode) => {
-      if (settled) return;
-      settled = true;
-      if (timeout) clearTimeout(timeout);
-      resolve({ exitCode, stdout, stderr, timedOut: false });
-    });
-  });
-}
-async function prepareLiveAdapterScript({
-  platform,
-  action,
-  implementationRoot,
-  allowRuntimeImports = false
-}) {
-  const entryPath = await firstExecutablePath(
-    candidatePaths(platform, action, {
-      METAMASK_RECIPE_ACTION_SOURCE_MAP: JSON.stringify({ [action]: implementationRoot })
-    })
-  );
-  if (!entryPath) return null;
-  const rootReal = await realpath(implementationRoot);
-  const entryReal = await realpath(entryPath);
-  if (!isPathWithin(rootReal, entryReal)) {
-    throw new Error(`Live adapter ${entryPath} resolves outside ${implementationRoot}.`);
-  }
-  const result = await build({
-    entryPoints: [entryReal],
-    bundle: true,
-    write: false,
-    platform: "node",
-    format: "esm",
-    target: `node${process.versions.node.split(".")[0]}`,
-    legalComments: "none",
-    sourcemap: false,
-    banner: {
-      js: `import { createRequire as __mmCreateRequire } from 'node:module';const require = __mmCreateRequire(import.meta.url);process.argv[1] = ${JSON.stringify(entryReal)};`
-    },
-    plugins: [bindImportMetaUrls()],
-    logLevel: "silent"
-  });
-  const output = result.outputFiles[0];
-  if (!output) throw new Error(`Bundling live adapter ${entryReal} produced no executable output.`);
-  const sourceText = output.text;
-  await init;
-  const [imports] = parse(sourceText);
-  if (!allowRuntimeImports && imports.some((entry) => entry.d >= 0)) {
-    const error = new Error(
-      `Live adapter ${entryReal} contains a runtime dynamic import that cannot be bound to the approved bundle. Replace it with a static import so its implementation bytes are included in the plan digest.`
-    );
-    Object.assign(error, {
-      code: "RECIPE_TRUST_UNBOUND_IMPORT",
-      userAction: "replace the computed import with a static import, or promote the adapter into an explicitly trusted engineer-owned library"
-    });
-    throw error;
-  }
-  return {
-    action,
-    platform,
-    entryPath: entryReal,
-    sourceText,
-    sourceDigest: `sha256:${createHash("sha256").update(sourceText).digest("hex")}`
-  };
-}
-function bindImportMetaUrls() {
-  return {
-    name: "bind-import-meta-urls",
-    setup(buildContext) {
-      buildContext.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, async (args) => {
-        const contents = await readFile(args.path, "utf8");
-        if (!contents.includes("import.meta.url")) return void 0;
-        const extension = path.extname(args.path);
-        const loader = extension === ".ts" || extension === ".mts" || extension === ".cts" ? "ts" : extension === ".tsx" ? "tsx" : extension === ".jsx" ? "jsx" : "js";
-        return {
-          contents: contents.replaceAll(
-            "import.meta.url",
-            JSON.stringify(pathToFileURL(args.path).href)
-          ),
-          loader
-        };
-      });
-    }
-  };
-}
-function tsxLiveScripts(platform) {
-  return platform && adapterRegistry.has(platform) ? getAdapterSurface(platform).actions.tsxLiveScripts : void 0;
-}
-function commandFor(file, projectRoot, platform) {
-  const needsTsx = Boolean(tsxLiveScripts(platform)) || importsSourceTypescript(file);
-  if (!needsTsx) {
-    return { command: process.execPath, args: [file] };
-  }
-  const tsxBin = resolveTsxBin(projectRoot);
-  if (!tsxBin) {
-    const where = projectRoot ?? "the checkout";
-    const error = new Error(
-      `this action runs TypeScript from the checkout but no tsx runtime was found.
-  Next: run 'yarn install' in ${where} (tsx is a dev dependency of the checkout); if package imports still fail, run 'yarn build' there`
-    );
-    error.exitCode = 2;
-    throw error;
-  }
-  return { command: tsxBin, args: [file] };
-}
-function resolveTsxBin(projectRoot) {
-  if (process.env.TSX_BIN) return process.env.TSX_BIN;
-  const candidates = [];
-  if (projectRoot) candidates.push(path.join(projectRoot, "node_modules/.bin/tsx"));
-  candidates.push(path.join(runnerDir, "node_modules/.bin/tsx"));
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) return candidate;
-  }
-  try {
-    const protocolTsx = path.join(resolveRequiredLocalProtocolRoot("TypeScript live adapter execution"), "node_modules/.bin/tsx");
-    if (existsSync(protocolTsx)) return protocolTsx;
-  } catch {
-  }
-  return null;
-}
-function importsSourceTypescript(file) {
-  return importsSourceTypescriptFrom(file, /* @__PURE__ */ new Set());
-}
-function importsSourceTypescriptFrom(file, visited) {
-  const absolute = path.resolve(file);
-  if (visited.has(absolute)) return false;
-  visited.add(absolute);
-  const source = readFileSync(file, "utf8");
-  const importPattern = /(?:from\s+|import\(\s*)['"]([^'"]+)['"]/gu;
-  for (const match of source.matchAll(importPattern)) {
-    const specifier = match[1] ?? "";
-    if (specifier.endsWith(".ts")) return true;
-    if (!specifier.startsWith(".")) continue;
-    if (!specifier.endsWith(".mjs")) continue;
-    if (importsSourceTypescriptFrom(path.resolve(path.dirname(absolute), specifier), visited)) {
-      return true;
-    }
-  }
-  return false;
-}
-async function resolveLiveAdapter(platform, action, runtimeEnv) {
-  return firstExecutablePath(candidatePaths(platform, action, runtimeEnv));
-}
-async function runLiveAdapterScript({ platform, action, node, context, prepared }) {
-  const script = prepared?.entryPath ?? await resolveLiveAdapter(platform, action, context?.env);
-  if (!script) return null;
-  const tempDir = await mkdtemp(path.join(os.tmpdir(), "mm-harness-live-adapter-"));
-  const inputPath = path.join(tempDir, "input.json");
-  const outputPath = path.join(tempDir, "output.json");
-  const input = {
-    schemaVersion: 1,
-    platform,
-    action,
-    node,
-    context: {
-      nodeId: context.nodeId,
-      projectRoot: context.projectRoot,
-      artifactsDir: context.artifactsDir,
-      ...context.trustedMutation ? { trustedMutation: serializeTrustedMutationContext(context.trustedMutation) } : {}
-    },
-    outputPath
-  };
-  await writeFile(inputPath, `${JSON.stringify(input, null, 2)}
-`);
-  const command = prepared ? commandForPrepared(context.projectRoot, platform) : commandFor(script, context.projectRoot, platform);
-  const platformEnv = await tsxLiveScripts(platform)?.env(context.projectRoot, tempDir) ?? {};
-  const processTimeoutMs = liveAdapterProcessTimeoutMs(node);
-  const result = await runProcess(command.command, [...command.args, inputPath], {
-    cwd: context.projectRoot,
-    env: {
-      ...process.env,
-      ...context.env,
-      ...platformEnv,
-      METAMASK_RECIPE_ADAPTER_INPUT: inputPath,
-      METAMASK_RECIPE_ADAPTER_OUTPUT: outputPath
-    },
-    timeoutMs: processTimeoutMs,
-    ...prepared ? { stdin: prepared.sourceText } : {}
-  });
-  try {
-    if (result.timedOut) {
-      throw new Error(`Live adapter ${script} timed out after ${processTimeoutMs}ms.`);
-    }
-    if (result.exitCode !== 0) {
-      const failureOutput = await readFile(outputPath, "utf8").then(JSON.parse).catch(() => null);
-      if (Array.isArray(failureOutput?.artifacts)) {
-        for (const artifact of failureOutput.artifacts) context.registerArtifact(artifact);
-      }
-      throw new Error(`Live adapter ${script} exited ${result.exitCode}: ${result.stderr || result.stdout}`);
-    }
-    let parsed = null;
-    try {
-      parsed = JSON.parse(await readFile(outputPath, "utf8"));
-    } catch (_error) {
-      const stdout = result.stdout.trim();
-      if (!stdout) throw new Error(`Live adapter ${script} did not write JSON output.`);
-      parsed = JSON.parse(stdout);
-    }
-    return { script, result: parsed };
-  } finally {
-    await rm(tempDir, { recursive: true, force: true });
-  }
-}
-function liveAdapterProcessTimeoutMs(node) {
-  if (node.live_adapter_timeout_ms != null) {
-    const timeoutMs = Number(node.live_adapter_timeout_ms);
-    return Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 6e4;
-  }
-  const settleMs = Number(node.settle_ms);
-  const settleAllowance = Number.isFinite(settleMs) && settleMs > 0 ? settleMs : 0;
-  const actionTimeouts = [
-    node.target_timeout_ms,
-    node.unlock_timeout_ms,
-    node.timeout_ms,
-    node.wait_timeout_ms
-  ].map(Number).filter((value) => Number.isFinite(value) && value > 0);
-  if (actionTimeouts.length > 0) {
-    return Math.max(
-      6e4,
-      actionTimeouts.reduce((total, value) => total + value, 0) + settleAllowance + 5e3
-    );
-  }
-  return 6e4 + settleAllowance;
-}
-function commandForPrepared(projectRoot, platform) {
-  if (!tsxLiveScripts(platform)) {
-    return { command: process.execPath, args: ["--input-type=module", "-"] };
-  }
-  const tsxBin = resolveTsxBin(projectRoot);
-  if (!tsxBin) {
-    const error = new Error(
-      `this action imports TypeScript from the checkout but no tsx runtime was found.
-  Next: run 'yarn install' in ${projectRoot}`
-    );
-    error.exitCode = 2;
-    throw error;
-  }
-  return { command: tsxBin, args: ["--input-type=module", "-"] };
-}
-function isPathWithin(root, candidate) {
-  const relative = path.relative(root, candidate);
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
-}
-export {
-  liveAdapterProcessTimeoutMs,
-  prepareLiveAdapterScript,
-  resolveLiveAdapter,
-  runLiveAdapterScript
-};

package/dist/recording-target.js

@@ -1,120 +0,0 @@
-import { spawnSync } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-const ANDROID_RECORDING_TARGET_PREFIX = "android-device:";
-const IOS_SIMULATOR_RECORDING_TARGET_PREFIX = "ios-simulator:";
-function createMetaMaskRecordingTargetProvider(adapter) {
-  return {
-    async resolveRecordingTarget(context) {
-      const { getAdapterSurface } = await import("./adapters/surface.js");
-      const recording = getAdapterSurface(adapter).recording;
-      if (!recording) throw new Error(`--record-video is not implemented for the ${adapter} adapter.`);
-      return recording.target(context);
-    }
-  };
-}
-function resolveAndroidDeviceSerial(env = process.env) {
-  return env.ADB_SERIAL?.trim() || process.env.ADB_SERIAL?.trim() || void 0;
-}
-function captureHelperSupportsRecordSessionSnapshots(projectRoot) {
-  return captureHelperSupportsCapability(projectRoot, "record_session_snapshot");
-}
-function captureHelperSupportsCapability(projectRoot, capability) {
-  const result = spawnSync(captureHelperPath(), ["version", "--json"], {
-    cwd: projectRoot,
-    encoding: "utf8"
-  });
-  if (result.status !== 0) return false;
-  try {
-    const parsed = JSON.parse(result.stdout);
-    return Array.isArray(parsed.capabilities) && parsed.capabilities.includes(capability);
-  } catch {
-    return false;
-  }
-}
-function resolveMobileIosSimulatorName(env = process.env) {
-  const explicit = env.IOS_SIMULATOR?.trim() || env.SIM_UDID?.trim();
-  if (explicit) return explicit;
-  const slot = env.FARMSLOT_SLOT_ID?.trim() || env.SLOT_ID?.trim();
-  if (!slot) return void 0;
-  const suffix = slot.includes("-") ? slot.slice(slot.lastIndexOf("-") + 1) : slot;
-  return suffix || void 0;
-}
-function resolveMobileIosSimulatorPid(simulator) {
-  const result = spawnSync(
-    captureHelperPath(),
-    ["resolve", "--app-name", "Simulator", "--window-name", simulator, "--json"],
-    { encoding: "utf8" }
-  );
-  if (result.status !== 0) return null;
-  try {
-    const parsed = JSON.parse(result.stdout);
-    return parsePositivePid(parsed.selected?.pid);
-  } catch {
-    return null;
-  }
-}
-function resolveExtensionBrowserPid(projectRoot, artifactsDir, cdpPort) {
-  const explicit = parsePositivePid(process.env.METAMASK_RECIPE_EXTENSION_BROWSER_PID);
-  if (explicit) return explicit;
-  if (cdpPort) {
-    const lsof = spawnSync("lsof", ["-nP", `-iTCP:${cdpPort}`, "-sTCP:LISTEN", "-t"], {
-      cwd: projectRoot,
-      encoding: "utf8"
-    });
-    if (lsof.status === 0) {
-      const pid = parsePositivePid(String(lsof.stdout).split(/\s+/u).find(Boolean));
-      if (pid) return pid;
-    }
-  }
-  for (const file of [
-    path.join(artifactsDir, "extension-runtime/runtime.json"),
-    path.join(projectRoot, "temp/recipe/runtime/runtime.json")
-  ]) {
-    const pid = parsePositivePid(readJsonFile(file)?.pid);
-    if (pid) return pid;
-  }
-  for (const file of [
-    path.join(projectRoot, "temp/recipe/runtime/chromium.pid"),
-    path.join(projectRoot, "temp/recipe/runtime/browser.pid")
-  ]) {
-    const pid = parsePositivePid(readTextFile(file));
-    if (pid) return pid;
-  }
-  return null;
-}
-function captureHelperPath() {
-  return process.env.CAPTURE_HELPER_PATH || "capture-helper";
-}
-function parsePositivePid(value) {
-  const pid = Number(String(value ?? "").trim());
-  return Number.isInteger(pid) && pid > 0 ? pid : null;
-}
-function readJsonFile(file) {
-  if (!fs.existsSync(file)) return null;
-  try {
-    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function readTextFile(file) {
-  if (!fs.existsSync(file)) return "";
-  try {
-    return fs.readFileSync(file, "utf8");
-  } catch {
-    return "";
-  }
-}
-export {
-  ANDROID_RECORDING_TARGET_PREFIX,
-  IOS_SIMULATOR_RECORDING_TARGET_PREFIX,
-  captureHelperSupportsCapability,
-  captureHelperSupportsRecordSessionSnapshots,
-  createMetaMaskRecordingTargetProvider,
-  resolveAndroidDeviceSerial,
-  resolveExtensionBrowserPid,
-  resolveMobileIosSimulatorName,
-  resolveMobileIosSimulatorPid
-};