@deeeed/metamask-harness 0.22.0 → 0.23.1

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## Unreleased
 
+## 0.23.1 - 2026-07-29
+
+### Fixed
+
+- Mobile recipe evidence no longer triggers Metro Fast Refresh: harness-managed Metro ignores checkout-local `temp` artifacts, and screenshot scratch files stay outside the watched project.
+
+## 0.23.0 - 2026-07-28
+
+### Added
+
+- Core Perps actions support trigger orders, attached and partial TP/SL, and position TP/SL updates.
+
+### Fixed
+
+- Core advanced-order mutations verify the submitted order fields, use executable trigger-limit defaults, honor bounded evidence polling, and classify mutation capabilities correctly.
+- Core advanced-order camelCase aliases validate consistently with their documented snake_case forms.
+
 ## 0.22.0 - 2026-07-26
 
 ### Added

package/adapters/manifest.json

@@ -42,6 +42,14 @@
       "inputs": "--target --port --log --pid-file [--workers] [--clear]",
       "outputs": "Metro PID/launch metadata and redirected log; exit 0/1/2"
     },
+    {
+      "id": "mobile/metro-config",
+      "entry": "adapters/mobile/metro-config.cjs",
+      "kind": "module",
+      "purpose": "Preserve the product Metro config while excluding harness-owned checkout temp artifacts.",
+      "inputs": "base Metro config; env MM_HARNESS_METRO_PROJECT_ROOT, MM_HARNESS_METRO_BASE_CONFIG",
+      "outputs": "merged Metro config with resolver.blockList for <projectRoot>/temp"
+    },
     {
       "id": "mobile/stop-metro",
       "entry": "adapters/mobile/stop-metro.sh",

package/adapters/mobile/metro-config.cjs

@@ -0,0 +1,93 @@
+'use strict';
+
+const fs = require('node:fs');
+const { createRequire } = require('node:module');
+const path = require('node:path');
+const { pathToFileURL } = require('node:url');
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function appendBlockList(blockList, pattern) {
+  if (Array.isArray(blockList)) return [...blockList, pattern];
+  return blockList instanceof RegExp ? [blockList, pattern] : [pattern];
+}
+
+function blockListFlags(blockList) {
+  const first = Array.isArray(blockList) ? blockList[0] : blockList;
+  return first instanceof RegExp ? first.flags : '';
+}
+
+function resolveExpoConfigLoader(projectRoot) {
+  const requireFromProject = createRequire(path.join(projectRoot, 'package.json'));
+  let requireUtilsPath;
+  try {
+    requireUtilsPath = requireFromProject.resolve('@expo/require-utils');
+  } catch (error) {
+    if (error?.code !== 'MODULE_NOT_FOUND') throw error;
+    return null;
+  }
+  const { loadModuleSync } = requireFromProject(requireUtilsPath);
+  return typeof loadModuleSync === 'function' ? loadModuleSync : null;
+}
+
+async function loadProductConfig(configPath, baseConfig, projectRoot) {
+  let loaded;
+  const expoConfigLoader = resolveExpoConfigLoader(projectRoot);
+  if (expoConfigLoader) {
+    loaded = expoConfigLoader(configPath);
+  } else {
+    try {
+      loaded = require(configPath);
+    } catch (error) {
+      if (error?.code !== 'ERR_REQUIRE_ESM') throw error;
+      loaded = await import(pathToFileURL(configPath).href);
+    }
+  }
+
+  const moduleValue = await loaded;
+  const exported =
+    moduleValue?.__esModule ||
+    moduleValue?.[Symbol.toStringTag] === 'Module'
+      ? moduleValue.default
+      : moduleValue;
+  const config = await exported;
+  return typeof config === 'function' ? config(baseConfig) : config;
+}
+
+module.exports = async function harnessMetroConfig(baseConfig) {
+  const projectRoot = path.resolve(
+    process.env.MM_HARNESS_METRO_PROJECT_ROOT || process.cwd(),
+  );
+  const productConfigPath = path.resolve(
+    process.env.MM_HARNESS_METRO_BASE_CONFIG ||
+      path.join(projectRoot, 'metro.config.js'),
+  );
+  let productConfig = baseConfig;
+  if (fs.existsSync(productConfigPath)) {
+    productConfig = await loadProductConfig(
+      productConfigPath,
+      baseConfig,
+      projectRoot,
+    );
+  }
+
+  const tempRoot = path.join(projectRoot, 'temp');
+  const existingBlockList =
+    productConfig.resolver?.blockList ?? baseConfig.resolver?.blockList;
+  const tempPattern = new RegExp(
+    `^${escapeRegExp(tempRoot)}(?:${escapeRegExp(path.sep)}|$)`,
+    blockListFlags(existingBlockList),
+  );
+  return {
+    ...productConfig,
+    resolver: {
+      ...productConfig.resolver,
+      blockList: appendBlockList(
+        existingBlockList,
+        tempPattern,
+      ),
+    },
+  };
+};

package/adapters/mobile/start-metro.sh

@@ -49,6 +49,7 @@ fi
 # only ever inspect or signal a Metro listening on $PORT.
 # shellcheck disable=SC1091
 . "$SCRIPT_DIR/lib/metro-listener.sh"
+MOBILE_METRO_REQUIRED_ENV="${MOBILE_METRO_REQUIRED_ENV:-MM_INFURA_PROJECT_ID} MM_HARNESS_METRO_PROJECT_ROOT EXPO_OVERRIDE_METRO_CONFIG"
 
 # RECIPE_RUNTIME_DIR (relative, validated) makes runtime state per-run so jobs
 # sharing one checkout do not collide on metro.log / metro.pid / metro.tmux.
@@ -98,6 +99,13 @@ set +a
 export EXPO_NO_TYPESCRIPT_SETUP=1
 export WATCHER_PORT="$(printf '%q' "$PORT")" METRO_PORT="$(printf '%q' "$PORT")"
 export METRO_MAX_WORKERS="$(printf '%q' "$METRO_WORKERS")"
+export MM_HARNESS_METRO_PROJECT_ROOT="$(printf '%q' "$TARGET")"
+if [ -n "\${EXPO_OVERRIDE_METRO_CONFIG:-}" ]; then
+  export MM_HARNESS_METRO_BASE_CONFIG="\$EXPO_OVERRIDE_METRO_CONFIG"
+else
+  export MM_HARNESS_METRO_BASE_CONFIG=$(printf '%q' "$TARGET/metro.config.js")
+fi
+export EXPO_OVERRIDE_METRO_CONFIG="$(printf '%q' "$SCRIPT_DIR/metro-config.cjs")"
 yarn expo start --port "$(printf '%q' "$PORT")"$clear_flag 2>&1 | tee -a "$(printf '%q' "$LOG_FILE")"
 EOF
   chmod +x "$runner"
@@ -184,6 +192,9 @@ if ! start_metro_tmux; then
     export EXPO_NO_TYPESCRIPT_SETUP=1
     export WATCHER_PORT="${PORT}" METRO_PORT="${PORT}"
     export METRO_MAX_WORKERS="${METRO_WORKERS}"
+    export MM_HARNESS_METRO_PROJECT_ROOT="$TARGET"
+    export MM_HARNESS_METRO_BASE_CONFIG="${EXPO_OVERRIDE_METRO_CONFIG:-$TARGET/metro.config.js}"
+    export EXPO_OVERRIDE_METRO_CONFIG="$SCRIPT_DIR/metro-config.cjs"
     launcher_args=(
       --target "$TARGET"
       --port "$PORT"

package/dist/recipe-security.js

@@ -18,6 +18,7 @@ const APP_MUTATION_CUSTOM_ACTIONS = /* @__PURE__ */ new Set([
   "metamask.perps.close_positions",
   "metamask.perps.close_orders",
   "metamask.perps.place_order",
+  "metamask.perps.update_position_tpsl",
   "metamask.perps.ensure_positions",
   "metamask.perps.ensure_orders",
   "metamask.perps.start_state",
@@ -27,6 +28,7 @@ const EXTERNAL_MUTATION_CUSTOM_ACTIONS = /* @__PURE__ */ new Set([
   "metamask.perps.close_positions",
   "metamask.perps.close_orders",
   "metamask.perps.place_order",
+  "metamask.perps.update_position_tpsl",
   "metamask.perps.ensure_positions",
   "metamask.perps.ensure_orders",
   "metamask.perps.start_state",

package/library/actions/core/perps/_controller.mjs

@@ -625,6 +625,13 @@ export function redactOrder(order) {
     size: order.size ?? order.sz ?? order.szi ?? null,
     price: order.price ?? order.limitPx ?? order.px ?? null,
     type: order.orderType ?? order.type ?? null,
+    // Trigger data, so evidence shows what a stop / take-profit placement
+    // actually round-tripped from the exchange.
+    triggerOrderType: order.triggerOrderType ?? null,
+    triggerPrice: order.triggerPrice ?? order.triggerPx ?? null,
+    detailedOrderType: order.detailedOrderType ?? null,
+    isTrigger: order.isTrigger ?? null,
+    reduceOnly: order.reduceOnly ?? null,
   };
 }
 

package/library/actions/core/perps/assert_orders.mjs

@@ -11,6 +11,13 @@ import {
 // over the controller's standalone getOpenOrders path (no signer / provider init
 // needed) — throws on mismatch so the recipe fails loudly. Mirrors
 // assert_positions.mjs.
+//
+// Optional expect_* fields additionally assert the TRIGGER DATA the exchange
+// round-tripped for every matching order: expect_trigger_order_type (the
+// normalized placement type, e.g. stop_market), expect_trigger_price,
+// expect_execution (market | limit once triggered), expect_reduce_only, and
+// expect_size (proves a partial TP/SL quantity). They use the controller's own
+// field names (triggerOrderType, triggerPrice, orderType, reduceOnly, size).
 
 export function expectedOpen(input) {
   if (input.node?.state == null) throw new Error('metamask.perps.assert_orders requires state=open or state=none.');
@@ -20,6 +27,79 @@ export function expectedOpen(input) {
   throw new Error(`metamask.perps.assert_orders received unsupported state: ${state}`);
 }
 
+/**
+ * Collect the optional trigger-data expectations from the node.
+ *
+ * @param input - Adapter input.
+ * @returns The expectations the node set, keyed by controller field name.
+ */
+/**
+ * Whether the node narrowed matching to trigger orders only.
+ *
+ * @param input - Adapter input.
+ * @returns True when only trigger orders should be considered.
+ */
+export function onlyTriggerOrders(input) {
+  const value = input.node?.only_trigger_orders ?? input.node?.onlyTriggerOrders;
+  return value === true || String(value).toLowerCase() === 'true';
+}
+
+export function expectedTriggerData(input) {
+  const node = input.node ?? {};
+  const expectations = {
+    triggerOrderType:
+      node.expect_trigger_order_type ?? node.expectTriggerOrderType,
+    triggerPrice: node.expect_trigger_price ?? node.expectTriggerPrice,
+    orderType: node.expect_execution ?? node.expectExecution,
+    reduceOnly: node.expect_reduce_only ?? node.expectReduceOnly,
+    size: node.expect_size ?? node.expectSize,
+  };
+  return Object.fromEntries(
+    Object.entries(expectations).filter(
+      ([, value]) => value !== undefined && value !== null,
+    ),
+  );
+}
+
+/**
+ * Assert every matching order carries the expected trigger data.
+ *
+ * @param orders - Matching open orders.
+ * @param expectations - Expectations from `expectedTriggerData`.
+ */
+export function assertTriggerData(orders, expectations) {
+  const fields = Object.keys(expectations);
+  if (fields.length === 0) return;
+
+  for (const order of orders) {
+    for (const field of fields) {
+      const expected = expectations[field];
+      const actual = order[field];
+      const expectedNumber = Number(expected);
+      const actualNumber = Number(actual);
+      const numeric =
+        typeof expected !== 'boolean' &&
+        expected !== '' &&
+        actual !== null &&
+        actual !== undefined &&
+        Number.isFinite(expectedNumber) &&
+        Number.isFinite(actualNumber);
+      const matches =
+        typeof expected === 'boolean'
+          ? Boolean(actual) === expected
+          : // Prices and sizes round-trip with exchange formatting
+            // ('44000' -> '44000.0'), so compare them numerically.
+            (numeric && expectedNumber === actualNumber) ||
+            String(actual) === String(expected);
+      if (!matches) {
+        throw new Error(
+          `Open Perps order ${order.orderId ?? '?'} (${order.symbol ?? '?'}) has ${field}=${JSON.stringify(actual)}, expected ${JSON.stringify(expected)}.`,
+        );
+      }
+    }
+  }
+}
+
 export async function assertOrders(input, expectOpen = expectedOpen(input)) {
   requireExplicitSelection(input);
   const { controller, accountAddress, network } = await getCoreController(input);
@@ -33,6 +113,11 @@ export async function assertOrders(input, expectOpen = expectedOpen(input)) {
       userAddress: accountAddress,
     });
     matching = selectedItems(input, orders);
+    if (onlyTriggerOrders(input)) {
+      // Narrow to the trigger orders on the market so expectations are not
+      // applied to an unrelated parent order resting alongside them.
+      matching = matching.filter((order) => order.isTrigger === true);
+    }
     if (expectOpen ? matching.length > 0 : matching.length === 0) break;
     if (Date.now() >= deadline) break;
     await new Promise((resolve) =>
@@ -44,6 +129,11 @@ export async function assertOrders(input, expectOpen = expectedOpen(input)) {
   if (expectOpen && !hasOrder) {
     throw new Error('Expected at least one matching open Perps order, but found none.');
   }
+
+  const triggerExpectations = expectedTriggerData(input);
+  if (expectOpen) {
+    assertTriggerData(matching, triggerExpectations);
+  }
   if (!expectOpen && hasOrder) {
     throw new Error(`Expected no matching open Perps orders, but found ${matching.length}.`);
   }
@@ -54,6 +144,8 @@ export async function assertOrders(input, expectOpen = expectedOpen(input)) {
     network,
     account: accountAddress,
     expectedOpen: expectOpen,
+    expectedTrigger:
+      Object.keys(triggerExpectations).length === 0 ? null : triggerExpectations,
     matchingCount: matching.length,
     orders: matching.map(redactOrder),
     proofPath: 'perps-controller-getOpenOrders',