@swmansion/argent 0.31.1-next.9 → 0.31.2-next.0

package/dist/ios-device-runner/ArgentRunner/ArgentRunnerUITests/ArgentRunnerSession+Commands.swift

@@ -159,6 +159,8 @@ extension ArgentRunnerSession {
             return performLongPress(request, on: app)
         case .drag:
             return performDrag(request, on: app)
+        case .touchPaths:
+            return performTouchPaths(request, on: app)
         case .type:
             return performType(request, on: app)
         case .keyboardReturn:

package/dist/ios-device-runner/ArgentRunner/ArgentRunnerUITests/ArgentRunnerSession+Gestures.swift

@@ -122,6 +122,102 @@ extension ArgentRunnerSession {
         return .success(MessagePayload(message: "dragged"))
     }
 
+    /// Most fingers one `touchPaths` command plays. A hand has five.
+    private static let maxTouchFingers = 5
+    /// Longest `touchPaths` gesture, comfortably inside the command budget.
+    private static let maxTouchPathsMs = 30_000.0
+
+    /// Plays one path per finger, all at once: pinches, rotations, and any
+    /// single path with waypoints. XCUICoordinate only draws one straight drag,
+    /// so this goes through XCTest's event synthesizer (ArgentTouchSynthesizer).
+    ///
+    /// Wire points are absolute screen points, the same space `tap` and `drag`
+    /// take, and times are measured from the start of the gesture. A finger
+    /// whose first waypoint is later than 0 touches down late, which is how a
+    /// second finger joins a gesture already under way.
+    func performTouchPaths(_ request: CommandRequest, on app: XCUIApplication)
+        -> Envelope
+    {
+        guard let fingers = request.fingers,
+            (1...Self.maxTouchFingers).contains(fingers.count)
+        else {
+            return .failure(
+                .invalidRequest,
+                "touchPaths requires between 1 and \(Self.maxTouchFingers) fingers"
+            )
+        }
+
+        for (index, finger) in fingers.enumerated() {
+            guard !finger.points.isEmpty else {
+                return .failure(
+                    .invalidRequest,
+                    "touchPaths finger \(index) has no waypoints"
+                )
+            }
+
+            var previousMs = 0.0
+
+            for point in finger.points {
+                guard point.x.isFinite, point.y.isFinite, point.tMs.isFinite,
+                    point.tMs >= previousMs, point.tMs <= Self.maxTouchPathsMs
+                else {
+                    return .failure(
+                        .invalidRequest,
+                        "touchPaths finger \(index) needs finite waypoints whose times do not decrease and stay within \(Int(Self.maxTouchPathsMs)) ms"
+                    )
+                }
+
+                previousMs = point.tMs
+            }
+        }
+
+        if let reason = ArgentTouchSynthesizer.unavailabilityReason() {
+            return .failure(
+                .unsupportedOperation,
+                "multi-finger touch is unavailable here: \(reason)",
+                hint:
+                    "Use tap, swipe or drag for a single finger, or drive the app's own zoom controls."
+            )
+        }
+
+        // The orientation the app draws in, not the way the phone is held: a
+        // portrait-only app on a phone turned sideways is still portrait. Wire
+        // points are in the app's space, which is the panel's own only in
+        // portrait. Other orientations have not been checked on hardware, and
+        // a touch that lands somewhere else without an error is worse than a
+        // refusal.
+        switch ArgentTouchSynthesizer.interfaceOrientation(ofApplication: app) {
+        case .portrait:
+            break
+        case .unknown:
+            return .failure(
+                .unsupportedOperation,
+                "touchPaths could not read the app's interface orientation",
+                hint:
+                    "Use tap, swipe or drag for a single finger, or drive the app's own zoom controls."
+            )
+        default:
+            return .failure(
+                .unsupportedOperation,
+                "touchPaths has only been verified with the app drawn in portrait",
+                hint: "Turn the phone upright so the app draws in portrait, then retry."
+            )
+        }
+
+        let waypoints = fingers.map { finger in
+            finger.points.map { [$0.x, $0.y, $0.tMs / 1000] as [NSNumber] }
+        }
+
+        if let failure = ArgentTouchSynthesizer.synthesizeFingers(
+            waypoints,
+            interfaceOrientation: .portrait
+        ) {
+            return .failure(.commandFailed, failure)
+        }
+
+        return .success(MessagePayload(message: "touched"))
+    }
+
     /// Reports the interaction viewport, the rectangle that normalized 0-1
     /// coordinates map into.
     func appViewport(_ app: XCUIApplication) -> Envelope {

package/dist/ios-device-runner/ArgentRunner/ArgentRunnerUITests/ArgentRunnerUITests-Bridging-Header.h

@@ -1 +1,2 @@
 #import "ArgentExceptionGuard.h"
+#import "ArgentTouchSynthesizer.h"

package/dist/ios-device-runner/ArgentRunner/ArgentRunnerUITests/ArgentTouchSynthesizer.h

@@ -0,0 +1,40 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Multi-finger touch synthesis through XCTest's own event classes.
+///
+/// The public XCUICoordinate API can drive one finger along one straight
+/// press-then-drag. Pinches, rotations and any path with waypoints need several
+/// fingers moving at once, which XCTest builds internally from
+/// XCPointerEventPath and XCSynthesizedEventRecord. Those classes are not in
+/// any public header, so they are looked up by name at runtime: nothing links
+/// against a private symbol, and an Xcode that renames or drops one makes
+/// `unavailabilityReason` answer instead of the runner failing to load.
+@interface ArgentTouchSynthesizer : NSObject
+
+/// nil when every class and selector this needs is present, otherwise a
+/// sentence naming what is missing.
++ (NSString *_Nullable)unavailabilityReason;
+
+/// The orientation the app's interface is drawn in, which can differ from the
+/// way the phone is held (a portrait-only app on a phone turned sideways).
+/// UIInterfaceOrientationUnknown when this XCTest cannot say.
++ (UIInterfaceOrientation)interfaceOrientationOfApplication:(id)application;
+
+/// Plays every finger at once as one event record, and returns once the last
+/// finger has lifted. Each finger is an array of `[x, y, seconds]` waypoints:
+/// points in the panel's own portrait space, and the time since the gesture
+/// started. The finger touches down at its first waypoint, moves through the
+/// rest in order, and lifts a hair after its last. Waypoint times must not
+/// decrease.
+///
+/// Returns nil on success, otherwise "Name: reason" for the failure or the
+/// NSException XCTest threw (Swift cannot catch those).
++ (NSString *_Nullable)synthesizeFingers:
+            (NSArray<NSArray<NSArray<NSNumber *> *> *> *)fingers
+                      interfaceOrientation:(UIInterfaceOrientation)orientation;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/dist/ios-device-runner/ArgentRunner/ArgentRunnerUITests/ArgentTouchSynthesizer.m

@@ -0,0 +1,149 @@
+#import "ArgentTouchSynthesizer.h"
+
+#import <XCTest/XCTest.h>
+#import <objc/message.h>
+
+/// The selectors used on XCTest's private classes, declared as protocols so the
+/// compiler can check the calls without a class symbol to link against.
+@protocol ArgentPointerEventPath <NSObject>
+- (instancetype)initForTouchAtPoint:(CGPoint)point offset:(NSTimeInterval)offset;
+- (void)moveToPoint:(CGPoint)point atOffset:(NSTimeInterval)offset;
+- (void)liftUpAtOffset:(NSTimeInterval)offset;
+@end
+
+@protocol ArgentSynthesizedEventRecord <NSObject>
+- (instancetype)initWithName:(NSString *)name
+                   displayID:(NSUInteger)displayID
+        interfaceOrientation:(UIInterfaceOrientation)orientation;
+- (instancetype)initWithName:(NSString *)name
+        interfaceOrientation:(UIInterfaceOrientation)orientation;
+- (void)addPointerEventPath:(id<ArgentPointerEventPath>)path;
+- (BOOL)synthesizeWithError:(NSError *_Nullable *_Nullable)error;
+@end
+
+/// How long after its last waypoint a finger lifts, so the move and the lift
+/// are two distinct events in the stream.
+static const NSTimeInterval kLiftDelay = 0.01;
+
+@implementation ArgentTouchSynthesizer
+
++ (NSString *_Nullable)unavailabilityReason {
+  Class pathClass = NSClassFromString(@"XCPointerEventPath");
+  Class recordClass = NSClassFromString(@"XCSynthesizedEventRecord");
+
+  if (pathClass == Nil || recordClass == Nil) {
+    return @"this Xcode's XCTest has no XCPointerEventPath/XCSynthesizedEventRecord";
+  }
+
+  SEL pathSelectors[] = {
+      @selector(initForTouchAtPoint:offset:),
+      @selector(moveToPoint:atOffset:),
+      @selector(liftUpAtOffset:),
+  };
+  for (size_t i = 0; i < sizeof(pathSelectors) / sizeof(SEL); i++) {
+    if (![pathClass instancesRespondToSelector:pathSelectors[i]]) {
+      return [NSString stringWithFormat:@"XCPointerEventPath no longer responds to %@",
+                                        NSStringFromSelector(pathSelectors[i])];
+    }
+  }
+
+  // Either record initializer will do; synthesizeFingers picks the newer one.
+  if (![recordClass instancesRespondToSelector:@selector(initWithName:displayID:interfaceOrientation:)] &&
+      ![recordClass instancesRespondToSelector:@selector(initWithName:interfaceOrientation:)]) {
+    return @"XCSynthesizedEventRecord has neither initWithName:displayID:interfaceOrientation: "
+           @"nor initWithName:interfaceOrientation:";
+  }
+
+  SEL recordSelectors[] = {
+      @selector(addPointerEventPath:),
+      @selector(synthesizeWithError:),
+  };
+  for (size_t i = 0; i < sizeof(recordSelectors) / sizeof(SEL); i++) {
+    if (![recordClass instancesRespondToSelector:recordSelectors[i]]) {
+      return [NSString stringWithFormat:@"XCSynthesizedEventRecord no longer responds to %@",
+                                        NSStringFromSelector(recordSelectors[i])];
+    }
+  }
+
+  return nil;
+}
+
++ (UIInterfaceOrientation)interfaceOrientationOfApplication:(id)application {
+  SEL selector = NSSelectorFromString(@"interfaceOrientation");
+  if (![application respondsToSelector:selector]) {
+    return UIInterfaceOrientationUnknown;
+  }
+  return ((UIInterfaceOrientation(*)(id, SEL))objc_msgSend)(application, selector);
+}
+
+/// The main screen's display id, which the display-aware record initializer
+/// routes touches by. nil when XCUIScreen does not expose one.
++ (NSNumber *_Nullable)mainDisplayID {
+  XCUIScreen *screen = XCUIScreen.mainScreen;
+  if (![screen respondsToSelector:NSSelectorFromString(@"displayID")]) {
+    return nil;
+  }
+  id value = [screen valueForKey:@"displayID"];
+  return [value isKindOfClass:NSNumber.class] ? value : nil;
+}
+
+/// A new event record. Prefers the display-aware initializer, which newer
+/// XCTest uses for its own touches, and falls back to the older one when this
+/// XCTest or the screen cannot supply a display id.
++ (id<ArgentSynthesizedEventRecord>)recordWithInterfaceOrientation:
+    (UIInterfaceOrientation)orientation {
+  Class recordClass = NSClassFromString(@"XCSynthesizedEventRecord");
+  NSString *name = @"argent-touch-paths";
+  NSNumber *displayID = [self mainDisplayID];
+
+  if (displayID != nil &&
+      [recordClass instancesRespondToSelector:@selector(initWithName:displayID:interfaceOrientation:)]) {
+    return [[recordClass alloc] initWithName:name
+                                   displayID:displayID.unsignedIntegerValue
+                        interfaceOrientation:orientation];
+  }
+
+  return [[recordClass alloc] initWithName:name interfaceOrientation:orientation];
+}
+
++ (NSString *_Nullable)synthesizeFingers:
+            (NSArray<NSArray<NSArray<NSNumber *> *> *> *)fingers
+                      interfaceOrientation:(UIInterfaceOrientation)orientation {
+  NSString *unavailable = [self unavailabilityReason];
+  if (unavailable != nil) {
+    return unavailable;
+  }
+
+  @try {
+    id<ArgentSynthesizedEventRecord> record = [self recordWithInterfaceOrientation:orientation];
+
+    for (NSArray<NSArray<NSNumber *> *> *waypoints in fingers) {
+      NSArray<NSNumber *> *first = waypoints.firstObject;
+      id<ArgentPointerEventPath> path = [[NSClassFromString(@"XCPointerEventPath") alloc]
+          initForTouchAtPoint:CGPointMake(first[0].doubleValue, first[1].doubleValue)
+                       offset:first[2].doubleValue];
+
+      for (NSUInteger i = 1; i < waypoints.count; i++) {
+        NSArray<NSNumber *> *waypoint = waypoints[i];
+        [path moveToPoint:CGPointMake(waypoint[0].doubleValue, waypoint[1].doubleValue)
+                 atOffset:waypoint[2].doubleValue];
+      }
+
+      [path liftUpAtOffset:waypoints.lastObject[2].doubleValue + kLiftDelay];
+      [record addPointerEventPath:path];
+    }
+
+    NSError *error = nil;
+    if (![record synthesizeWithError:&error]) {
+      return [NSString stringWithFormat:@"XCTest refused the touch events: %@",
+                                        error.localizedDescription ?: @"no error given"];
+    }
+
+    return nil;
+  } @catch (NSException *exception) {
+    return [NSString stringWithFormat:@"%@: %@", exception.name ?: @"NSException",
+                                      exception.reason ?: @"unhandled Objective-C exception"];
+  }
+}
+
+@end

package/dist/ios-device-runner/ArgentRunner/ArgentRunnerUITests/RunnerProtocol.swift

@@ -13,6 +13,7 @@ enum CommandKind: String, Codable {
     case tap
     case longPress
     case drag
+    case touchPaths
     case type
     case keyboardReturn
     case keyboardDelete
@@ -30,8 +31,8 @@ extension CommandKind {
         switch self {
         case .status, .viewport, .snapshot, .screenshot:
             return true
-        case .tap, .longPress, .drag, .type, .keyboardReturn, .keyboardDelete,
-            .button, .shutdown:
+        case .tap, .longPress, .drag, .touchPaths, .type, .keyboardReturn,
+            .keyboardDelete, .button, .shutdown:
             return false
         }
     }
@@ -41,8 +42,8 @@ extension CommandKind {
     /// runner's own host app.
     var requiresAppBundleId: Bool {
         switch self {
-        case .viewport, .tap, .longPress, .drag, .type, .keyboardReturn,
-            .keyboardDelete, .snapshot:
+        case .viewport, .tap, .longPress, .drag, .touchPaths, .type,
+            .keyboardReturn, .keyboardDelete, .snapshot:
             return true
         case .status, .button, .screenshot, .shutdown:
             return false
@@ -73,7 +74,7 @@ extension CommandKind {
         // never reports quiescent stalls the wait until XCTest gives up and
         // synthesizes the event anyway, and a shorter budget would abandon a
         // command that still completes.
-        case .tap, .longPress, .drag: return 75
+        case .tap, .longPress, .drag, .touchPaths: return 75
         default: return 30
         }
     }
@@ -90,6 +91,20 @@ enum DeviceButton: String, Codable {
     case actionButton
 }
 
+/// One point on a finger's path: an absolute point in the app's coordinate
+/// space, and the time since the gesture started.
+struct TouchWaypoint: Codable {
+    let x: Double
+    let y: Double
+    let tMs: Double
+}
+
+/// One finger of a `touchPaths` command: it touches down at the first
+/// waypoint, moves through the rest in order, and lifts after the last.
+struct TouchFinger: Codable {
+    let points: [TouchWaypoint]
+}
+
 struct CommandRequest: Codable {
     let command: CommandKind
     let commandId: String?
@@ -119,6 +134,8 @@ struct CommandRequest: Codable {
     /// velocity is near zero and the scroll view does not fling. Mirrors the
     /// simulator's ease-out `settle` swipe.
     let settle: Bool?
+    /// `touchPaths`: one path per finger, all played at once.
+    let fingers: [TouchFinger]?
     /// `type`: the text delivered to the focused input.
     let text: String?
     /// `button`: which hardware button to press.

package/dist/mcp-server.mjs

@@ -26024,6 +26024,9 @@ var FAILURE_COMMANDS = [
   "hdc",
   "deveco_emulator",
   "xcrun_simctl",
+  // The `sim-remote` CLI, which stands in for simctl (and more) against a
+  // remote simulator.
+  "sim_remote",
   "xctrace",
   "native_devtools",
   "android_devtools",
@@ -28888,6 +28891,9 @@ function toMcpToolList(tools) {
   return tools.filter((t) => !t.hideFromMcp).map(toMcpTool);
 }
 
+// ../argent-mcp/src/instructions.ts
+var SERVER_INSTRUCTIONS = "Argent \u2014 iOS Simulator, Android Emulator, and Chromium app control for interacting, testing, profiling and debugging mobile and Chromium applications. Interaction tools return the screen after the action: a screenshot plus the accessibility element tree with normalized tap frames. Take coordinates from that tree; call describe (or debugger-component-tree) only when no fresh tree is available \u2014 never guess coordinates from pixels. Do not stop simulator servers when a task finishes: the next task reuses them. Call stop-all-simulator-servers when the user asks to clean up or ends the session, or when a skill tells you to recycle a device's services, always with devices: [...] naming the devices this session used. Never stop a Metro the user started unless they ask. One tool-server is shared by every agent using this argent install, so an unscoped call tears down their devices too \u2014 reserve it for a deliberate machine-wide cleanup. Full guidance is in the argent rule loaded from .claude/rules/argent.md.";
+
 // ../argent-mcp/src/installed-version.ts
 import * as fs11 from "node:fs";
 import * as path16 from "node:path";
@@ -29148,7 +29154,7 @@ ${desc}` }];
     { name: "argent", version: getInstalledVersion() },
     {
       capabilities: { tools: {} },
-      instructions: "Argent \u2014 iOS Simulator, Android Emulator, and Chromium app control for interacting, testing, profiling and debugging mobile and Chromium applications. Interaction tools return the screen after the action: a screenshot plus the accessibility element tree with normalized tap frames. Take coordinates from that tree; call describe (or debugger-component-tree) only when no fresh tree is available \u2014 never guess coordinates from pixels. Do not stop simulator servers when a task finishes: the next task reuses them. Call stop-all-simulator-servers when the user asks to clean up or ends the session, or when a skill tells you to recycle a device's services, always with devices: [...] naming the devices this session used. Never stop a Metro the user started unless they ask. One tool-server is shared by every agent using this argent install, so an unscoped call tears down their devices too \u2014 reserve it for a deliberate machine-wide cleanup. Full guidance is in the argent rule loaded from .claude/rules/argent.md."
+      instructions: SERVER_INSTRUCTIONS
     }
   );
   server.setRequestHandler(ListToolsRequestSchema, async () => {

package/dist/tool-args.generated.d.ts

@@ -792,9 +792,9 @@ export interface ArgentToolArgs {
         udid: string;
         /** Auto-stop cap in seconds (default 180, max 600). Set it to slightly more than the interaction you plan to capture. */
         timeLimitSeconds?: number;
-        /** Default true. Collapse stretches where the screen does not change: the first second of each still stretch is kept, then unchanged frames are dropped until something moves again, so a long recording with brief activity comes back short instead of full of dead air. The returned durationMs is the trimmed length; wallClockMs/trimmedMs report what was removed. Set false to keep a faithful real-time recording. */
+        /** Default true. Collapse stretches where the screen does not change: the first second of each still stretch is kept, then unchanged frames are dropped until something moves again, so a long recording with brief activity comes back short instead of full of dead air (on a remote simulator the still stretches are removed whole). The returned durationMs is the trimmed length; wallClockMs/trimmedMs report what was removed. Set false to keep a faithful real-time recording. */
         trimStatic?: boolean;
-        /** Default true. Draw simulator-server's touch visualizer into the recording: a pulse marks each tap, a comet trail follows swipes and drags, and paired markers show two-finger pinch/rotate, so the video makes clear where every interaction landed. Set false to record the raw screen with no overlay. */
+        /** Default true. Draw simulator-server's touch visualizer into the recording: a pulse marks each tap, a comet trail follows swipes and drags, and paired markers show two-finger pinch/rotate, so the video makes clear where every interaction landed. On remote (`remote:`) simulators the overlay is drawn on the runner and is also visible in the live stream until the recording stops. Set false to record the raw screen with no overlay. */
         showTouches?: boolean;
     };
     "screen-recording-stop": {