@deeeed/metamask-harness 0.80.0 → 0.81.0

package/dist/discovery.js

@@ -1,15 +0,0 @@
-import { assessRecipe } from "@farmslot/recipe-cli";
-import {
-  loadRecipeLibraries
-} from "@farmslot/recipe-runner";
-import { resolveActionManifest } from "./manifest.js";
-async function runnableLibraryRecipes(adapter, sources) {
-  const resolution = await loadRecipeLibraries(sources, { adapter });
-  const { manifest } = await resolveActionManifest(adapter, void 0, sources);
-  return [...resolution.recipes.values()].filter(
-    (recipe) => assessRecipe({ resolution, manifest }, recipe).length === 0
-  );
-}
-export {
-  runnableLibraryRecipes
-};

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
-};

package/dist/network-observation.js

@@ -1,290 +0,0 @@
-import path from "node:path";
-import brokerModule from "@farmslot/recipe-runner/cdp-broker";
-import configModule from "@farmslot/adapter-rn/bridge-runtime/lib/config.cjs";
-import {
-  createExtensionNetworkObserver
-} from "./adapters/extension/network-observer.js";
-import { getAdapterSurface } from "./adapters/surface.js";
-import {
-  indexArtifactManifest,
-  writeContainedArtifact
-} from "@farmslot/recipe-cli/harness";
-const AUTO_CAPTURE_ID = "run-network";
-const AUTO_ARTIFACT_PATH = "network/run-summary.json";
-const { brokerSocketPath, createBrokerClient } = brokerModule;
-const { resolvePort } = configModule;
-const sessions = /* @__PURE__ */ new Map();
-async function startRunNetworkObservation(adapter, target, artifactsDir, env, ports = {}) {
-  const network = getAdapterSurface(adapter).observation?.network;
-  if (!network) return void 0;
-  const runtimeEnv = {
-    ...env,
-    ...ports.cdpPort ? { CDP_PORT: ports.cdpPort, RECIPE_CDP_PORT: ports.cdpPort } : {},
-    ...ports.watcherPort ? { WATCHER_PORT: ports.watcherPort } : {}
-  };
-  const key = path.resolve(artifactsDir);
-  const session = {
-    artifactsDir: key,
-    autoStarted: false,
-    autoStartedAt: Date.now(),
-    nodeEvents: []
-  };
-  sessions.set(key, session);
-  try {
-    session.backend = await network.backend(target, runtimeEnv, key);
-  } catch (error) {
-    session.setupError = boundedError(error);
-  }
-  if (runtimeEnv.MM_HARNESS_AUTO_NETWORK_CAPTURE !== "0") {
-    session.autoStartedAt = Date.now();
-    if (session.backend) {
-      try {
-        await session.backend.start({
-          id: AUTO_CAPTURE_ID,
-          bodyJsonFields: ["type"],
-          maxDurationMs: 60 * 60 * 1e3,
-          maxRequests: 1e4,
-          methods: [],
-          urlIncludes: []
-        });
-        session.autoStarted = true;
-      } catch (error) {
-        session.setupError = boundedError(error);
-      }
-    }
-  }
-  return {
-    onActionEvent(event) {
-      session.nodeEvents.push({ ...event, epochMs: Date.now() });
-    },
-    async finalize(artifactManifestPath) {
-      try {
-        if (runtimeEnv.MM_HARNESS_AUTO_NETWORK_CAPTURE !== "0") {
-          const summary = await automaticSummary(session);
-          await writeSummary(key, AUTO_ARTIFACT_PATH, summary);
-          if (artifactManifestPath) {
-            await indexArtifact(
-              artifactManifestPath,
-              AUTO_ARTIFACT_PATH,
-              "Automatic network observation"
-            );
-          }
-        }
-      } finally {
-        sessions.delete(key);
-        await session.backend?.close();
-      }
-    }
-  };
-}
-async function handleRunNetworkAction(platform, action, node, context) {
-  if (!getAdapterSurface(platform).observation?.network?.actions) return null;
-  if (action === "app.network_assert") {
-    const assertion = await import("../library/actions/shared/app/network-assert.mjs");
-    return {
-      output: await assertion.assertNetwork({ action, node, context })
-    };
-  }
-  if (action !== "app.network_capture") return null;
-  const phase = String(node.phase ?? "").toLowerCase();
-  const id = String(node.id ?? "").trim();
-  if (!["start", "end"].includes(phase) || !id) {
-    throw new Error(
-      "app.network_capture requires phase=start|end and a non-empty id."
-    );
-  }
-  const session = sessions.get(path.resolve(context.artifactsDir));
-  if (!session?.backend) {
-    throw new Error(
-      `Extension network observation is unavailable: ${session?.setupError ?? "run observer was not started"}.`
-    );
-  }
-  if (phase === "start") {
-    const result = await session.backend.start(captureParams(id, node));
-    return {
-      output: {
-        action,
-        phase,
-        ...asRecord(result)
-      }
-    };
-  }
-  const artifactPath = String(
-    node.artifact_path ?? `network/${id}-summary.json`
-  );
-  const summary = await session.backend.end(id);
-  await writeSummary(context.artifactsDir, artifactPath, summary);
-  return {
-    output: {
-      action,
-      phase,
-      ...summary
-    },
-    artifacts: [
-      {
-        path: artifactPath,
-        type: "report",
-        nodeId: context.nodeId
-      }
-    ]
-  };
-}
-async function createMobileNetworkBackend(target, env) {
-  const { client } = await connectMobileBroker(target, env);
-  return {
-    start(params) {
-      return client.control("capture-start", params, 1e4);
-    },
-    async end(id) {
-      return asRecord(await client.control("capture-end", { id }, 1e4));
-    },
-    async close() {
-      client.close();
-    }
-  };
-}
-async function connectMobileBroker(target, env) {
-  const runtimeDir = env.RECIPE_RUNTIME_DIR ? path.resolve(target, env.RECIPE_RUNTIME_DIR) : path.join(target, "temp", "recipe", "runtime");
-  const socketPath = brokerSocketPath(
-    runtimeDir,
-    resolvePort(env, target)
-  );
-  const discoveryClient = await createBrokerClient(socketPath, "", 1e4);
-  let targets;
-  try {
-    targets = await discoveryClient.control(
-      "resolve-targets",
-      { nameIncludes: mobileTargetPin(env) },
-      1e4
-    );
-  } finally {
-    discoveryClient.close();
-  }
-  const deviceId = selectMobileBrokerTarget(targets, env);
-  const client = await createBrokerClient(socketPath, deviceId, 1e4);
-  return { client, deviceId };
-}
-function selectMobileBrokerTarget(value, env) {
-  const targets = Array.isArray(value) ? value.map(asRecord).filter((target) => target.deviceId) : [];
-  const pin = mobileTargetPin(env);
-  const candidates = pin ? targets.filter(
-    (target) => String(target.name ?? "").toLowerCase().includes(pin.toLowerCase())
-  ) : targets;
-  if (candidates.length !== 1) {
-    throw new Error(
-      `Mobile network observation requires one broker target; found ${candidates.length}.`
-    );
-  }
-  return String(candidates[0].deviceId);
-}
-function mobileTargetPin(env) {
-  const platform = String(
-    env.RECIPE_RN_EXPLICIT_PLATFORM ?? env.RECIPE_HARNESS_PLATFORM ?? ""
-  ).toLowerCase();
-  return String(
-    platform === "android" ? env.ANDROID_TARGET_DEVICE_NAME ?? env.ANDROID_DEVICE ?? "" : platform === "ios" ? env.IOS_SIMULATOR ?? "" : env.IOS_SIMULATOR ?? env.ANDROID_TARGET_DEVICE_NAME ?? env.ANDROID_DEVICE ?? ""
-  ).trim();
-}
-async function automaticSummary(session) {
-  let summary;
-  if (session.autoStarted && session.backend) {
-    try {
-      summary = await session.backend.end(AUTO_CAPTURE_ID);
-    } catch (error) {
-      summary = unavailableSummary(session.autoStartedAt, boundedError(error));
-    }
-  } else {
-    summary = unavailableSummary(
-      session.autoStartedAt,
-      session.setupError ?? "Network observer did not start."
-    );
-  }
-  const startedAt = Number(summary.startedAtEpochMs ?? session.autoStartedAt);
-  return {
-    ...summary,
-    nodeEvents: session.nodeEvents.map((event) => ({
-      action: event.action,
-      elapsedMs: Math.max(0, event.epochMs - startedAt),
-      nodeId: event.nodeId,
-      status: event.status
-    }))
-  };
-}
-function unavailableSummary(startedAtEpochMs, reason) {
-  return {
-    schemaVersion: 1,
-    id: AUTO_CAPTURE_ID,
-    status: "unavailable",
-    startedAtEpochMs,
-    endedAtEpochMs: Date.now(),
-    maxDurationMs: 60 * 60 * 1e3,
-    reconnects: 0,
-    droppedRequests: 0,
-    unavailableReasons: [reason],
-    coverageGapReasons: [],
-    uninspectableBodyRequests: 0,
-    projectedBodyFields: ["type"],
-    totalRequests: 0,
-    requestsByMethod: {},
-    requestsByHost: {},
-    requestsByType: {},
-    requests: []
-  };
-}
-function captureParams(id, node) {
-  return {
-    id,
-    urlIncludes: node.url_includes ?? [],
-    methods: node.methods ?? [],
-    bodyJsonFields: node.body_json_fields ?? [],
-    maxRequests: node.max_requests,
-    maxDurationMs: node.max_duration_ms
-  };
-}
-async function writeSummary(artifactsDir, relativePath, summary) {
-  await writeContainedArtifact(
-    artifactsDir,
-    relativePath,
-    `${JSON.stringify(summary, null, 2)}
-`,
-    "Network artifact"
-  );
-}
-async function indexArtifact(artifactManifestPath, relativePath, label) {
-  await indexArtifactManifest(
-    artifactManifestPath,
-    [
-      {
-        path: relativePath,
-        type: "report",
-        label,
-        category: "diagnostic"
-      }
-    ]
-  );
-}
-async function createExtensionNetworkBackend(env, artifactsDir) {
-  return createExtensionNetworkObserver(extensionCdpPort(env), artifactsDir);
-}
-function extensionCdpPort(env) {
-  const port = Number(
-    env.CDP_PORT ?? env.RECIPE_CDP_PORT ?? process.env.CDP_PORT
-  );
-  if (!Number.isInteger(port) || port <= 0) {
-    throw new Error("Extension network observation requires CDP_PORT.");
-  }
-  return port;
-}
-function boundedError(error) {
-  return String(error instanceof Error ? error.message : error).slice(0, 256);
-}
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-export {
-  connectMobileBroker,
-  createExtensionNetworkBackend,
-  createMobileNetworkBackend,
-  handleRunNetworkAction,
-  startRunNetworkObservation
-};