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

package/dist/tool-server.cjs

@@ -144547,6 +144547,12 @@ function toYamlStep(step) {
       const body = step.selector ? selectorToYaml(step.selector) : { x: step.x, y: step.y };
       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 +144802,7 @@ var STEP_DIRECTIVE_KEYS = [
   "run",
   "tool",
   "tap",
+  "long-press",
   "type",
   "await",
   "assert",
@@ -144803,6 +144810,35 @@ 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 fromYamlStep(raw) {
   const entry = raw;
   const kinds = STEP_DIRECTIVE_KEYS.filter((k) => k in entry);
@@ -144845,6 +144881,9 @@ function fromYamlStep(raw) {
     }
     return { kind: "tap", selector: parseSelector(body, "tap") };
   }
+  if ("long-press" in raw) {
+    return parseLongPress(raw["long-press"], raw);
+  }
   if ("type" in raw) {
     const body = raw.type;
     if (!body || typeof body !== "object") badEntry(raw, "type needs { into, text }");
@@ -145776,6 +145815,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 +146063,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 +146072,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":
@@ -146061,6 +146104,33 @@ async function runTap(env, target) {
   await invokeOnDevice(env, "gesture-tap", point);
   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) {
   const frame = await waitForFrame(env, step.into);
   if (frame === "aborted") return ABORTED_OUTCOME;
@@ -148495,8 +148565,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 +148722,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 +148819,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.4",
   "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` or `- tap: { x: 0.5, y: 0.57 }`                                                           | tap an element by selector (auto-waits), or a raw normalized point      |
+| `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: