refactor: dedupe replay and interaction series helpers

Author: thymikee

src/core/dispatch.ts

@@ -150,14 +150,13 @@ export async function dispatchCommand(
         return { x, y, count, intervalMs, holdMs, jitterPx, timingMode: 'runner-series' };
       }
 
-      for (let index = 0; index < count; index += 1) {
+      await runRepeatedSeries(count, intervalMs, async (index) => {
         const [dx, dy] = computeDeterministicJitter(index, jitterPx);
         const targetX = x + dx;
         const targetY = y + dy;
         if (holdMs > 0) await interactor.longPress(targetX, targetY, holdMs);
         else await interactor.tap(targetX, targetY);
-        if (index < count - 1 && intervalMs > 0) await sleep(intervalMs);
-      }
+      });
 
       return { x, y, count, intervalMs, holdMs, jitterPx };
     }
@@ -211,12 +210,11 @@ export async function dispatchCommand(
         };
       }
 
-      for (let index = 0; index < count; index += 1) {
+      await runRepeatedSeries(count, pauseMs, async (index) => {
         const reverse = pattern === 'ping-pong' && index % 2 === 1;
         if (reverse) await interactor.swipe(x2, y2, x1, y1, effectiveDurationMs);
         else await interactor.swipe(x1, y1, x2, y2, effectiveDurationMs);
-        if (index < count - 1 && pauseMs > 0) await sleep(pauseMs);
-      }
+      });
 
       return {
         x1,
@@ -420,6 +418,19 @@ function computeDeterministicJitter(index: number, jitterPx: number): [number, n
   return [dx * jitterPx, dy * jitterPx];
 }
 
+async function runRepeatedSeries(
+  count: number,
+  pauseMs: number,
+  operation: (index: number) => Promise<void>,
+): Promise<void> {
+  for (let index = 0; index < count; index += 1) {
+    await operation(index);
+    if (index < count - 1 && pauseMs > 0) {
+      await sleep(pauseMs);
+    }
+  }
+}
+
 async function sleep(ms: number): Promise<void> {
   await new Promise((resolve) => setTimeout(resolve, ms));
 }

src/daemon/handlers/interaction.ts

@@ -6,6 +6,7 @@ import type { DaemonRequest, DaemonResponse, SessionState } from '../types.ts';
 import { SessionStore } from '../session-store.ts';
 import { evaluateIsPredicate, isSupportedPredicate } from '../is-predicates.ts';
 import { extractNodeText, findNodeByLabel, isFillableType, pruneGroupNodes, resolveRefLabel } from '../snapshot-processing.ts';
+import { isClickLikeCommand } from '../script-utils.ts';
 import {
   buildSelectorChainForNode,
   findSelectorChainMatch,
@@ -33,7 +34,7 @@ export async function handleInteractionCommands(params: {
   const dispatch = params.dispatch ?? dispatchCommand;
   const command = req.command;
 
-  if (command === 'click' || command === 'press') {
+  if (isClickLikeCommand(command)) {
     const session = sessionStore.get(sessionName);
     if (!session) {
       return {
@@ -114,9 +115,14 @@ export async function handleInteractionCommands(params: {
       };
     }
     const chain = parseSelectorChain(selectorExpression);
-    const snapshot = await captureSnapshotForSession(session, req.flags, sessionStore, contextFromFlags, {
-      interactiveOnly: true,
-    });
+    const snapshot = await captureSnapshotForSession(
+      session,
+      req.flags,
+      sessionStore,
+      contextFromFlags,
+      { interactiveOnly: true },
+      dispatch,
+    );
     const resolved = resolveSelectorChain(snapshot.nodes, chain, {
       platform: session.device.platform,
       requireRect: true,
@@ -185,7 +191,7 @@ export async function handleInteractionCommands(params: {
       const refLabel = resolveRefLabel(node, session.snapshot.nodes);
       const selectorChain = buildSelectorChainForNode(node, session.device.platform, { action: 'fill' });
       const { x, y } = centerOfRect(node.rect);
-      const data = await dispatchCommand(
+      const data = await dispatch(
         session.device,
         'fill',
         [String(x), String(y), text],
@@ -224,9 +230,14 @@ export async function handleInteractionCommands(params: {
         return { ok: false, error: { code: 'INVALID_ARGS', message: 'fill requires text after selector' } };
       }
       const chain = parseSelectorChain(selectorArgs.selectorExpression);
-      const snapshot = await captureSnapshotForSession(session, req.flags, sessionStore, contextFromFlags, {
-        interactiveOnly: true,
-      });
+      const snapshot = await captureSnapshotForSession(
+        session,
+        req.flags,
+        sessionStore,
+        contextFromFlags,
+        { interactiveOnly: true },
+        dispatch,
+      );
       const resolved = resolveSelectorChain(snapshot.nodes, chain, {
         platform: session.device.platform,
         requireRect: true,
@@ -249,7 +260,7 @@ export async function handleInteractionCommands(params: {
           ? `fill target ${resolved.selector.raw} resolved to "${nodeType}", attempting fill anyway.`
           : undefined;
       const { x, y } = centerOfRect(resolved.node.rect);
-      const data = await dispatchCommand(session.device, 'fill', [String(x), String(y), text], req.flags?.out, {
+      const data = await dispatch(session.device, 'fill', [String(x), String(y), text], req.flags?.out, {
         ...contextFromFlags(req.flags, session.appBundleId, session.trace?.outPath),
       });
       const selectorChain = buildSelectorChainForNode(node, session.device.platform, { action: 'fill' });
@@ -337,9 +348,14 @@ export async function handleInteractionCommands(params: {
       };
     }
     const chain = parseSelectorChain(selectorExpression);
-    const snapshot = await captureSnapshotForSession(session, req.flags, sessionStore, contextFromFlags, {
-      interactiveOnly: false,
-    });
+    const snapshot = await captureSnapshotForSession(
+      session,
+      req.flags,
+      sessionStore,
+      contextFromFlags,
+      { interactiveOnly: false },
+      dispatch,
+    );
     const resolved = resolveSelectorChain(snapshot.nodes, chain, {
       platform: session.device.platform,
       requireRect: false,
@@ -435,9 +451,14 @@ export async function handleInteractionCommands(params: {
       };
     }
     const chain = parseSelectorChain(split.selectorExpression);
-    const snapshot = await captureSnapshotForSession(session, req.flags, sessionStore, contextFromFlags, {
-      interactiveOnly: false,
-    });
+    const snapshot = await captureSnapshotForSession(
+      session,
+      req.flags,
+      sessionStore,
+      contextFromFlags,
+      { interactiveOnly: false },
+      dispatch,
+    );
     if (predicate === 'exists') {
       const matched = findSelectorChainMatch(snapshot.nodes, chain, {
         platform: session.device.platform,
@@ -518,8 +539,9 @@ async function captureSnapshotForSession(
   sessionStore: SessionStore,
   contextFromFlags: ContextFromFlags,
   options: { interactiveOnly: boolean },
+  dispatch: typeof dispatchCommand = dispatchCommand,
 ) {
-  const data = (await dispatchCommand(session.device, 'snapshot', [], flags?.out, {
+  const data = (await dispatch(session.device, 'snapshot', [], flags?.out, {
     ...contextFromFlags(
       {
         ...(flags ?? {}),

src/daemon/handlers/session.ts

@@ -19,6 +19,13 @@ import {
   tryParseSelectorChain,
 } from '../selectors.ts';
 import { inferFillText, uniqueStrings } from '../action-utils.ts';
+import {
+  appendScriptSeriesFlags,
+  formatScriptActionSummary,
+  formatScriptArg,
+  isClickLikeCommand,
+  parseReplaySeriesFlags,
+} from '../script-utils.ts';
 
 type ReinstallOps = {
   ios: (device: DeviceInfo, app: string, appPath: string) => Promise<{ bundleId: string }>;
@@ -649,13 +656,7 @@ function withReplayFailureContext(
 }
 
 function formatReplayActionSummary(action: SessionAction): string {
-  const values = (action.positionals ?? []).map((value) => {
-    const trimmed = value.trim();
-    if (/^-?\d+(\.\d+)?$/.test(trimmed)) return trimmed;
-    if (trimmed.startsWith('@')) return trimmed;
-    return JSON.stringify(trimmed);
-  });
-  return [action.command, ...values].join(' ');
+  return formatScriptActionSummary(action);
 }
 
 async function healReplayAction(params: {
@@ -666,13 +667,12 @@ async function healReplayAction(params: {
   dispatch: typeof dispatchCommand;
 }): Promise<SessionAction | null> {
   const { action, sessionName, logPath, sessionStore, dispatch } = params;
-  if (!['click', 'press', 'fill', 'get', 'is', 'wait'].includes(action.command)) return null;
+  if (!(isClickLikeCommand(action.command) || ['fill', 'get', 'is', 'wait'].includes(action.command))) return null;
   const session = sessionStore.get(sessionName);
   if (!session) return null;
-  const requiresRect = action.command === 'click' || action.command === 'press' || action.command === 'fill';
+  const requiresRect = isClickLikeCommand(action.command) || action.command === 'fill';
   const allowDisambiguation =
-    action.command === 'click' ||
-    action.command === 'press' ||
+    isClickLikeCommand(action.command) ||
     action.command === 'fill' ||
     (action.command === 'get' && action.positionals?.[0] === 'text');
   const snapshot = await captureSnapshotForReplay(session, action, logPath, requiresRect, dispatch, sessionStore);
@@ -688,15 +688,10 @@ async function healReplayAction(params: {
     });
     if (!resolved) continue;
     const selectorChain = buildSelectorChainForNode(resolved.node, session.device.platform, {
-      action:
-        action.command === 'click' || action.command === 'press'
-          ? 'click'
-          : action.command === 'fill'
-            ? 'fill'
-            : 'get',
+      action: isClickLikeCommand(action.command) ? 'click' : action.command === 'fill' ? 'fill' : 'get',
     });
     const selectorExpression = selectorChain.join(' || ');
-    if (action.command === 'click' || action.command === 'press') {
+    if (isClickLikeCommand(action.command)) {
       return {
         ...action,
         positionals: [selectorExpression],
@@ -796,7 +791,7 @@ function collectReplaySelectorCandidates(action: SessionAction): string[] {
       : [];
   result.push(...explicitChain);
 
-  if (action.command === 'click' || action.command === 'press') {
+  if (isClickLikeCommand(action.command)) {
     const first = action.positionals?.[0] ?? '';
     if (first && !first.startsWith('@')) {
       result.push(action.positionals.join(' '));
@@ -992,8 +987,8 @@ function parseReplayScriptLine(line: string): SessionAction | null {
     return action;
   }
 
-  if (command === 'click' || command === 'press') {
-    const parsed = parseReplayPressFlags(args);
+  if (isClickLikeCommand(command)) {
+    const parsed = parseReplaySeriesFlags(command, args);
     Object.assign(action.flags, parsed.flags);
     if (parsed.positionals.length === 0) return action;
     const target = parsed.positionals[0];
@@ -1052,7 +1047,7 @@ function parseReplayScriptLine(line: string): SessionAction | null {
   }
 
   if (command === 'swipe') {
-    const parsed = parseReplaySwipeFlags(args);
+    const parsed = parseReplaySeriesFlags(command, args);
     Object.assign(action.flags, parsed.flags);
     action.positionals = parsed.positionals;
     return action;
@@ -1062,81 +1057,6 @@ function parseReplayScriptLine(line: string): SessionAction | null {
   return action;
 }
 
-function parseReplayPressFlags(args: string[]): { positionals: string[]; flags: SessionAction['flags'] } {
-  const positionals: string[] = [];
-  const flags: SessionAction['flags'] = {};
-  for (let index = 0; index < args.length; index += 1) {
-    const token = args[index];
-    if (token === '--tap-batch') {
-      flags.tapBatch = true;
-      continue;
-    }
-    if (token === '--count' && index + 1 < args.length) {
-      const parsed = parseNonNegativeIntToken(args[index + 1]);
-      if (parsed !== null) flags.count = parsed;
-      index += 1;
-      continue;
-    }
-    if (token === '--interval-ms' && index + 1 < args.length) {
-      const parsed = parseNonNegativeIntToken(args[index + 1]);
-      if (parsed !== null) flags.intervalMs = parsed;
-      index += 1;
-      continue;
-    }
-    if (token === '--hold-ms' && index + 1 < args.length) {
-      const parsed = parseNonNegativeIntToken(args[index + 1]);
-      if (parsed !== null) flags.holdMs = parsed;
-      index += 1;
-      continue;
-    }
-    if (token === '--jitter-px' && index + 1 < args.length) {
-      const parsed = parseNonNegativeIntToken(args[index + 1]);
-      if (parsed !== null) flags.jitterPx = parsed;
-      index += 1;
-      continue;
-    }
-    positionals.push(token);
-  }
-  return { positionals, flags };
-}
-
-function parseReplaySwipeFlags(args: string[]): { positionals: string[]; flags: SessionAction['flags'] } {
-  const positionals: string[] = [];
-  const flags: SessionAction['flags'] = {};
-  for (let index = 0; index < args.length; index += 1) {
-    const token = args[index];
-    if (token === '--count' && index + 1 < args.length) {
-      const parsed = parseNonNegativeIntToken(args[index + 1]);
-      if (parsed !== null) flags.count = parsed;
-      index += 1;
-      continue;
-    }
-    if (token === '--pause-ms' && index + 1 < args.length) {
-      const parsed = parseNonNegativeIntToken(args[index + 1]);
-      if (parsed !== null) flags.pauseMs = parsed;
-      index += 1;
-      continue;
-    }
-    if (token === '--pattern' && index + 1 < args.length) {
-      const pattern = args[index + 1];
-      if (pattern === 'one-way' || pattern === 'ping-pong') {
-        flags.pattern = pattern;
-      }
-      index += 1;
-      continue;
-    }
-    positionals.push(token);
-  }
-  return { positionals, flags };
-}
-
-function parseNonNegativeIntToken(token: string | undefined): number | null {
-  if (!token) return null;
-  const value = Number(token);
-  if (!Number.isFinite(value) || value < 0) return null;
-  return Math.floor(value);
-}
-
 function isNumericToken(token: string | undefined): token is string {
   if (!token) return false;
   return !Number.isNaN(Number(token));
@@ -1205,49 +1125,23 @@ function formatReplayActionLine(action: SessionAction): string {
       parts.push('-d', String(action.flags.snapshotDepth));
     }
     if (action.flags?.snapshotScope) {
-      parts.push('-s', formatReplayArg(action.flags.snapshotScope));
+      parts.push('-s', formatScriptArg(action.flags.snapshotScope));
     }
     if (action.flags?.snapshotRaw) parts.push('--raw');
     return parts.join(' ');
   }
   if (action.command === 'open') {
     for (const positional of action.positionals ?? []) {
-      parts.push(formatReplayArg(positional));
+      parts.push(formatScriptArg(positional));
     }
     if (action.flags?.relaunch) {
       parts.push('--relaunch');
     }
     return parts.join(' ');
   }
   for (const positional of action.positionals ?? []) {
-    parts.push(formatReplayArg(positional));
+    parts.push(formatScriptArg(positional));
   }
-  appendReplaySeriesFlags(parts, action);
+  appendScriptSeriesFlags(parts, action);
   return parts.join(' ');
 }
-
-function appendReplaySeriesFlags(parts: string[], action: SessionAction): void {
-  const flags = action.flags ?? {};
-  if (action.command === 'click' || action.command === 'press') {
-    if (typeof flags.count === 'number') parts.push('--count', String(flags.count));
-    if (typeof flags.intervalMs === 'number') parts.push('--interval-ms', String(flags.intervalMs));
-    if (typeof flags.holdMs === 'number') parts.push('--hold-ms', String(flags.holdMs));
-    if (typeof flags.jitterPx === 'number') parts.push('--jitter-px', String(flags.jitterPx));
-    if (flags.tapBatch === true) parts.push('--tap-batch');
-    return;
-  }
-  if (action.command === 'swipe') {
-    if (typeof flags.count === 'number') parts.push('--count', String(flags.count));
-    if (typeof flags.pauseMs === 'number') parts.push('--pause-ms', String(flags.pauseMs));
-    if (flags.pattern === 'one-way' || flags.pattern === 'ping-pong') {
-      parts.push('--pattern', flags.pattern);
-    }
-  }
-}
-
-function formatReplayArg(value: string): string {
-  const trimmed = value.trim();
-  if (trimmed.startsWith('@')) return trimmed;
-  if (/^-?\d+(\.\d+)?$/.test(trimmed)) return trimmed;
-  return JSON.stringify(trimmed);
-}