@deeeed/metamask-harness 0.79.0 → 0.81.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/metamask-action-validation.js

@@ -1,68 +0,0 @@
-import { adapterRegistry } from "./adapters/registry.js";
-import { getAdapterSurface } from "./adapters/surface.js";
-function isRecord(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function resolveMetaMaskParameterValue(value, params) {
-  if (typeof value === "string") {
-    const exact = /^\{\{params\.([A-Za-z0-9_.-]+)\}\}$/u.exec(value);
-    if (!exact) return value;
-    let current = params;
-    for (const segment of exact[1].split(".")) {
-      if (!isRecord(current) || !Object.hasOwn(current, segment)) return value;
-      current = current[segment];
-    }
-    return current;
-  }
-  if (Array.isArray(value)) return value.map((entry) => resolveMetaMaskParameterValue(entry, params));
-  if (!isRecord(value)) return value;
-  return Object.fromEntries(
-    Object.entries(value).map(([key, entry]) => [key, resolveMetaMaskParameterValue(entry, params)])
-  );
-}
-function validateMetaMaskActionInputs(recipe, adapter, params) {
-  if (!isRecord(recipe) || !isRecord(recipe.workflow)) return [];
-  const nodes = isRecord(recipe.workflow.nodes) ? recipe.workflow.nodes : void 0;
-  if (!nodes) return [];
-  const surface = adapter && adapterRegistry.has(adapter) ? getAdapterSurface(adapter) : void 0;
-  const findings = [];
-  for (const [nodeId, rawNode] of Object.entries(nodes)) {
-    const node = params ? resolveMetaMaskParameterValue(rawNode, params) : rawNode;
-    if (!isRecord(node)) continue;
-    const action = node.action;
-    findings.push(...surface?.actions.inputFindings?.(nodeId, node) ?? []);
-    const state = typeof node.state === "string" ? node.state.toLowerCase() : void 0;
-    const createsOrder = action === "metamask.perps.place_order" || !surface?.actions.ensureChecksOnly && (action === "metamask.perps.ensure_positions" || action === "metamask.perps.ensure_orders") && (state === "open" || state === "present");
-    if (!createsOrder) continue;
-    const requireOneOf = (names, message) => {
-      const present = names.some((name) => {
-        const value = node[name];
-        return value !== void 0 && value !== null && value !== "";
-      });
-      if (present) return;
-      findings.push({
-        severity: "error",
-        code: "recipe.missing_param",
-        path: `workflow.nodes.${nodeId}.${names[0]}`,
-        message
-      });
-    };
-    requireOneOf(
-      ["market", "symbol"],
-      `${action} requires market=<symbol> (or symbol=<symbol>) before it may create an order`
-    );
-    requireOneOf(
-      ["side"],
-      `${action} requires side=long or side=short before it may create an order`
-    );
-    requireOneOf(
-      ["amount", "notional"],
-      `${action} requires amount=<usd> or notional=<usd> before it may create an order`
-    );
-  }
-  return findings;
-}
-export {
-  resolveMetaMaskParameterValue,
-  validateMetaMaskActionInputs
-};