@deeeed/metamask-harness 0.23.0 → 0.24.0

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

@@ -1,8 +1,11 @@
 import {
   configuredSymbols,
+  controllerRejection,
   currentMarketPrice,
   getCoreControllerWithSigner,
   isDirectRun,
+  optionalBooleanParam,
+  optionalParam,
   redactOrder,
   redactPosition,
   runAdapter,
@@ -64,8 +67,8 @@ const TRIGGER_ORDER_TYPES = ORDER_TYPES.filter((type) => type.includes('_'));
 const LIMIT_EXECUTION_ORDER_TYPES = ['limit', 'stop_limit', 'take_profit_limit'];
 
 function resolveOrderType(input) {
-  const raw = String(
-    input.node?.order_type ?? input.node?.orderType ?? 'market',
+  const raw = (
+    optionalParam(input.node ?? {}, 'order_type', 'orderType') ?? 'market'
   ).toLowerCase();
   if (!ORDER_TYPES.includes(raw)) {
     throw new Error(
@@ -91,8 +94,12 @@ const isLimitExecution = (orderType) => LIMIT_EXECUTION_ORDER_TYPES.includes(ord
  * @param mid - Current mid price.
  */
 function resolveTriggerPrice(input, orderType, isBuy, mid) {
-  const absolute = input.node?.trigger_price ?? input.node?.triggerPrice;
-  if (absolute !== undefined && absolute !== null && String(absolute).length > 0) {
+  const absolute = optionalParam(
+    input.node ?? {},
+    'trigger_price',
+    'triggerPrice',
+  );
+  if (absolute !== undefined) {
     const numeric = Number(absolute);
     if (!Number.isFinite(numeric) || numeric <= 0) {
       throw new Error(
@@ -101,7 +108,11 @@ function resolveTriggerPrice(input, orderType, isBuy, mid) {
     }
     return numeric;
   }
-  const rawOffset = input.node?.trigger_offset_pct ?? input.node?.triggerOffsetPct;
+  const rawOffset = optionalParam(
+    input.node ?? {},
+    'trigger_offset_pct',
+    'triggerOffsetPct',
+  );
   const isStop = orderType.startsWith('stop');
   // A stop fires against the position: below mid when selling to close a long.
   const defaultOffset = isStop === isBuy ? 30 : -30;
@@ -121,27 +132,96 @@ function resolveTriggerPrice(input, orderType, isBuy, mid) {
   return price;
 }
 
+/**
+ * Resolve a trigger price set on a placement that is not a trigger type.
+ *
+ * Such a value is a caller mistake, which the controller reports as
+ * ORDER_TRIGGER_PRICE_NOT_SUPPORTED. It has to reach the controller in either
+ * spelling to be reported: accepting only the absolute form meant an offset was
+ * silently dropped and the order placed for real instead of being refused.
+ *
+ * @param input - Adapter input (node.trigger_price / node.trigger_offset_pct).
+ * @param mid - Current mid price, for the offset spelling.
+ * @returns The stray trigger price, or undefined when the node set none.
+ */
+function resolveStrayTriggerPrice(input, mid) {
+  const node = input.node ?? {};
+  const absolute = optionalParam(node, 'trigger_price', 'triggerPrice');
+  if (absolute !== undefined) {
+    return absolute;
+  }
+
+  const rawOffset = optionalParam(
+    node,
+    'trigger_offset_pct',
+    'triggerOffsetPct',
+  );
+  if (rawOffset === undefined) {
+    return undefined;
+  }
+
+  const offsetPct = Number(rawOffset);
+  if (!Number.isFinite(offsetPct)) {
+    throw new Error(
+      `metamask.perps.place_order received invalid trigger_offset_pct: ${rawOffset}.`,
+    );
+  }
+  return String(mid * (1 + offsetPct / 100));
+}
+
 /**
  * Collect the attached TP/SL fields, using the controller's own param names.
  *
  * @param input - Adapter input.
  * @returns Attached TP/SL params, omitting anything the node did not set.
  */
-function resolveAttachedTpsl(input) {
+function resolveAttachedTpsl(input, mid) {
   const node = input.node ?? {};
-  const pick = (snake, camel) => {
-    const value = node[snake] ?? node[camel];
-    return value === undefined || value === null ? undefined : String(value);
+  const pick = (snake, camel) => optionalParam(node, snake, camel);
+
+  // An absolute price only holds for one market at one moment, so offsets from
+  // live mid are the preferred spelling; an explicit price still wins.
+  const fromOffset = (snake, camel, name) => {
+    const raw = pick(snake, camel);
+    if (raw === undefined) {
+      return undefined;
+    }
+    const pct = Number(raw);
+    if (!Number.isFinite(pct)) {
+      throw new Error(
+        `metamask.perps.place_order received invalid ${name}: ${raw}.`,
+      );
+    }
+    const price = mid * (1 + pct / 100);
+    if (!Number.isFinite(price) || price <= 0) {
+      throw new Error(
+        `metamask.perps.place_order computed a non-positive price from ${name}=${raw}.`,
+      );
+    }
+    return String(price);
   };
+
   const attached = {
-    takeProfitPrice: pick('take_profit_price', 'takeProfitPrice'),
+    takeProfitPrice:
+      pick('take_profit_price', 'takeProfitPrice') ??
+      fromOffset(
+        'take_profit_offset_pct',
+        'takeProfitOffsetPct',
+        'take_profit_offset_pct',
+      ),
     takeProfitSize: pick('take_profit_size', 'takeProfitSize'),
-    stopLossPrice: pick('stop_loss_price', 'stopLossPrice'),
+    stopLossPrice:
+      pick('stop_loss_price', 'stopLossPrice') ??
+      fromOffset(
+        'stop_loss_offset_pct',
+        'stopLossOffsetPct',
+        'stop_loss_offset_pct',
+      ),
     stopLossSize: pick('stop_loss_size', 'stopLossSize'),
   };
-  const linkage = node.tpsl_linkage ?? node.tpslLinkage;
-  if (linkage !== undefined && linkage !== null) {
-    attached.tpslLinkage = String(linkage);
+  const linkage = optionalParam(node, 'tpsl_linkage', 'tpslLinkage');
+  if (linkage !== undefined) {
+    attached.tpslLinkage = linkage;
   }
   return Object.fromEntries(
     Object.entries(attached).filter(([, value]) => value !== undefined),
@@ -159,15 +239,18 @@ function resolveAttachedTpsl(input) {
  * @param mid - Current mid price.
  */
 function resolveLimitPrice(input, isBuy, mid) {
-  const absolute = input.node?.limit_price ?? input.node?.limitPrice ?? input.node?.price;
-  if (absolute !== undefined && absolute !== null && String(absolute).length > 0) {
+  const node = input.node ?? {};
+  const absolute =
+    optionalParam(node, 'limit_price', 'limitPrice') ??
+    optionalParam(node, 'price');
+  if (absolute !== undefined) {
     const numeric = Number(absolute);
     if (!Number.isFinite(numeric) || numeric <= 0) {
       throw new Error(`metamask.perps.place_order received invalid limit_price: ${absolute}.`);
     }
     return numeric;
   }
-  const rawOffset = input.node?.offset_pct ?? input.node?.offsetPct;
+  const rawOffset = optionalParam(input.node ?? {}, 'offset_pct', 'offsetPct');
   // Default far-from-mid offset so the resting order does not fill.
   const offsetPct = rawOffset === undefined || rawOffset === null ? (isBuy ? -30 : 30) : Number(rawOffset);
   if (!Number.isFinite(offsetPct)) {
@@ -182,12 +265,16 @@ function resolveLimitPrice(input, isBuy, mid) {
 
 export function resolveTriggerLimitPrice(input, isBuy, triggerPrice) {
   const node = input.node ?? {};
+  // Presence must be tested on the NORMALIZED value. A recipe cannot omit a
+  // key, so an unused param arrives as '' — and `'' !== undefined` is true, so
+  // a raw presence test reads a blank as explicit and then falls through to the
+  // far-from-mid default. For a buy trigger at 100 that silently turns 101 into
+  // 70: an unrelated price, on the wrong side, from a param nobody set.
   const hasExplicitPrice =
-    node.limit_price !== undefined ||
-    node.limitPrice !== undefined ||
-    node.price !== undefined;
+    optionalParam(node, 'limit_price', 'limitPrice') !== undefined ||
+    optionalParam(node, 'price') !== undefined;
   const hasExplicitOffset =
-    node.offset_pct !== undefined || node.offsetPct !== undefined;
+    optionalParam(node, 'offset_pct', 'offsetPct') !== undefined;
   if (hasExplicitPrice || hasExplicitOffset) {
     return resolveLimitPrice(input, isBuy, triggerPrice);
   }
@@ -265,28 +352,54 @@ async function waitForPlacedOrder(
 
 export async function placeOrder(input) {
   const symbol = resolveSymbol(input);
-  if (input.node?.side == null) throw new Error('metamask.perps.place_order requires side=long or side=short.');
-  if (input.node?.amount == null && input.node?.notional == null) {
+  // Blank counts as absent, not as a default direction: treating '' as long
+  // would let an unset template place a real order on the wrong side.
+  const side = optionalParam(input.node ?? {}, 'side', 'side')?.toLowerCase();
+  if (side === undefined) {
+    throw new Error(
+      'metamask.perps.place_order requires side=long or side=short.',
+    );
+  }
+  const usdAmount =
+    optionalParam(input.node ?? {}, 'amount') ??
+    optionalParam(input.node ?? {}, 'notional');
+  if (usdAmount === undefined) {
     throw new Error('metamask.perps.place_order requires amount=<usd> or notional=<usd>.');
   }
   const { controller, accountAddress, network } = await getCoreControllerWithSigner(input);
-  const side = String(input.node.side).toLowerCase();
-  const isBuy = side !== 'short';
+  if (side !== 'long' && side !== 'short') {
+    throw new Error(
+      `metamask.perps.place_order received invalid side: ${side} (expected long or short).`,
+    );
+  }
+  const isBuy = side === 'long';
   const orderType = resolveOrderType(input);
-  const usdAmount = String(input.node.amount ?? input.node.notional);
-  const leverage = Number(input.node?.leverage ?? 3);
+  const leverage = Number(optionalParam(input.node ?? {}, 'leverage') ?? 3);
   const maxSlippageBps = Number(
-    input.node?.max_slippage_bps ?? input.node?.maxSlippageBps ?? 300,
+    optionalParam(
+      input.node ?? {},
+      'max_slippage_bps',
+      'maxSlippageBps',
+    ) ?? 300,
   );
-  const postOnly = input.node?.post_only ?? input.node?.postOnly;
-  const requestedTimeInForce =
-    input.node?.time_in_force ?? input.node?.timeInForce;
-  if (
-    orderType !== 'limit' &&
-    (postOnly !== undefined || requestedTimeInForce !== undefined)
-  ) {
+  const postOnly = optionalBooleanParam(
+    input.node ?? {},
+    'post_only',
+    'postOnly',
+  );
+  const requestedTimeInForce = optionalParam(
+    input.node ?? {},
+    'time_in_force',
+    'timeInForce',
+  );
+  // The controller rejects this combination itself, with
+  // ORDER_TIME_IN_FORCE_NOT_SUPPORTED. Duplicating the check here only made the
+  // controller's own refusal unreachable, so the fields are forwarded and the
+  // controller decides. post_only has no controller equivalent, so it keeps a
+  // local guard.
+  if (orderType !== 'limit' && postOnly !== undefined) {
     throw new Error(
-      'metamask.perps.place_order supports time_in_force/post_only only for order_type=limit.',
+      'metamask.perps.place_order supports post_only only for order_type=limit.',
     );
   }
   const timeInForce =
@@ -317,9 +430,40 @@ export async function placeOrder(input) {
 
   const currentPrice = await currentMarketPrice(controller, symbol);
 
-  const reduceOnly =
-    input.node?.reduce_only ?? input.node?.reduceOnly ?? undefined;
-  const attachedTpsl = resolveAttachedTpsl(input);
+  const reduceOnly = optionalBooleanParam(
+    input.node ?? {},
+    'reduce_only',
+    'reduceOnly',
+  );
+  const attachedTpsl = resolveAttachedTpsl(input, currentPrice);
+
+  // A non-trigger placement used to drop a stray trigger price or time in
+  // force. Silently discarding a field the caller set is wrong on its own
+  // terms, and it also hid the controller's refusal of it. Both are forwarded
+  // verbatim now, for every request, so what is submitted never depends on what
+  // the caller expects to happen. Trigger placements resolve their own trigger
+  // price below, so this only carries the stray case.
+  // Each branch below builds its own params, so a field only that branch
+  // considers stray has to be added to all of them — forwarding on the market
+  // branch alone left a limit order silently dropping a trigger price and a
+  // trigger order silently dropping a time in force, either of which then
+  // succeeded instead of reaching the controller's refusal.
+  const isTrigger = isTriggerOrderType(orderType);
+  const strayTriggerPrice = isTrigger
+    ? undefined
+    : resolveStrayTriggerPrice(input, currentPrice);
+  // A limit order legitimately carries a time in force; every other shape does
+  // not, and the controller refuses it.
+  const strayTimeInForce =
+    orderType === 'limit' ? undefined : requestedTimeInForce;
+  const forwardedFields = {
+    ...(strayTriggerPrice === undefined
+      ? {}
+      : { triggerPrice: strayTriggerPrice }),
+    ...(strayTimeInForce === undefined
+      ? {}
+      : { timeInForce: strayTimeInForce }),
+  };
 
   let orderParams;
   let limitPrice = null;
@@ -339,6 +483,7 @@ export async function placeOrder(input) {
       isBuy,
       size,
       orderType,
+      ...forwardedFields,
       triggerPrice: String(triggerPrice),
       ...(limitPrice === null ? {} : { price: String(limitPrice) }),
       leverage,
@@ -358,6 +503,7 @@ export async function placeOrder(input) {
       isBuy,
       size,
       orderType: 'limit',
+      ...forwardedFields,
       price: String(limitPrice),
       timeInForce,
       leverage,
@@ -374,6 +520,7 @@ export async function placeOrder(input) {
       isBuy,
       size,
       orderType: 'market',
+      ...forwardedFields,
       leverage,
       usdAmount,
       currentPrice,
@@ -386,9 +533,11 @@ export async function placeOrder(input) {
 
   const result = await controller.placeOrder(orderParams);
   if (!result || result.success !== true) {
-    throw new Error(
-      `core placeOrder failed for ${symbol} (${orderType}): ${result?.error ?? 'unknown error'} (currentPrice=${currentPrice}${limitPrice ? `, limitPrice=${limitPrice}` : ''}).`,
-    );
+    throw controllerRejection({
+      action: 'core placeOrder',
+      detail: `${symbol} (${orderType}), currentPrice=${currentPrice}${limitPrice ? `, limitPrice=${limitPrice}` : ''}`,
+      code: result?.error ?? 'unknown error',
+    });
   }
 
   // For limit orders, confirm a RESTING open order exists (not a filled position);
@@ -410,7 +559,7 @@ export async function placeOrder(input) {
         size: result.submittedSize ?? orderParams.size,
         reduceOnly: orderParams.reduceOnly ?? false,
       },
-      Number(input.node?.timeout_ms ?? 30000),
+      Number(optionalParam(input.node ?? {}, 'timeout_ms', 'timeoutMs') ?? 30000),
     );
   } else {
     positions = await controller.getPositions({

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

@@ -1,7 +1,9 @@
 import {
   configuredSymbols,
+  controllerRejection,
   getCoreControllerWithSigner,
   isDirectRun,
+  optionalParam,
   redactOrder,
   requireExplicitSelection,
   runAdapter,
@@ -22,11 +24,6 @@ import {
 // whole position. After submitting we re-read live open orders so the resulting
 // trigger orders — including their partial sizes — are visible as evidence.
 
-function optionalString(node, snake, camel) {
-  const value = node?.[snake] ?? node?.[camel];
-  return value === undefined || value === null ? undefined : String(value);
-}
-
 function numericValuesMatch(actual, expected) {
   const actualNumber = Number(actual);
   const expectedNumber = Number(expected);
@@ -94,12 +91,21 @@ export async function updatePositionTpsl(input) {
   const symbol = symbols[0];
 
   const node = input.node ?? {};
-  const takeProfitPrice = optionalString(node, 'take_profit_price', 'takeProfitPrice');
-  const stopLossPrice = optionalString(node, 'stop_loss_price', 'stopLossPrice');
-  const takeProfitSize = optionalString(node, 'take_profit_size', 'takeProfitSize');
-  const stopLossSize = optionalString(node, 'stop_loss_size', 'stopLossSize');
+  let takeProfitPrice = optionalParam(node, 'take_profit_price', 'takeProfitPrice');
+  let stopLossPrice = optionalParam(node, 'stop_loss_price', 'stopLossPrice');
+  let takeProfitSize = optionalParam(node, 'take_profit_size', 'takeProfitSize');
+  let stopLossSize = optionalParam(node, 'stop_loss_size', 'stopLossSize');
+  const takeProfitOffsetPct = optionalParam(node, 'take_profit_offset_pct', 'takeProfitOffsetPct');
+  const stopLossOffsetPct = optionalParam(node, 'stop_loss_offset_pct', 'stopLossOffsetPct');
+  const takeProfitFraction = optionalParam(node, 'take_profit_fraction', 'takeProfitFraction');
+  const stopLossFraction = optionalParam(node, 'stop_loss_fraction', 'stopLossFraction');
 
-  if (takeProfitPrice === undefined && stopLossPrice === undefined) {
+  if (
+    takeProfitPrice === undefined &&
+    stopLossPrice === undefined &&
+    takeProfitOffsetPct === undefined &&
+    stopLossOffsetPct === undefined
+  ) {
     throw new Error(
       'metamask.perps.update_position_tpsl requires take_profit_price and/or stop_loss_price (omit both only to clear, which is not supported here).',
     );
@@ -120,6 +126,93 @@ export async function updatePositionTpsl(input) {
     );
   }
 
+  // Prices and sizes are resolved from live mid and the actual position, so a
+  // recipe never has to name a number that only holds for one market at one
+  // moment. An absolute value still wins when the caller gives one.
+  // Both derivations below need the market, and each used to fetch it
+  // separately. getMarketDataWithPrices reads every market, so doing it twice in
+  // one adapter is what pushed this past the node timeout.
+  let market;
+  const readMarket = async () => {
+    if (market === undefined) {
+      const markets = await controller.getMarketDataWithPrices({
+        standalone: true,
+      });
+      market =
+        (Array.isArray(markets) ? markets : []).find(
+          (item) => (item?.symbol ?? '').toUpperCase() === symbol.toUpperCase(),
+        ) ?? null;
+    }
+    return market;
+  };
+
+  if (takeProfitOffsetPct !== undefined || stopLossOffsetPct !== undefined) {
+    // PerpsMarketData.price is a formatted string like '$103,245.00'.
+    const mid = Number(
+      String((await readMarket())?.price ?? '').replace(/[$,\s]/gu, ''),
+    );
+    if (!Number.isFinite(mid) || mid <= 0) {
+      throw new Error(
+        `metamask.perps.update_position_tpsl found no usable mid for ${symbol}.`,
+      );
+    }
+    const fromOffset = (raw, name) => {
+      const pct = Number(raw);
+      if (!Number.isFinite(pct)) {
+        throw new Error(
+          `metamask.perps.update_position_tpsl received invalid ${name}: ${raw}.`,
+        );
+      }
+      const price = mid * (1 + pct / 100);
+      if (!Number.isFinite(price) || price <= 0) {
+        throw new Error(
+          `metamask.perps.update_position_tpsl computed a non-positive price from ${name}=${raw}.`,
+        );
+      }
+      return String(price);
+    };
+    if (takeProfitPrice === undefined && takeProfitOffsetPct !== undefined) {
+      takeProfitPrice = fromOffset(takeProfitOffsetPct, 'take_profit_offset_pct');
+    }
+    if (stopLossPrice === undefined && stopLossOffsetPct !== undefined) {
+      stopLossPrice = fromOffset(stopLossOffsetPct, 'stop_loss_offset_pct');
+    }
+  }
+
+  if (takeProfitFraction !== undefined || stopLossFraction !== undefined) {
+    const absolutePositionSize = Math.abs(Number(position.size ?? position.szi ?? 0));
+    // Round to the market's own size precision before submitting. The venue
+    // rounds anyway, and the read-back below matches on size — so an unrounded
+    // fraction asks for a size that can never come back, and the poll spins
+    // until it times out.
+    const szDecimals = Number((await readMarket())?.szDecimals);
+    const fromFraction = (raw, name) => {
+      const fraction = Number(raw);
+      if (!Number.isFinite(fraction) || fraction <= 0 || fraction > 1) {
+        throw new Error(
+          `metamask.perps.update_position_tpsl received invalid ${name}: ${raw} (expected a fraction in (0, 1]).`,
+        );
+      }
+      const exact = absolutePositionSize * fraction;
+      if (!Number.isFinite(szDecimals)) {
+        return String(exact);
+      }
+      const rounded = Number(exact.toFixed(szDecimals));
+      if (rounded <= 0) {
+        throw new Error(
+          `metamask.perps.update_position_tpsl: ${name}=${raw} of a ${absolutePositionSize} position rounds to zero at ${szDecimals} size decimals; use a larger position or a larger fraction.`,
+        );
+      }
+      return String(rounded);
+    };
+    if (takeProfitSize === undefined && takeProfitFraction !== undefined) {
+      takeProfitSize = fromFraction(takeProfitFraction, 'take_profit_fraction');
+    }
+    if (stopLossSize === undefined && stopLossFraction !== undefined) {
+      stopLossSize = fromFraction(stopLossFraction, 'stop_loss_fraction');
+    }
+  }
+
   const params = {
     symbol,
     ...(takeProfitPrice === undefined ? {} : { takeProfitPrice }),
@@ -130,9 +223,11 @@ export async function updatePositionTpsl(input) {
 
   const result = await controller.updatePositionTPSL(params);
   if (!result || result.success !== true) {
-    throw new Error(
-      `core updatePositionTPSL failed for ${symbol}: ${result?.error ?? 'unknown error'}.`,
-    );
+    throw controllerRejection({
+      action: 'core updatePositionTPSL',
+      detail: symbol,
+      code: result?.error ?? 'unknown error',
+    });
   }
 
   const requests = [
@@ -156,12 +251,23 @@ export async function updatePositionTpsl(input) {
     accountAddress,
     input,
     requests,
-    Number(input.node?.timeout_ms ?? 30000),
+    // Poll for only part of the node's budget. Spending all of it means the
+    // runner kills this adapter before the mismatch below can be reported, so a
+    // read-back that never matches surfaces as an opaque timeout instead of
+    // saying which trigger order was missing.
+    Math.min(
+      Number(
+        optionalParam(input.node ?? {}, 'timeout_ms', 'timeoutMs') ?? 30000,
+      ) * 0.6,
+      60000,
+    ),
   );
 
   if (triggerOrders.length !== requests.length) {
     throw new Error(
-      `core updatePositionTPSL for ${symbol} reported success but only ${triggerOrders.length}/${requests.length} requested trigger orders are visible.`,
+      `core updatePositionTPSL for ${symbol} reported success but only ${triggerOrders.length}/${requests.length} requested trigger orders are visible. Requested: ${JSON.stringify(
+        requests,
+      )}.`,
     );
   }
 

package/library/actions/mobile/platform/bridge.mjs

@@ -1,8 +1,9 @@
 import { randomUUID } from 'node:crypto';
 import { constants as fsConstants } from 'node:fs';
-import { mkdir, open, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { mkdir, mkdtemp, open, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { execFile, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
+import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import bridgeErrors from '../../../../adapters/mobile/bridge-runtime/lib/bridge-errors.cjs';
@@ -420,7 +421,7 @@ export async function simulatorScreenshot(input, relPath) {
   await rm(absolute, { force: true });
   let temporaryDirectory;
   try {
-    temporaryDirectory = await createScreenshotTemporaryDirectory(absolute);
+    temporaryDirectory = await createScreenshotTemporaryDirectory();
     const captured = path.join(temporaryDirectory, 'captured.png');
     await createPrivateScreenshotFile(captured);
     let result;
@@ -446,7 +447,7 @@ export async function simulatorScreenshot(input, relPath) {
         `  Next: mm-harness doctor --adapter mobile --device ${target} --json`,
       );
     }
-    await publishPrivateScreenshot(png, temporaryDirectory, absolute);
+    await publishPrivateScreenshot(png, absolute);
     await rm(temporaryDirectory, { recursive: true, force: true });
   } catch (error) {
     await removeScreenshotResidue(temporaryDirectory, absolute);
@@ -477,7 +478,7 @@ async function androidScreenshot(input, relPath) {
   await rm(absolute, { force: true });
   let temporaryDirectory;
   try {
-    temporaryDirectory = await createScreenshotTemporaryDirectory(absolute);
+    temporaryDirectory = await createScreenshotTemporaryDirectory();
     const adbSerial = await resolveAndroidScreenshotSerial(input);
     let result;
     try {
@@ -501,7 +502,7 @@ async function androidScreenshot(input, relPath) {
         `  Next: mm-harness doctor --adapter mobile --device ${adbSerial} --json`,
       );
     }
-    await publishPrivateScreenshot(result.stdout, temporaryDirectory, absolute);
+    await publishPrivateScreenshot(result.stdout, absolute);
     await rm(temporaryDirectory, { recursive: true, force: true });
     return {
       path: relative,
@@ -672,10 +673,8 @@ function pngCrc32(bytes, start, end) {
   return (crc ^ 0xffffffff) >>> 0;
 }
 
-async function createScreenshotTemporaryDirectory(absolute) {
-  const temporary = path.join(path.dirname(absolute), `.${path.basename(absolute)}.${process.pid}.${randomUUID()}.tmp`);
-  await mkdir(temporary, { mode: 0o700 });
-  return temporary;
+async function createScreenshotTemporaryDirectory() {
+  return mkdtemp(path.join(os.tmpdir(), 'mm-harness-screenshot-'));
 }
 
 async function createPrivateScreenshotFile(file) {
@@ -706,21 +705,28 @@ async function readPrivateScreenshotFile(file) {
   }
 }
 
-async function publishPrivateScreenshot(png, temporaryDirectory, absolute) {
-  const publication = path.join(temporaryDirectory, 'validated.png');
-  const handle = await open(
-    publication,
-    fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_NOFOLLOW,
-    0o600,
+async function publishPrivateScreenshot(png, absolute) {
+  const publication = path.join(
+    path.dirname(absolute),
+    `.${path.basename(absolute)}.${process.pid}.${randomUUID()}.tmp`,
   );
+  let handle;
   try {
+    handle = await open(
+      publication,
+      fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_NOFOLLOW,
+      0o600,
+    );
     const stats = await handle.stat();
     if (!stats.isFile() || stats.nlink !== 1) throw new Error('validated screenshot is not a private regular file');
     await handle.writeFile(png);
     await handle.sync();
+    await handle.close();
+    handle = undefined;
     await rename(publication, absolute);
   } finally {
-    await handle.close();
+    await handle?.close();
+    await rm(publication, { force: true });
   }
 }