@deeeed/metamask-harness 0.36.0 → 0.37.0

package/dist/adapters/extension/runtime-decision.js

@@ -2,6 +2,7 @@ import { execFileSync } from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
+import { extensionTreeSha256 } from "./artifact-integrity.js";
 import {
   depsCheck,
   INSTALL_MARKERS
@@ -151,21 +152,106 @@ function latestDistMtime(target) {
   walk2(distDir);
   return latest;
 }
-function runtimeDistCheck(target) {
-  const dist = path.join(target, "dist/chrome");
+function releaseArtifactState(target) {
+  const runtimeRoot = path.join(target, recipeRuntimeDir());
+  const statePath = path.join(runtimeRoot, "extension-release-artifact.json");
+  if (!fs.existsSync(statePath)) return { status: "none" };
+  try {
+    const stateStat = fs.lstatSync(statePath);
+    if (!stateStat.isFile() || stateStat.isSymbolicLink() || stateStat.size <= 0 || stateStat.size > 64 * 1024) {
+      return { status: "invalid", reason: "artifact runtime identity is not a regular bounded file" };
+    }
+    const state = JSON.parse(fs.readFileSync(statePath, "utf8"));
+    const sourceDir = typeof state.sourceDir === "string" ? path.resolve(state.sourceDir) : "";
+    const runtimeDist = typeof state.runtimeDist === "string" ? path.resolve(state.runtimeDist) : "";
+    const provenancePath = typeof state.provenancePath === "string" ? path.resolve(state.provenancePath) : "";
+    const expectedRuntimeDist = path.join(
+      runtimeRoot,
+      process.env.RECIPE_RUNTIME_DIST_DIR || "runtime-dist"
+    );
+    if (state.schemaVersion !== 1 || !sourceDir || runtimeDist !== expectedRuntimeDist || !provenancePath) {
+      return { status: "invalid", reason: "artifact runtime identity has invalid paths or schema" };
+    }
+    const provenanceStat = fs.lstatSync(provenancePath);
+    if (!provenanceStat.isFile() || provenanceStat.isSymbolicLink() || provenanceStat.size <= 0 || provenanceStat.size > 64 * 1024) {
+      return { status: "invalid", reason: "artifact provenance is not a regular bounded file" };
+    }
+    const provenance = JSON.parse(fs.readFileSync(provenancePath, "utf8"));
+    const relativeExtensionDir = typeof provenance.extensionDir === "string" ? provenance.extensionDir : "";
+    const boundSource = relativeExtensionDir && !path.isAbsolute(relativeExtensionDir) && !relativeExtensionDir.split(/[\\/]+/u).includes("..") ? path.resolve(path.dirname(provenancePath), relativeExtensionDir) : "";
+    const sha256 = typeof provenance.sha256 === "string" ? provenance.sha256 : "";
+    const expectedVersion = typeof provenance.expectedVersion === "string" ? provenance.expectedVersion : "";
+    const manifestVersion = typeof provenance.manifestVersion === "string" ? provenance.manifestVersion : "";
+    const treeSha256 = typeof provenance.treeSha256 === "string" ? provenance.treeSha256 : "";
+    if (provenance.schemaVersion !== 1 || boundSource !== sourceDir || !/^[a-f0-9]{64}$/u.test(sha256) || !/^[a-f0-9]{64}$/u.test(treeSha256) || !/^\d+\.\d+\.\d+$/u.test(expectedVersion) || state.sha256 !== sha256 || state.treeSha256 !== treeSha256 || state.expectedVersion !== expectedVersion || state.manifestVersion !== manifestVersion) {
+      return { status: "invalid", reason: "artifact runtime identity does not match its provenance" };
+    }
+    const manifest = JSON.parse(fs.readFileSync(path.join(runtimeDist, "manifest.json"), "utf8"));
+    const runtimeVersion = typeof manifest.version === "string" ? manifest.version : "";
+    if (normalizeReleaseVersion(runtimeVersion) !== expectedVersion || runtimeVersion !== manifestVersion) {
+      return { status: "invalid", reason: "artifact runtime manifest does not match its provenance" };
+    }
+    if (extensionTreeSha256(sourceDir) !== treeSha256 || extensionTreeSha256(runtimeDist) !== treeSha256) {
+      return { status: "invalid", reason: "artifact source or runtime tree does not match its provenance" };
+    }
+    return {
+      status: "valid",
+      sourceDir,
+      runtimeDist,
+      provenancePath,
+      sha256,
+      treeSha256,
+      expectedVersion,
+      manifestVersion
+    };
+  } catch (error) {
+    return {
+      status: "invalid",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function normalizeReleaseVersion(version) {
+  if (!/^\d+\.\d+\.\d+(?:\.\d+)?$/u.test(version)) return null;
+  const parts = version.split(".");
+  if (parts.length === 4 && parts[3] !== "0") return null;
+  return parts.slice(0, 3).join(".");
+}
+function releaseArtifactDistCheck(artifact) {
+  return {
+    status: "fresh",
+    source: "release-artifact",
+    manifestPath: path.join(artifact.runtimeDist, "manifest.json"),
+    manifestVersion: artifact.manifestVersion,
+    artifactSha256: artifact.sha256
+  };
+}
+function runtimeDistCheck(target, artifact = releaseArtifactState(target)) {
+  if (artifact.status === "invalid") {
+    return {
+      status: "stale",
+      source: "release-artifact",
+      artifactError: artifact.reason,
+      modified: ["<artifact identity invalid>"]
+    };
+  }
+  const dist = artifact.status === "valid" ? artifact.sourceDir : path.join(target, "dist/chrome");
   const runtimeDist = path.join(
     target,
     recipeRuntimeDir(),
     process.env.RECIPE_RUNTIME_DIST_DIR || "runtime-dist"
   );
-  if (!fs.existsSync(path.join(runtimeDist, "manifest.json"))) return { status: "missing" };
+  const identity = artifact.status === "valid" ? {
+    source: "release-artifact",
+    artifactSha256: artifact.sha256,
+    provenancePath: artifact.provenancePath
+  } : {};
+  if (!fs.existsSync(path.join(runtimeDist, "manifest.json"))) return { status: "missing", ...identity };
   let output;
   try {
-    output = execFileSync("rsync", [
+    const rsyncArgs = [
       "-rnic",
       "--exclude",
-      "_metadata",
-      "--exclude",
       "home.html",
       "--exclude",
       "sidepanel.html",
@@ -174,21 +260,34 @@ function runtimeDistCheck(target) {
       "--out-format=%n",
       `${dist}${path.sep}`,
       `${runtimeDist}${path.sep}`
-    ], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    ];
+    if (artifact.status !== "valid") rsyncArgs.splice(1, 0, "--exclude", "_metadata");
+    output = execFileSync("rsync", rsyncArgs, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
   } catch {
-    return { status: "stale", modified: ["<snapshot comparison failed>"] };
+    return { status: "stale", modified: ["<snapshot comparison failed>"], ...identity };
   }
   const modified = output.split("\n").map((line) => line.trim()).filter(Boolean);
-  for (const name of ["home.html", "sidepanel.html"]) {
-    const source = path.join(dist, name);
-    const loaded = path.join(runtimeDist, name);
-    if (normalizedRuntimeHtml(source) !== normalizedRuntimeHtml(loaded)) modified.push(name);
-  }
-  if (normalizedRuntimeManifest(path.join(dist, "manifest.json")) !== normalizedRuntimeManifest(path.join(runtimeDist, "manifest.json"))) {
-    modified.push("manifest.json");
+  if (artifact.status === "valid") {
+    for (const name of ["home.html", "sidepanel.html", "manifest.json"]) {
+      const source = path.join(dist, name);
+      const loaded = path.join(runtimeDist, name);
+      if (fileDigest(source) !== fileDigest(loaded)) modified.push(name);
+    }
+  } else {
+    for (const name of ["home.html", "sidepanel.html"]) {
+      const source = path.join(dist, name);
+      const loaded = path.join(runtimeDist, name);
+      if (normalizedRuntimeHtml(source) !== normalizedRuntimeHtml(loaded)) modified.push(name);
+    }
+    if (normalizedRuntimeManifest(path.join(dist, "manifest.json")) !== normalizedRuntimeManifest(path.join(runtimeDist, "manifest.json"))) {
+      modified.push("manifest.json");
+    }
   }
   const boundedModified = [...new Set(modified)].slice(0, 10);
-  return boundedModified.length > 0 ? { status: "stale", modified: boundedModified } : { status: "fresh" };
+  return boundedModified.length > 0 ? { status: "stale", modified: boundedModified, ...identity } : { status: "fresh", ...identity };
+}
+function fileDigest(file) {
+  return fs.existsSync(file) ? crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex") : null;
 }
 function normalizedRuntimeHtml(file) {
   if (!fs.existsSync(file)) return null;
@@ -269,10 +368,11 @@ async function decideExtensionReadiness(target, options = {}) {
   const deps = depsCheck(resolved);
   const webpackCache = webpackCacheCheck(resolved);
   const buildLog = buildLogCheck(resolved, options.watchLog);
-  const dist = distCheck(resolved);
-  const runtimeDist = runtimeDistCheck(resolved);
+  const releaseArtifact = releaseArtifactState(resolved);
+  const dist = releaseArtifact.status === "valid" ? releaseArtifactDistCheck(releaseArtifact) : distCheck(resolved);
+  const runtimeDist = runtimeDistCheck(resolved, releaseArtifact);
   const cdp = await cdpCheck(resolved, options.cdpPort, options.pageMode);
-  const checks = { deps, webpackCache, buildLog, dist, runtimeDist, cdp };
+  const checks = { deps, webpackCache, buildLog, dist, runtimeDist, releaseArtifact, cdp };
   const install = [{ id: "yarn-install", argv: ["yarn", "install", "--immutable"], cwd: resolved }];
   const relaunch = [{ id: "relaunch-browser" }];
   const cacheStale = buildLog.reason === "stale-cache";
@@ -355,7 +455,47 @@ async function decideExtensionReadiness(target, options = {}) {
     reasons: ["Build is fresh; browser liveness unverified (pass --cdp-port to confirm `ready`)."],
     actions: relaunch
   };
-  const core = rules.find((rule) => rule.when) ?? fallback;
+  let core;
+  if (releaseArtifact.status === "invalid") {
+    core = {
+      decision: "blocked",
+      reasonCode: "release-artifact-identity-invalid",
+      reasons: [`The loaded release artifact identity is invalid: ${releaseArtifact.reason ?? "unknown reason"}.`],
+      actions: []
+    };
+  } else if (releaseArtifact.status === "valid") {
+    const artifactRules = [
+      {
+        when: runtimeDist.status !== "fresh",
+        decision: "relaunch",
+        reasonCode: runtimeDist.status === "missing" ? "release-artifact-runtime-missing" : "release-artifact-runtime-stale",
+        reasons: [runtimeDist.status === "missing" ? "The loaded release artifact snapshot is missing." : `The loaded runtime snapshot differs from release artifact ${releaseArtifact.sha256?.slice(0, 12)}.`],
+        actions: relaunch
+      },
+      {
+        when: cdp.status === "pass",
+        decision: "ready",
+        reasonCode: "release-artifact-healthy",
+        reasons: [`Release artifact ${releaseArtifact.expectedVersion} is intact and healthy over CDP.`],
+        actions: []
+      },
+      {
+        when: cdp.status === "fail",
+        decision: "relaunch",
+        reasonCode: "runtime-unhealthy",
+        reasons: ["The release artifact is intact but the live extension is unhealthy.", ...cdp.findings?.slice(0, 3) ?? []],
+        actions: relaunch
+      }
+    ];
+    core = artifactRules.find((rule) => rule.when) ?? {
+      decision: "relaunch",
+      reasonCode: "cdp-unknown",
+      reasons: [`Release artifact ${releaseArtifact.expectedVersion} is intact; browser liveness is unverified.`],
+      actions: relaunch
+    };
+  } else {
+    core = rules.find((rule) => rule.when) ?? fallback;
+  }
   return {
     schemaVersion: 1,
     adapter: "extension",
@@ -378,5 +518,6 @@ export {
   decideExtensionReadiness,
   isExtensionDistStale,
   recordWebpackBaseline,
+  releaseArtifactState,
   runtimeDistCheck
 };

package/dist/adapters/extension/runtime.js

@@ -147,6 +147,12 @@ async function checkExtensionRuntimeHealth(projectRoot, cdpPort, options = {}) {
       };
     }
     const runtime = await evaluateHealth(session, cdpCallTimeoutMs);
+    if (runtime.hasSubmitRequest !== true) {
+      const providerProbe = await probeUiEthereumProvider(session, cdpCallTimeoutMs);
+      runtime.evmRpcProbeOk = providerProbe.ok;
+      runtime.evmRpcProbeError = providerProbe.error;
+      runtime.evmRpcProbeSource = providerProbe.source;
+    }
     if (runtime.href && !String(runtime.href).startsWith("chrome-extension://")) {
       findings.push(`Extension page href is not an extension URL: ${runtime.href}`);
     }
@@ -316,6 +322,127 @@ async function evaluateHealth(session, timeoutMs) {
   }
   return result.result?.value ?? {};
 }
+async function probeUiEthereumProvider(session, timeoutMs) {
+  const bridgeKey = "mm-harness.runtime.evm-provider-probe";
+  const preload = await boundedCdpCall(
+    session,
+    "Page.addScriptToEvaluateOnNewDocument",
+    {
+      source: `(() => {
+        const bridgeKey = Symbol.for(${JSON.stringify(bridgeKey)});
+        let provider;
+        Object.defineProperty(globalThis, 'ethereumProvider', {
+          configurable: true,
+          get() { return provider; },
+          set(value) { provider = value; },
+        });
+        Object.defineProperty(globalThis, bridgeKey, {
+          configurable: true,
+          value: {
+            async probe() {
+              if (!provider || typeof provider.request !== 'function') {
+                return { ok: false, error: 'Ethereum provider is unavailable' };
+              }
+              try {
+                const code = await provider.request({
+                  method: 'eth_getCode',
+                  params: ['0x0000000000000000000000000000000000000000', 'latest'],
+                });
+                const ok = typeof code === 'string' && /^0x[0-9a-f]*$/iu.test(code);
+                return {
+                  ok,
+                  error: ok ? null : 'Ethereum provider returned invalid contract code',
+                };
+              } catch (error) {
+                return { ok: false, error: String(error?.message || error) };
+              }
+            },
+            cleanup() {
+              const descriptor = Object.getOwnPropertyDescriptor(globalThis, 'ethereumProvider');
+              if (descriptor?.configurable === true) {
+                Object.defineProperty(globalThis, 'ethereumProvider', {
+                  configurable: true,
+                  writable: true,
+                  value: provider,
+                });
+              }
+              return delete globalThis[bridgeKey];
+            },
+          },
+        });
+      })();`
+    },
+    timeoutMs
+  );
+  if (typeof preload?.identifier !== "string" || preload.identifier.length === 0) {
+    return {
+      ok: false,
+      error: "Ethereum provider preload was not installed",
+      source: "ui-ethereum-provider"
+    };
+  }
+  let outcome = {
+    ok: false,
+    error: "Ethereum provider is unavailable",
+    source: "ui-ethereum-provider"
+  };
+  const cleanupErrors = [];
+  try {
+    await boundedCdpCall(session, "Page.reload", { ignoreCache: false }, timeoutMs);
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+      try {
+        const result = await boundedCdpCall(session, "Runtime.evaluate", {
+          expression: `globalThis[Symbol.for(${JSON.stringify(bridgeKey)})]?.probe()`,
+          awaitPromise: true,
+          returnByValue: true
+        }, Math.max(1, deadline - Date.now()));
+        const value = result.result?.value;
+        if (value?.ok === true) {
+          outcome = { ok: true, error: null, source: "ui-ethereum-provider" };
+          break;
+        }
+        if (typeof value?.error === "string") outcome.error = value.error;
+      } catch (error) {
+        outcome.error = messageOf(error);
+      }
+      if (outcome.ok) break;
+      await sleep(100);
+    }
+  } catch (error) {
+    outcome = { ok: false, error: messageOf(error), source: "ui-ethereum-provider" };
+  } finally {
+    try {
+      const cleanup = await boundedCdpCall(session, "Runtime.evaluate", {
+        expression: `(() => {
+          const key = Symbol.for(${JSON.stringify(bridgeKey)});
+          const bridge = globalThis[key];
+          if (!bridge) return true;
+          return bridge.cleanup() === true && !(key in globalThis);
+        })()`,
+        returnByValue: true
+      }, timeoutMs);
+      if (cleanup.result?.value !== true) cleanupErrors.push("page bridge removal was not confirmed");
+    } catch (error) {
+      cleanupErrors.push(messageOf(error));
+    }
+    try {
+      await boundedCdpCall(
+        session,
+        "Page.removeScriptToEvaluateOnNewDocument",
+        { identifier: preload.identifier },
+        timeoutMs
+      );
+    } catch (error) {
+      cleanupErrors.push(messageOf(error));
+    }
+  }
+  return cleanupErrors.length > 0 ? {
+    ok: false,
+    error: `Ethereum provider probe cleanup failed: ${cleanupErrors.join("; ")}`,
+    source: "ui-ethereum-provider"
+  } : outcome;
+}
 function extensionBackgroundProbeTimeoutMs(cdpCallTimeoutMs) {
   return Math.max(1, Math.floor(cdpCallTimeoutMs * 0.8));
 }

package/dist/adapters/mobile/release-artifact-state.js

@@ -0,0 +1,124 @@
+import { randomBytes } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { recipeRuntimePath } from "../../paths.js";
+import {
+  assertAndroidReleaseArtifactRuntime
+} from "./release-artifact.js";
+function mobileReleaseArtifactStatePath(target) {
+  return recipeRuntimePath(target, "mobile-release-artifact.json");
+}
+function writeMobileReleaseArtifactState(target, report) {
+  const state = {
+    schemaVersion: 1,
+    adapter: "mobile",
+    platform: "android",
+    packageId: report.packageId,
+    versionName: report.versionName,
+    versionCode: report.versionCode,
+    sha256: report.sha256,
+    deviceSerial: report.deviceSerial,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const file = mobileReleaseArtifactStatePath(target);
+  const directory = ensureSafeRuntimeDirectory(target, file);
+  const existing = fs.lstatSync(file, { throwIfNoEntry: false });
+  if (existing && (!existing.isFile() || existing.isSymbolicLink())) throw invalidState(file);
+  const temporary = path.join(
+    directory,
+    `.mobile-release-artifact.${process.pid}.${randomBytes(8).toString("hex")}.tmp`
+  );
+  let descriptor;
+  try {
+    descriptor = fs.openSync(temporary, "wx", 384);
+    fs.writeFileSync(descriptor, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+    fs.fsyncSync(descriptor);
+    fs.closeSync(descriptor);
+    descriptor = void 0;
+    fs.renameSync(temporary, file);
+  } finally {
+    if (descriptor !== void 0) fs.closeSync(descriptor);
+    const temporaryStat = fs.lstatSync(temporary, { throwIfNoEntry: false });
+    if (temporaryStat) fs.unlinkSync(temporary);
+  }
+  return state;
+}
+function requireCurrentMobileReleaseArtifactState(target, verify = assertAndroidReleaseArtifactRuntime) {
+  const state = readMobileReleaseArtifactState(target);
+  if (state) verify(state);
+  return state;
+}
+function clearMobileReleaseArtifactState(target) {
+  const file = mobileReleaseArtifactStatePath(target);
+  const existing = fs.lstatSync(file, { throwIfNoEntry: false });
+  if (!existing) return;
+  ensureSafeRuntimeDirectory(target, file);
+  if (!existing.isFile() || existing.isSymbolicLink()) throw invalidState(file);
+  fs.unlinkSync(file);
+}
+function readMobileReleaseArtifactState(target) {
+  const file = mobileReleaseArtifactStatePath(target);
+  let stat;
+  try {
+    stat = fs.lstatSync(file);
+  } catch (error) {
+    if (isMissing(error)) return null;
+    throw invalidState(file);
+  }
+  try {
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size <= 0 || stat.size > 16 * 1024) {
+      throw invalidState(file);
+    }
+    const value = JSON.parse(fs.readFileSync(file, "utf8"));
+    if (value.schemaVersion !== 1 || value.adapter !== "mobile" || value.platform !== "android" || !text(value.packageId) || !text(value.versionName) || !text(value.versionCode) || !/^[a-f0-9]{64}$/u.test(value.sha256 ?? "") || !text(value.deviceSerial) || !text(value.installedAt)) throw invalidState(file);
+    return value;
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("The Mobile release artifact state is invalid")) {
+      throw error;
+    }
+    throw invalidState(file);
+  }
+}
+function text(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isMissing(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function invalidState(file) {
+  return new Error(`The Mobile release artifact state is invalid: ${file}. Next: rerun runtime-launch with the same artifact source.`);
+}
+function ensureSafeRuntimeDirectory(target, file) {
+  const root = path.resolve(target);
+  const directory = path.dirname(path.resolve(file));
+  const relative = path.relative(root, directory);
+  if (!relative || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    throw invalidState(file);
+  }
+  let current = root;
+  const rootStat = fs.lstatSync(root, { throwIfNoEntry: false });
+  if (!rootStat?.isDirectory() || rootStat.isSymbolicLink()) throw invalidState(file);
+  for (const segment of relative.split(path.sep)) {
+    current = path.join(current, segment);
+    const stat = fs.lstatSync(current, { throwIfNoEntry: false });
+    if (stat) {
+      if (!stat.isDirectory() || stat.isSymbolicLink()) throw invalidState(file);
+    } else {
+      fs.mkdirSync(current, { mode: 448 });
+    }
+  }
+  const realRoot = fs.realpathSync(root);
+  const realDirectory = fs.realpathSync(directory);
+  if (realDirectory !== realRoot && !realDirectory.startsWith(`${realRoot}${path.sep}`)) {
+    throw invalidState(file);
+  }
+  return directory;
+}
+export {
+  clearMobileReleaseArtifactState,
+  mobileReleaseArtifactStatePath,
+  readMobileReleaseArtifactState,
+  requireCurrentMobileReleaseArtifactState,
+  writeMobileReleaseArtifactState
+};