@swmansion/argent 0.15.1-next.3 → 0.15.1-next.5

package/dist/tool-server.cjs

@@ -126102,7 +126102,10 @@ var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
 var zodSchema16 = external_exports.object({
   udid: external_exports.string().describe("Target device id from `list-devices` (iOS UDID, Android serial, or Chromium id)."),
   x: external_exports.number().describe("Normalized horizontal position 0.0\u20131.0 (left=0, right=1), not pixels"),
-  y: external_exports.number().describe("Normalized vertical position 0.0\u20131.0 (top=0, bottom=1), not pixels")
+  y: external_exports.number().describe("Normalized vertical position 0.0\u20131.0 (top=0, bottom=1), not pixels"),
+  clickCount: external_exports.number().int().min(1).max(10).optional().describe(
+    "Number of taps/clicks dispatched as ONE multi-tap gesture (2 = double-tap / double-click). The taps land inside the OS double-tap window; on Chromium each click carries an escalating CDP clickCount so dblclick actually fires. Default 1."
+  )
 });
 var capability8 = {
   apple: { simulator: true, device: true },
@@ -126110,19 +126113,25 @@ var capability8 = {
   android: { emulator: true, device: true, unknown: true },
   chromium: { app: true }
 };
-async function tapChromium(api, x, y) {
+var TAP_HOLD_MS = 50;
+var MULTI_TAP_GAP_MS = 100;
+async function tapChromium(api, x, y, clickCount) {
   const vp = api.getViewport();
   const pxX = Math.max(0, Math.min(vp.width, x * vp.width));
   const pxY = Math.max(0, Math.min(vp.height, y * vp.height));
   await api.dispatchMouseEvent({ type: "mouseMoved", x: pxX, y: pxY });
-  await api.dispatchMouseEvent({ type: "mousePressed", x: pxX, y: pxY, clickCount: 1 });
-  await sleep2(50);
-  await api.dispatchMouseEvent({ type: "mouseReleased", x: pxX, y: pxY, clickCount: 1 });
+  for (let i = 1; i <= clickCount; i++) {
+    if (i > 1) await sleep2(MULTI_TAP_GAP_MS);
+    await api.dispatchMouseEvent({ type: "mousePressed", x: pxX, y: pxY, clickCount: i });
+    await sleep2(TAP_HOLD_MS);
+    await api.dispatchMouseEvent({ type: "mouseReleased", x: pxX, y: pxY, clickCount: i });
+  }
 }
 var gestureTapTool = {
   id: "gesture-tap",
   description: `Press the device screen (iOS simulator, Android emulator, or Chromium app) at normalized coordinates: x and y are fractions of screen width and height in 0.0\u20131.0 (not pixels).
 Sends a Down event followed by an Up event at the same point. For Chromium, this dispatches a CDP mouse-press/release on the renderer.
+Set clickCount: 2 for a double-tap / double-click \u2014 the taps are dispatched as one gesture with proper click counting, which two separate tap calls cannot guarantee.
 Use when you need to tap a button, link, or any tappable element on the screen.
 Returns { tapped: true, timestampMs }. Fails if the simulator-server / emulator backend / Chromium CDP is not reachable for the given device.
 Before tapping, determine the correct coordinates by using discovery tools \u2014 pick by platform: iOS / Android use \`describe\`, \`native-describe-screen\`, or \`debugger-component-tree\`; Chromium uses \`describe\` (the DOM walker), since the native and RN-specific discovery tools don't apply. More information in \`argent-device-interact\` skill`,
@@ -126140,29 +126149,33 @@ Before tapping, determine the correct coordinates by using discovery tools \u201
   async execute(services, params) {
     const device = resolveDevice(params.udid);
     const timestampMs = Date.now();
+    const clickCount = params.clickCount ?? 1;
     if (device.platform === "chromium") {
       const chromium = services.chromium;
-      await tapChromium(chromium, params.x, params.y);
+      await tapChromium(chromium, params.x, params.y, clickCount);
       return { tapped: true, timestampMs };
     }
     const api = services.simulatorServer;
-    sendCommand(api, {
-      cmd: "touch",
-      type: "Down",
-      x: params.x,
-      y: params.y,
-      second_x: null,
-      second_y: null
-    });
-    await sleep2(50);
-    sendCommand(api, {
-      cmd: "touch",
-      type: "Up",
-      x: params.x,
-      y: params.y,
-      second_x: null,
-      second_y: null
-    });
+    for (let i = 1; i <= clickCount; i++) {
+      if (i > 1) await sleep2(MULTI_TAP_GAP_MS);
+      sendCommand(api, {
+        cmd: "touch",
+        type: "Down",
+        x: params.x,
+        y: params.y,
+        second_x: null,
+        second_y: null
+      });
+      await sleep2(TAP_HOLD_MS);
+      sendCommand(api, {
+        cmd: "touch",
+        type: "Up",
+        x: params.x,
+        y: params.y,
+        second_x: null,
+        second_y: null
+      });
+    }
     return { tapped: true, timestampMs };
   }
 };
@@ -133567,7 +133580,7 @@ a prior tap), use individual tool calls instead.
 
 Allowed tools and their args (udid is auto-injected, do NOT include it in args):
 
-  gesture-tap:    { x: number, y: number }                                                                              [ios/android/chromium]
+  gesture-tap:    { x: number, y: number, clickCount?: number }                                                        [ios/android/chromium]
   gesture-swipe:  { fromX: number, fromY: number, toX: number, toY: number, durationMs?: number }                       [ios/android]
   gesture-scroll: { x: number, y: number, deltaX?: number, deltaY?: number, durationMs?: number }                       [chromium only]
   gesture-drag:   { fromX: number, fromY: number, toX: number, toY: number, durationMs?: number }                       [chromium only]
@@ -144544,9 +144557,20 @@ function toYamlStep(step) {
     case "run":
       return { run: step.flow };
     case "tap": {
-      const body = step.selector ? selectorToYaml(step.selector) : { x: step.x, y: step.y };
+      if (step.selector) {
+        const sel = selectorToYaml(step.selector);
+        return { tap: step.times !== void 0 ? { on: sel, times: step.times } : sel };
+      }
+      const body = { x: step.x, y: step.y };
+      if (step.times !== void 0) body.times = step.times;
       return { tap: body };
     }
+    case "long-press": {
+      const sel = selectorToYaml(step.selector);
+      return {
+        "long-press": step.duration !== void 0 ? { on: sel, duration: step.duration } : sel
+      };
+    }
     case "type": {
       const body = {
         into: selectorToYaml(step.into),
@@ -144796,6 +144820,7 @@ var STEP_DIRECTIVE_KEYS = [
   "run",
   "tool",
   "tap",
+  "long-press",
   "type",
   "await",
   "assert",
@@ -144803,6 +144828,79 @@ var STEP_DIRECTIVE_KEYS = [
   "scroll-to",
   "snapshot"
 ];
+function parseLongPress(body, entry) {
+  const obj = body !== null && typeof body === "object" ? body : {};
+  if (obj.on !== void 0 || obj.duration !== void 0) {
+    if (obj.text !== void 0 || obj.id !== void 0 || obj.identifier !== void 0 || obj.role !== void 0) {
+      badEntry(
+        entry,
+        'the long-press options form takes a nested selector \u2014 e.g. long-press: { on: { text: "Row" }, duration: 1200 }'
+      );
+    }
+    if (!Object.keys(obj).every((k) => k === "on" || k === "duration")) {
+      badEntry(entry, "the long-press options form accepts only { on, duration }");
+    }
+    if (obj.on === void 0) {
+      badEntry(entry, 'long-press needs a target \u2014 e.g. long-press: { on: "Row", duration: 1200 }');
+    }
+    const step = { kind: "long-press", selector: parseSelector(obj.on, "long-press.on") };
+    if (obj.duration !== void 0) {
+      if (typeof obj.duration !== "number" || !Number.isFinite(obj.duration) || obj.duration <= 0) {
+        badEntry(
+          entry,
+          "long-press.duration needs a positive number of milliseconds (e.g. `duration: 1200`)"
+        );
+      }
+      step.duration = obj.duration;
+    }
+    return step;
+  }
+  return { kind: "long-press", selector: parseSelector(body, "long-press") };
+}
+function parseTapTimes(raw, entry) {
+  if (raw === void 0) return void 0;
+  if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 1 || raw > 10) {
+    badEntry(entry, "tap.times must be an integer between 1 and 10 (2 = double-tap)");
+  }
+  return raw === 1 ? void 0 : raw;
+}
+function parseTap(body, entry) {
+  const obj = body !== null && typeof body === "object" ? body : {};
+  if (obj.x !== void 0 || obj.y !== void 0) {
+    if (obj.on !== void 0 || obj.text !== void 0 || obj.id !== void 0 || obj.identifier !== void 0 || obj.role !== void 0) {
+      badEntry(entry, "tap takes a selector or x/y coordinates, not both");
+    }
+    if (typeof obj.x !== "number" || typeof obj.y !== "number") {
+      badEntry(entry, "a coordinate tap needs numeric x and y");
+    }
+    if (!Object.keys(obj).every((k) => k === "x" || k === "y" || k === "times")) {
+      badEntry(entry, "a coordinate tap takes only { x, y, times }");
+    }
+    const step = { kind: "tap", x: obj.x, y: obj.y };
+    const times = parseTapTimes(obj.times, entry);
+    if (times !== void 0) step.times = times;
+    return step;
+  }
+  if (obj.on !== void 0 || obj.times !== void 0) {
+    if (obj.text !== void 0 || obj.id !== void 0 || obj.identifier !== void 0 || obj.role !== void 0) {
+      badEntry(
+        entry,
+        'the tap options form takes a nested selector \u2014 e.g. tap: { on: { text: "Photo" }, times: 2 }'
+      );
+    }
+    if (!Object.keys(obj).every((k) => k === "on" || k === "times")) {
+      badEntry(entry, "the tap options form accepts only { on, times }");
+    }
+    if (obj.on === void 0) {
+      badEntry(entry, 'tap with times needs a target \u2014 e.g. tap: { on: "Photo", times: 2 }');
+    }
+    const step = { kind: "tap", selector: parseSelector(obj.on, "tap.on") };
+    const times = parseTapTimes(obj.times, entry);
+    if (times !== void 0) step.times = times;
+    return step;
+  }
+  return { kind: "tap", selector: parseSelector(body, "tap") };
+}
 function fromYamlStep(raw) {
   const entry = raw;
   const kinds = STEP_DIRECTIVE_KEYS.filter((k) => k in entry);
@@ -144828,22 +144926,9 @@ function fromYamlStep(raw) {
   if ("echo" in raw) return { kind: "echo", message: String(raw.echo) };
   if ("launch" in raw) return { kind: "launch", app: parseLaunch(raw.launch) };
   if ("run" in raw) return { kind: "run", flow: String(raw.run) };
-  if ("tap" in raw) {
-    const body = raw.tap;
-    const obj = body !== null && typeof body === "object" ? body : {};
-    if (body !== null && typeof body === "object" && !Array.isArray(body)) {
-      rejectUnknownKeys(raw, obj, [...SELECTOR_KEYS, "x", "y"], "tap");
-    }
-    if (obj.x !== void 0 || obj.y !== void 0) {
-      if (obj.text !== void 0 || obj.id !== void 0 || obj.identifier !== void 0 || obj.role !== void 0) {
-        badEntry(raw, "tap takes a selector or x/y coordinates, not both");
-      }
-      if (typeof obj.x !== "number" || typeof obj.y !== "number") {
-        badEntry(raw, "a coordinate tap needs numeric x and y");
-      }
-      return { kind: "tap", x: obj.x, y: obj.y };
-    }
-    return { kind: "tap", selector: parseSelector(body, "tap") };
+  if ("tap" in raw) return parseTap(raw.tap, raw);
+  if ("long-press" in raw) {
+    return parseLongPress(raw["long-press"], raw);
   }
   if ("type" in raw) {
     const body = raw.type;
@@ -145680,13 +145765,15 @@ If a step was recorded by mistake, edit the .yaml file directly to remove it.`,
       const runTarget = params.command === RUN_TARGET_COMMAND && params.delayMs === void 0 ? await captureRunTarget(session, args) : void 0;
       const strippedArgs = stripDeviceKeys(args);
       const isLaunch = params.command === "restart-app" && params.delayMs === void 0 && typeof strippedArgs.bundleId === "string" && Object.keys(strippedArgs).length === 1;
+      const cc = args.clickCount;
+      const tapTimes = isTap && typeof cc === "number" && Number.isInteger(cc) && cc >= 2 && cc <= 10 ? { times: cc } : {};
       let step;
       let warning;
       if (captured?.selector) {
-        step = { kind: "tap", selector: captured.selector };
+        step = { kind: "tap", selector: captured.selector, ...tapTimes };
         warning = captured.warning;
       } else if (isTap) {
-        step = { kind: "tap", x: args.x, y: args.y };
+        step = { kind: "tap", x: args.x, y: args.y, ...tapTimes };
         warning = captured?.warning;
       } else if (isLaunch) {
         step = { kind: "launch", app: strippedArgs.bundleId };
@@ -145776,6 +145863,8 @@ You can still edit the .yaml file directly afterwards to remove or reorder steps
           return `${n}. run: ${step.flow}`;
         case "tap":
           return `${n}. tap: ${step.selector ? selectorLabel(step.selector) : `(${step.x}, ${step.y})`}`;
+        case "long-press":
+          return `${n}. long-press: ${selectorLabel(step.selector)}`;
         case "type":
           return `${n}. type: ${selectorLabel(step.into)} \u2190 "${step.text}"`;
         case "await":
@@ -146022,7 +146111,7 @@ function offscreenHint(sel) {
   return `no visible element matched selector ${describeSelector(sel)} \u2014 if it is off-screen, add a scroll-to step before this one`;
 }
 async function runDirective(env, step) {
-  if (env.device.platform === "vega" && (step.kind === "tap" || step.kind === "type" || step.kind === "scroll-to")) {
+  if (env.device.platform === "vega" && (step.kind === "tap" || step.kind === "long-press" || step.kind === "type" || step.kind === "scroll-to")) {
     return {
       ok: false,
       reason: `${step.kind} is a touch directive and Vega is remote-driven \u2014 move focus with \`tool: tv-remote\` steps (and type via \`tool: keyboard\`) instead`
@@ -146031,6 +146120,8 @@ async function runDirective(env, step) {
   switch (step.kind) {
     case "tap":
       return runTap(env, step);
+    case "long-press":
+      return runLongPress(env, step);
     case "type":
       return runType(env, step);
     case "await":
@@ -146058,7 +146149,37 @@ async function runTap(env, target) {
   } else {
     return { ok: false, reason: "tap needs a selector or x/y coordinates" };
   }
-  await invokeOnDevice(env, "gesture-tap", point);
+  await invokeOnDevice(env, "gesture-tap", {
+    ...point,
+    ...target.times !== void 0 ? { clickCount: target.times } : {}
+  });
+  return { ok: true };
+}
+var DEFAULT_LONG_PRESS_MS = 800;
+async function runLongPress(env, step) {
+  const frame = await waitForFrame(env, step.selector);
+  if (frame === "aborted") return ABORTED_OUTCOME;
+  if (!frame) {
+    return { ok: false, reason: offscreenHint(step.selector) };
+  }
+  const point = getDescribeTapPoint(frame);
+  const duration3 = step.duration ?? DEFAULT_LONG_PRESS_MS;
+  if (env.device.platform === "chromium") {
+    await invokeOnDevice(env, "gesture-drag", {
+      fromX: point.x,
+      fromY: point.y,
+      toX: point.x,
+      toY: point.y,
+      durationMs: duration3
+    });
+  } else {
+    await invokeOnDevice(env, "gesture-custom", {
+      events: [
+        { type: "Down", x: point.x, y: point.y, delayMs: 0 },
+        { type: "Up", x: point.x, y: point.y, delayMs: duration3 }
+      ]
+    });
+  }
   return { ok: true };
 }
 async function runType(env, step) {
@@ -148495,8 +148616,9 @@ function createRunFlowTool(registry2) {
     id: "flow-execute",
     description: `Run a saved flow from the .argent/flows/ directory.
 Steps run in order: \`launch\` starts an app from scratch (terminate + relaunch) and waits until it is
-ready; \`tool\` calls dispatch through the registry; \`tap\`/\`type\` resolve a selector to an element and
-act on it; \`scroll-to\` scrolls (momentum-free) until a target is visible; \`await\` waits for a UI
+ready; \`tool\` calls dispatch through the registry; \`tap\`/\`long-press\`/\`type\` resolve a selector to an
+element and act on it (\`long-press: { on, duration }\` presses and holds); \`scroll-to\` scrolls
+(momentum-free) until a target is visible; \`await\` waits for a UI
 condition; \`wait\` pauses for a fixed number of milliseconds; \`assert\` checks one now; \`snapshot\`
 diffs a screenshot against a stored baseline (a missing baseline fails the step \u2014 set updateBaselines
 to adopt the current screen); \`echo\` annotates; \`run\` executes a referenced fragment inline.
@@ -148651,6 +148773,8 @@ function stepTarget(step) {
       if (step.selector) return selectorLabel2(step.selector);
       if (step.x !== void 0 && step.y !== void 0) return `(${step.x}, ${step.y})`;
       return void 0;
+    case "long-press":
+      return selectorLabel2(step.selector);
     case "type":
       return `into ${selectorLabel2(step.into)}`;
     case "await":
@@ -148746,6 +148870,7 @@ async function execLeafStep(state3, step, index, sourceFlow) {
       return { ...base, status: r.ok ? "pass" : "error", reason: r.reason };
     }
     case "tap":
+    case "long-press":
     case "type":
     case "await":
     case "assert":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swmansion/argent",
-  "version": "0.15.1-next.3",
+  "version": "0.15.1-next.5",
   "description": "MCP server for iOS Simulator and Android Emulator control",
   "license": "Apache-2.0",
   "repository": {

package/skills/argent-create-flow/SKILL.md

@@ -20,17 +20,18 @@ Both run via `argent flow run <name>` — a fragment simply runs against whateve
 
 Beyond raw `tool:` steps and `echo:`, flows support declarative directives interpreted by the runner (they are **not** agent-callable tools). **Every directive hard-stops the flow on failure**; later steps are reported `skip`.
 
-| Directive   | YAML                                                                                                     | Meaning                                                                 |
-| ----------- | -------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
-| `launch`    | `- launch: com.acme.app` or `- launch: { ios: …, android: … }`                                           | start the app from scratch (terminate + relaunch) and wait until ready  |
-| `tap`       | `- tap: Login` or `- tap: { x: 0.5, y: 0.57 }`                                                           | tap an element by selector (auto-waits), or a raw normalized point      |
-| `type`      | `- type: { into: email, text: "a@b.com" }`                                                               | focus a field, type, then press Enter to submit + dismiss the keyboard  |
-| `scroll-to` | `- scroll-to: "Order #1234"` (scrolls down) or `- scroll-to: { target: …, direction: right, within: … }` | momentum-free scroll until the target is visible                        |
-| `await`     | `- await: { visible: Home }`                                                                             | wait for a UI condition                                                 |
-| `wait`      | `- wait: 500`                                                                                            | pause for a fixed number of milliseconds (last resort — prefer `await`) |
-| `assert`    | `- assert: { visible: Welcome }`                                                                         | check a condition, hard-fail if it never holds                          |
-| `snapshot`  | `- snapshot: home` or `- snapshot: { name: home, maxMismatch: 0.5 }`                                     | diff a screenshot against a stored baseline                             |
-| `run`       | `- run: login`                                                                                           | execute a fragment's steps inline                                       |
+| Directive    | YAML                                                                                                     | Meaning                                                                 |
+| ------------ | -------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
+| `launch`     | `- launch: com.acme.app` or `- launch: { ios: …, android: … }`                                           | start the app from scratch (terminate + relaunch) and wait until ready  |
+| `tap`        | `- tap: Login`, `- tap: { x: 0.5, y: 0.57 }`, `- tap: { on: Login, times: 2 }`                           | tap by selector (auto-waits) or raw point; `times: 2` = double-tap      |
+| `long-press` | `- long-press: Row 3` or `- long-press: { on: <sel>, duration: 1200 }`                                   | press and hold an element (default 800ms; Chromium: mouse press-hold)   |
+| `type`       | `- type: { into: email, text: "a@b.com" }`                                                               | focus a field, type, then press Enter to submit + dismiss the keyboard  |
+| `scroll-to`  | `- scroll-to: "Order #1234"` (scrolls down) or `- scroll-to: { target: …, direction: right, within: … }` | momentum-free scroll until the target is visible                        |
+| `await`      | `- await: { visible: Home }`                                                                             | wait for a UI condition                                                 |
+| `wait`       | `- wait: 500`                                                                                            | pause for a fixed number of milliseconds (last resort — prefer `await`) |
+| `assert`     | `- assert: { visible: Welcome }`                                                                         | check a condition, hard-fail if it never holds                          |
+| `snapshot`   | `- snapshot: home` or `- snapshot: { name: home, maxMismatch: 0.5 }`                                     | diff a screenshot against a stored baseline                             |
+| `run`        | `- run: login`                                                                                           | execute a fragment's steps inline                                       |
 
 ### Selectors
 
@@ -60,7 +61,7 @@ For a custom poll interval or bundleId, drop to an explicit `- tool: await-ui-el
 
 ### TV targets (Vega)
 
-A Vega (Fire TV) device is remote-driven — there is no touch input, so the touch directives (`tap`, `type`, `scroll-to`) fail on it with guidance. Drive focus with `tool: tv-remote` steps and type with `tool: keyboard` instead; everything else (`launch`, `await`, `assert`, `wait`, `snapshot`, `echo`, `run`, selectors) works unchanged — the tree comes from the on-device automation toolkit, which attaches at app launch (the `launch` step waits for it, so a leading `launch` also guarantees selectors resolve).
+A Vega (Fire TV) device is remote-driven — there is no touch input, so the touch directives (`tap`, `long-press`, `type`, `scroll-to`) fail on it with guidance. Drive focus with `tool: tv-remote` steps and type with `tool: keyboard` instead; everything else (`launch`, `await`, `assert`, `wait`, `snapshot`, `echo`, `run`, selectors) works unchanged — the tree comes from the on-device automation toolkit, which attaches at app launch (the `launch` step waits for it, so a leading `launch` also guarantees selectors resolve).
 
 ```yaml
 steps: