agent-device 0.15.2 → 0.16.0

package/dist/src/server.js

@@ -1,2 +1,2 @@
-import{readVersion as e}from"./9671.js";function t(t){if("2.0"!==t.jsonrpc||"string"!=typeof t.method)return r(t.id??null,-32600,"Invalid JSON-RPC request.");if(void 0===t.id)return null;try{var i,s;return i=t.id,s=function(t,r){switch(t){case"initialize":return{protocolVersion:"2025-11-25",capabilities:{tools:{}},serverInfo:{name:"agent-device",version:e()}};case"ping":return{};case"tools/list":return{tools:[{name:"status",description:"Return discovery-only handoff metadata for installing, verifying, and using the agent-device CLI.",inputSchema:{type:"object",properties:{},additionalProperties:!1},outputSchema:{type:"object",properties:{packageName:{type:"string"},installedPackageVersion:{type:"string"},cliCommandName:{type:"string"},installCommand:{type:"string"},verifyCommand:{type:"string"},startingHelpCommand:{type:"string"},supportedTargets:{type:"array",items:{type:"string"}},capabilities:{type:"array",items:{type:"string"}},prerequisites:{type:"array",items:{type:"string"}},docsUrl:{type:"string"},agentDocsUrl:{type:"string"},firstCommands:{type:"array",items:{type:"string"}},automationInterface:{type:"string",const:"cli"},automationNote:{type:"string"},installRequiresHumanApproval:{type:"boolean",const:!0},installSafetyNote:{type:"string"}},required:["packageName","installedPackageVersion","cliCommandName","installCommand","verifyCommand","startingHelpCommand","supportedTargets","capabilities","prerequisites","docsUrl","agentDocsUrl","firstCommands","automationInterface","automationNote","installRequiresHumanApproval","installSafetyNote"],additionalProperties:!1}}]};case"tools/call":var i=r;let s=function(e,t){let r=e[t];if("string"!=typeof r||0===r.length)throw Error(`Expected ${t} to be a non-empty string.`);return r}(function(e){if(!e||"object"!=typeof e||Array.isArray(e))throw Error("Expected object parameters.");return e}(i),"name");try{if("status"===s){let t;return t={packageName:"agent-device",installedPackageVersion:e(),cliCommandName:"agent-device",installCommand:"npm install -g agent-device@latest",verifyCommand:"agent-device --version",startingHelpCommand:"agent-device help workflow",supportedTargets:["ios-simulator","android-emulator","ios-device","android-device","tvos-simulator","macos","linux"],capabilities:["inspect-ui","interact-with-elements","open-apps","install-app","capture-screenshot","accessibility-snapshot","collect-logs","collect-network","collect-performance","record-replay","react-native","expo","android-adb","ios-xcuitest"],prerequisites:["node>=22","xcode-for-ios","android-sdk-adb-for-android","macos-accessibility-permission-for-desktop"],docsUrl:"https://agent-device.dev/",agentDocsUrl:"https://incubator.callstack.com/agent-device/llms-full.txt",firstCommands:["agent-device help workflow","agent-device apps --platform ios","agent-device apps --platform android"],automationInterface:"cli",automationNote:"Device automation happens through the agent-device CLI. This MCP server is discovery-only and does not expose device automation tools.",installRequiresHumanApproval:!0,installSafetyNote:"Agents should not install or update the package unless the human has approved the environment change. If the CLI is missing, ask the human to run the install command, then run the verify command."},{isError:!1,structuredContent:t,content:[{type:"text",text:JSON.stringify(t,null,2)}]}}throw Error(`Unknown tool: ${s}`)}catch(e){return function(e,t=!1){return{isError:t,content:[{type:"text",text:e}]}}(e instanceof Error?e.message:String(e),!0)}return;default:throw new n(`Unsupported MCP method: ${t}`)}}(t.method,t.params),{jsonrpc:"2.0",id:i,result:s}}catch(e){if(e instanceof n)return r(t.id,-32601,e.message);return r(t.id,-32602,e instanceof Error?e.message:String(e))}}function r(e,t,r){return{jsonrpc:"2.0",id:e,error:{code:t,message:r}}}class n extends Error{}async function i(){let e=new s(e=>{let r=function(e){if(Array.isArray(e)){let r=e.flatMap(e=>{var r;return(r=t(e))?[r]:[]});return r.length>0?r:null}return t(e)}(e);r&&a(r)});process.stdin.setEncoding("utf8"),process.stdin.on("data",t=>{try{e.push(t)}catch(e){a({jsonrpc:"2.0",id:null,error:{code:-32700,message:e instanceof Error?e.message:String(e)}})}}),await new Promise(e=>{process.stdin.on("end",e),process.stdin.on("close",e),process.stdin.resume()})}class s{buffer="";sink;constructor(e){this.sink=e}push(e){for(this.buffer+=e;;){let e=this.tryReadLineMessage();if(void 0!==e){this.emit(e);continue}break}}tryReadLineMessage(){let e=this.buffer.indexOf("\n");if(-1===e)return;let t=this.buffer.slice(0,e).trim();return this.buffer=this.buffer.slice(e+1),t.length>0?t:void 0}emit(e){let t=JSON.parse(e);Array.isArray(t),this.sink(t)}}function a(e){process.stdout.write(`${JSON.stringify(e)}
-`)}export{i as runAgentDeviceMcpServer};
+import{createAgentDeviceClient as r}from"./9542.js";import{runCommand as e,isCommandName as t,listMcpToolDefinitions as n}from"./89.js";import{readVersion as i}from"./2099.js";let s=function(n={createClient:r,runCommand:e}){return{execute:async(r,e)=>{var i;if(!t(r))throw Error(`Unknown command tool: ${r}`);let s=n.createClient(function(r){if(!r||"object"!=typeof r||Array.isArray(r))return{};let e=r.stateDir;if(void 0===e)return{};if("string"!=typeof e||0===e.length)throw Error("Expected stateDir to be a non-empty string.");return{stateDir:e}}(e)),o=await n.runCommand(s,r,function(r){if(!r||"object"!=typeof r||Array.isArray(r))return r;let{stateDir:e,...t}=r;return t}(e));return{isError:!1,structuredContent:o,content:[{type:"text",text:"string"==typeof(i=o)?i:JSON.stringify(i,null,2)}]}}}}();async function o(r){if("2.0"!==r.jsonrpc||"string"!=typeof r.method)return u(r.id??null,-32600,"Invalid JSON-RPC request.");if(void 0===r.id)return null;try{var e,t;return e=r.id,t=await a(r.method,r.params),{jsonrpc:"2.0",id:e,result:t}}catch(e){if(e instanceof f)return u(r.id,-32601,e.message);return u(r.id,-32602,e instanceof Error?e.message:String(e))}}async function a(r,e){switch(r){case"initialize":return{protocolVersion:"2025-11-25",capabilities:{tools:{}},serverInfo:{name:"agent-device",version:i()}};case"ping":return{};case"tools/list":return{tools:n().map(r=>{var e;return{name:r.name,description:r.description,inputSchema:{...e=r.inputSchema,properties:{...e.properties,stateDir:{type:"string",description:"Agent-device state directory."}}}}})};case"tools/call":return await c(e);default:throw new f(`Unsupported MCP method: ${r}`)}}async function c(r){let e=function(r){if(!r||"object"!=typeof r||Array.isArray(r))throw Error("Expected object parameters.");return r}(r),t=function(r,e){let t=r[e];if("string"!=typeof t||0===t.length)throw Error(`Expected ${e} to be a non-empty string.`);return t}(e,"name");try{return await s.execute(t,e.arguments)}catch(r){return function(r,e=!1){return{isError:e,content:[{type:"text",text:r}]}}(r instanceof Error?r.message:String(r),!0)}}function u(r,e,t){return{jsonrpc:"2.0",id:r,error:{code:e,message:t}}}class f extends Error{}async function l(){let r=function(r={}){let e=r.handlePayload??p,t=r.write??m,n=Promise.resolve();return{push:r=>{var i;let s=Array.isArray(i=r)?1===i.length?i[0]?.id??null:null:i.id??null;n=n.then(async()=>{let n=await e(r);n&&t(n)}).catch(r=>{t({jsonrpc:"2.0",id:s,error:{code:-32603,message:r instanceof Error?r.message:String(r)}})})},idle:async()=>{await n}}}(),e=new y(e=>{r.push(e)});process.stdin.setEncoding("utf8"),process.stdin.on("data",r=>{try{e.push(r)}catch(r){m({jsonrpc:"2.0",id:null,error:{code:-32700,message:r instanceof Error?r.message:String(r)}})}}),await new Promise(r=>{process.stdin.on("end",r),process.stdin.on("close",r),process.stdin.resume()}),await r.idle()}function p(r){return Array.isArray(r)?d(r):o(r)}async function d(r){let e=[];for(let n of r){var t;e.push(...(t=await o(n))?[t]:[])}return e.length>0?e:null}class y{buffer="";sink;constructor(r){this.sink=r}push(r){for(this.buffer+=r;;){let r=this.tryReadLineMessage();if(void 0!==r){this.emit(r);continue}break}}tryReadLineMessage(){let r=this.buffer.indexOf("\n");if(-1===r)return;let e=this.buffer.slice(0,r).trim();return this.buffer=this.buffer.slice(r+1),e.length>0?e:void 0}emit(r){let e=JSON.parse(r);Array.isArray(e),this.sink(e)}}function m(r){process.stdout.write(`${JSON.stringify(r)}
+`)}export{l as runAgentDeviceMcpServer};

package/ios-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/AgentDeviceRunnerUITests-Bridging-Header.h

@@ -1 +1,2 @@
 #import "RunnerObjCExceptionCatcher.h"
+#import "RunnerSynthesizedGesture.h"

package/ios-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSynthesizedGesture.h

@@ -0,0 +1,19 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RunnerSynthesizedGesture : NSObject
+
++ (NSString * _Nullable)synthesizeTransformWithApplication:(id)application
+                                                         x:(double)x
+                                                         y:(double)y
+                                                        dx:(double)dx
+                                                        dy:(double)dy
+                                                     scale:(double)scale
+                                                   degrees:(double)degrees
+                                                    radius:(double)radius
+                                                durationMs:(double)durationMs;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSynthesizedGesture.m

@@ -0,0 +1,297 @@
+#import "RunnerSynthesizedGesture.h"
+
+#import <CoreGraphics/CoreGraphics.h>
+#import <math.h>
+#import <objc/message.h>
+
+typedef NSInteger (*RunnerMsgSendInteger)(id, SEL);
+typedef id (*RunnerMsgSendInitRecord)(id, SEL, NSString *, NSInteger);
+typedef id (*RunnerMsgSendInitPath)(id, SEL, CGPoint, NSTimeInterval);
+typedef void (*RunnerMsgSendPathMove)(id, SEL, CGPoint, NSTimeInterval);
+typedef void (*RunnerMsgSendPathOffset)(id, SEL, NSTimeInterval);
+typedef void (*RunnerMsgSendAddPath)(id, SEL, id);
+typedef void (*RunnerMsgSendSetInteger)(id, SEL, NSInteger);
+typedef BOOL (*RunnerMsgSendSynthesize)(id, SEL, NSError **);
+
+typedef struct {
+  Class recordClass;
+  Class pathClass;
+  SEL initRecordSelector;
+  SEL addPathSelector;
+  SEL setTargetProcessIDSelector;
+  SEL synthesizeSelector;
+  SEL interfaceOrientationSelector;
+  SEL processIDSelector;
+  SEL initPathSelector;
+  SEL moveSelector;
+  SEL liftSelector;
+} RunnerXCTestEventBridge;
+
+static NSString * _Nullable RunnerResolveXCTestEventBridge(
+  id application,
+  RunnerXCTestEventBridge *bridge
+);
+static NSString * _Nullable RunnerRequireClass(Class cls, NSString *className);
+static NSString * _Nullable RunnerRequireSelector(Class cls, SEL selector, NSString *selectorName);
+static NSString * _Nullable RunnerRequireApplicationSelector(id application, SEL selector, NSString *selectorName);
+static id RunnerPointerPath(
+  const RunnerXCTestEventBridge *bridge,
+  CGPoint start,
+  double x,
+  double y,
+  double dx,
+  double dy,
+  double scale,
+  double degrees,
+  double radius,
+  double durationMs,
+  double side
+);
+static CGPoint RunnerPointerPointAt(
+  double x,
+  double y,
+  double dx,
+  double dy,
+  double scale,
+  double degrees,
+  double baseRadius,
+  double t,
+  double side
+);
+
+@implementation RunnerSynthesizedGesture
+
++ (NSString * _Nullable)synthesizeTransformWithApplication:(id)application
+                                                         x:(double)x
+                                                         y:(double)y
+                                                        dx:(double)dx
+                                                        dy:(double)dy
+                                                     scale:(double)scale
+                                                   degrees:(double)degrees
+                                                    radius:(double)radius
+                                                durationMs:(double)durationMs {
+  @try {
+    return [self trySynthesizeTransformWithApplication:application
+                                                     x:x
+                                                     y:y
+                                                    dx:dx
+                                                    dy:dy
+                                                 scale:scale
+                                               degrees:degrees
+                                                radius:radius
+                                            durationMs:durationMs];
+  } @catch (NSException *exception) {
+    NSString *name = exception.name ?: @"NSException";
+    NSString *reason = exception.reason ?: @"private XCTest event synthesis failed";
+    return [NSString stringWithFormat:@"%@: %@", name, reason];
+  }
+}
+
++ (NSString * _Nullable)trySynthesizeTransformWithApplication:(id)application
+                                                            x:(double)x
+                                                            y:(double)y
+                                                           dx:(double)dx
+                                                           dy:(double)dy
+                                                        scale:(double)scale
+                                                      degrees:(double)degrees
+                                                       radius:(double)radius
+                                                   durationMs:(double)durationMs {
+  RunnerXCTestEventBridge bridge;
+  NSString *missing = RunnerResolveXCTestEventBridge(application, &bridge);
+  if (missing != nil) {
+    return missing;
+  }
+
+  NSInteger interfaceOrientation =
+    ((RunnerMsgSendInteger)objc_msgSend)(application, bridge.interfaceOrientationSelector);
+  NSInteger targetProcessID = ((RunnerMsgSendInteger)objc_msgSend)(application, bridge.processIDSelector);
+  if (targetProcessID <= 0) {
+    return @"private XCTest event synthesis unavailable: could not resolve target process ID";
+  }
+
+  id record = ((RunnerMsgSendInitRecord)objc_msgSend)(
+    [bridge.recordClass alloc],
+    bridge.initRecordSelector,
+    @"agent-device-transform",
+    interfaceOrientation
+  );
+  if (record == nil) {
+    return @"private XCTest event synthesis failed: could not create event record";
+  }
+  ((RunnerMsgSendSetInteger)objc_msgSend)(record, bridge.setTargetProcessIDSelector, targetProcessID);
+
+  double sides[] = {1.0, -1.0};
+  for (int index = 0; index < 2; index += 1) {
+    double side = sides[index];
+    id path = RunnerPointerPath(
+      &bridge,
+      RunnerPointerPointAt(x, y, dx, dy, scale, degrees, radius, 0.0, side),
+      x,
+      y,
+      dx,
+      dy,
+      scale,
+      degrees,
+      radius,
+      durationMs,
+      side
+    );
+    if (path == nil) {
+      return @"private XCTest event synthesis failed: could not create pointer path";
+    }
+    ((RunnerMsgSendAddPath)objc_msgSend)(record, bridge.addPathSelector, path);
+  }
+
+  NSError *error = nil;
+  BOOL ok = ((RunnerMsgSendSynthesize)objc_msgSend)(record, bridge.synthesizeSelector, &error);
+  if (!ok) {
+    NSString *detail = error.localizedDescription ?: @"synthesizeWithError returned false";
+    return [NSString stringWithFormat:@"private XCTest event synthesis failed: %@", detail];
+  }
+  return nil;
+}
+
+static NSString * _Nullable RunnerResolveXCTestEventBridge(
+  id application,
+  RunnerXCTestEventBridge *bridge
+) {
+  Class recordClass = NSClassFromString(@"XCSynthesizedEventRecord");
+  Class pathClass = NSClassFromString(@"XCPointerEventPath");
+  SEL initRecordSelector = NSSelectorFromString(@"initWithName:interfaceOrientation:");
+  SEL addPathSelector = NSSelectorFromString(@"addPointerEventPath:");
+  SEL setTargetProcessIDSelector = NSSelectorFromString(@"setTargetProcessID:");
+  SEL synthesizeSelector = NSSelectorFromString(@"synthesizeWithError:");
+  SEL interfaceOrientationSelector = NSSelectorFromString(@"interfaceOrientation");
+  SEL processIDSelector = NSSelectorFromString(@"processID");
+  SEL initPathSelector = NSSelectorFromString(@"initForTouchAtPoint:offset:");
+  SEL moveSelector = NSSelectorFromString(@"moveToPoint:atOffset:");
+  SEL liftSelector = NSSelectorFromString(@"liftUpAtOffset:");
+
+  NSString *missing = RunnerRequireClass(recordClass, @"XCSynthesizedEventRecord");
+  if (missing != nil) return missing;
+  missing = RunnerRequireClass(pathClass, @"XCPointerEventPath");
+  if (missing != nil) return missing;
+  missing = RunnerRequireSelector(recordClass, initRecordSelector, @"initWithName:interfaceOrientation:");
+  if (missing != nil) return missing;
+  missing = RunnerRequireSelector(recordClass, addPathSelector, @"addPointerEventPath:");
+  if (missing != nil) return missing;
+  missing = RunnerRequireSelector(recordClass, setTargetProcessIDSelector, @"setTargetProcessID:");
+  if (missing != nil) return missing;
+  missing = RunnerRequireSelector(recordClass, synthesizeSelector, @"synthesizeWithError:");
+  if (missing != nil) return missing;
+  missing = RunnerRequireSelector(pathClass, initPathSelector, @"initForTouchAtPoint:offset:");
+  if (missing != nil) return missing;
+  missing = RunnerRequireSelector(pathClass, moveSelector, @"moveToPoint:atOffset:");
+  if (missing != nil) return missing;
+  missing = RunnerRequireSelector(pathClass, liftSelector, @"liftUpAtOffset:");
+  if (missing != nil) return missing;
+  missing = RunnerRequireApplicationSelector(application, interfaceOrientationSelector, @"interfaceOrientation");
+  if (missing != nil) return missing;
+  missing = RunnerRequireApplicationSelector(application, processIDSelector, @"processID");
+  if (missing != nil) return missing;
+
+  *bridge = (RunnerXCTestEventBridge){
+    .recordClass = recordClass,
+    .pathClass = pathClass,
+    .initRecordSelector = initRecordSelector,
+    .addPathSelector = addPathSelector,
+    .setTargetProcessIDSelector = setTargetProcessIDSelector,
+    .synthesizeSelector = synthesizeSelector,
+    .interfaceOrientationSelector = interfaceOrientationSelector,
+    .processIDSelector = processIDSelector,
+    .initPathSelector = initPathSelector,
+    .moveSelector = moveSelector,
+    .liftSelector = liftSelector,
+  };
+  return nil;
+}
+
+static NSString * _Nullable RunnerRequireClass(Class cls, NSString *className) {
+  if (cls == Nil) {
+    return [NSString stringWithFormat:@"private XCTest event synthesis unavailable: missing %@", className];
+  }
+  return nil;
+}
+
+static NSString * _Nullable RunnerRequireSelector(Class cls, SEL selector, NSString *selectorName) {
+  if (![cls instancesRespondToSelector:selector]) {
+    return [NSString stringWithFormat:
+      @"private XCTest event synthesis unavailable: %@ missing %@",
+      NSStringFromClass(cls),
+      selectorName
+    ];
+  }
+  return nil;
+}
+
+static NSString * _Nullable RunnerRequireApplicationSelector(
+  id application,
+  SEL selector,
+  NSString *selectorName
+) {
+  if (![application respondsToSelector:selector]) {
+    return [NSString stringWithFormat:
+      @"private XCTest event synthesis unavailable: XCUIApplication missing %@",
+      selectorName
+    ];
+  }
+  return nil;
+}
+
+static id RunnerPointerPath(
+  const RunnerXCTestEventBridge *bridge,
+  CGPoint start,
+  double x,
+  double y,
+  double dx,
+  double dy,
+  double scale,
+  double degrees,
+  double radius,
+  double durationMs,
+  double side
+) {
+  id path =
+    ((RunnerMsgSendInitPath)objc_msgSend)([bridge->pathClass alloc], bridge->initPathSelector, start, 0.0);
+  if (path == nil) {
+    return nil;
+  }
+
+  int frameCount = MAX(3, (int)(durationMs / 16.0));
+  NSTimeInterval durationSeconds = durationMs / 1000.0;
+  for (int index = 1; index <= frameCount; index += 1) {
+    double t = (double)index / (double)frameCount;
+    CGPoint point = RunnerPointerPointAt(x, y, dx, dy, scale, degrees, radius, t, side);
+    NSTimeInterval offset = durationSeconds * t;
+    ((RunnerMsgSendPathMove)objc_msgSend)(path, bridge->moveSelector, point, offset);
+  }
+
+  ((RunnerMsgSendPathOffset)objc_msgSend)(path, bridge->liftSelector, durationSeconds);
+  return path;
+}
+
+static CGPoint RunnerPointerPointAt(
+  double x,
+  double y,
+  double dx,
+  double dy,
+  double scale,
+  double degrees,
+  double baseRadius,
+  double t,
+  double side
+) {
+  double centerX = x + dx * t;
+  double centerY = y + dy * t;
+  double startRadius = baseRadius / MAX(scale, 1.0);
+  double endRadius = baseRadius;
+  if (scale < 1.0) {
+    startRadius = baseRadius;
+    endRadius = baseRadius * scale;
+  }
+  double radius = startRadius + (endRadius - startRadius) * t;
+  double angle = (-M_PI_2) + (degrees * M_PI / 180.0) * t;
+  return CGPointMake(centerX + cos(angle) * radius * side, centerY + sin(angle) * radius * side);
+}
+
+@end

package/ios-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+CommandExecution.swift

@@ -252,7 +252,12 @@ extension RunnerTests {
       )
     case .tap:
       if let selectorKey = command.selectorKey, let selectorValue = command.selectorValue {
-        let match = findElement(app: activeApp, selectorKey: selectorKey, selectorValue: selectorValue)
+        let match = findElement(
+          app: activeApp,
+          selectorKey: selectorKey,
+          selectorValue: selectorValue,
+          allowNonHittableFallback: command.allowNonHittableCoordinateFallback == true
+        )
         if match.isAmbiguous {
           return Response(ok: false, error: ErrorPayload(code: "AMBIGUOUS_MATCH", message: "selector matched multiple elements"))
         }
@@ -264,16 +269,24 @@ extension RunnerTests {
           var outcome = RunnerInteractionOutcome.performed
           let timing = measureGesture {
             withTemporaryScrollIdleTimeoutIfSupported(activeApp) {
-              outcome = activateElement(app: activeApp, element: element, action: "tap by selector")
+              if match.usedNonHittableFallback {
+                // Maestro compatibility: RN E2E backdoor controls can be 1x1 and
+                // reported non-hittable by XCTest, while Maestro still taps their
+                // resolved bounds. Keep this behind the explicit replay-only flag.
+                outcome = tapAt(app: activeApp, x: frame.midX, y: frame.midY)
+              } else {
+                outcome = activateElement(app: activeApp, element: element, action: "tap by selector")
+              }
             }
           }
           if let response = unsupportedResponse(for: outcome) {
             return response
           }
+          waitForTextEntryReadinessAfterTap(app: activeApp, element: element)
           return Response(
             ok: true,
             data: DataPayload(
-              message: "tapped",
+              message: match.usedNonHittableFallback ? "tapped via non-hittable coordinate fallback" : "tapped",
               gestureStartUptimeMs: timing.gestureStartUptimeMs,
               gestureEndUptimeMs: timing.gestureEndUptimeMs,
               x: touchFrame?.x,
@@ -729,6 +742,25 @@ extension RunnerTests {
           dismissed: result.dismissed
         )
       )
+    case .keyboardReturn:
+      let result = pressKeyboardReturn(app: activeApp)
+      if !result.pressed {
+        return Response(
+          ok: false,
+          error: ErrorPayload(
+            code: "UNSUPPORTED_OPERATION",
+            message: "Unable to press the iOS keyboard return key"
+          )
+        )
+      }
+      return Response(
+        ok: true,
+        data: DataPayload(
+          message: "keyboardReturn",
+          visible: result.visible,
+          wasVisible: result.wasVisible
+        )
+      )
     case .alert:
       let action = (command.action ?? "get").lowercased()
       guard let alert = resolveAlert(app: activeApp) else {
@@ -754,6 +786,82 @@ extension RunnerTests {
           gestureEndUptimeMs: timing.gestureEndUptimeMs
         )
       )
+    case .rotateGesture:
+      guard let degrees = command.degrees, degrees.isFinite else {
+        return Response(ok: false, error: ErrorPayload(message: "rotateGesture requires degrees"))
+      }
+      let velocity = command.velocity ?? (degrees >= 0 ? 1.0 : -1.0)
+      guard velocity.isFinite && velocity != 0 else {
+        return Response(ok: false, error: ErrorPayload(message: "rotateGesture velocity must be non-zero"))
+      }
+      var outcome = RunnerInteractionOutcome.performed
+      let timing = measureGesture {
+        outcome = rotateGesture(
+          app: activeApp,
+          degrees: degrees,
+          x: command.x,
+          y: command.y,
+          velocity: velocity
+        )
+      }
+      if let response = unsupportedResponse(for: outcome) {
+        return response
+      }
+      return Response(
+        ok: true,
+        data: DataPayload(
+          message: "rotatedGesture",
+          gestureStartUptimeMs: timing.gestureStartUptimeMs,
+          gestureEndUptimeMs: timing.gestureEndUptimeMs
+        )
+      )
+    case .transformGesture:
+      guard
+        let x = command.x,
+        let y = command.y,
+        let dx = command.dx,
+        let dy = command.dy,
+        x.isFinite,
+        y.isFinite,
+        dx.isFinite,
+        dy.isFinite
+      else {
+        return Response(ok: false, error: ErrorPayload(message: "transformGesture requires finite x y dx dy"))
+      }
+      guard let scale = command.scale, scale.isFinite, scale > 0 else {
+        return Response(ok: false, error: ErrorPayload(message: "transformGesture requires scale > 0"))
+      }
+      guard let degrees = command.degrees, degrees.isFinite else {
+        return Response(ok: false, error: ErrorPayload(message: "transformGesture requires finite degrees"))
+      }
+      let durationMs = command.durationMs ?? 300
+      guard durationMs.isFinite && durationMs >= 16 else {
+        return Response(ok: false, error: ErrorPayload(message: "transformGesture durationMs must be >= 16"))
+      }
+      var outcome = RunnerInteractionOutcome.performed
+      let timing = measureGesture {
+        outcome = transformGesture(
+          app: activeApp,
+          x: x,
+          y: y,
+          dx: dx,
+          dy: dy,
+          scale: scale,
+          degrees: degrees,
+          durationMs: durationMs
+        )
+      }
+      if let response = unsupportedResponse(for: outcome) {
+        return response
+      }
+      return Response(
+        ok: true,
+        data: DataPayload(
+          message: "transformedGesture",
+          gestureStartUptimeMs: timing.gestureStartUptimeMs,
+          gestureEndUptimeMs: timing.gestureEndUptimeMs
+        )
+      )
     }
   }
 
@@ -763,7 +871,27 @@ extension RunnerTests {
     }
     let delaySeconds = Double(max(command.delayMs ?? 0, 0)) / 1000.0
     let textEntryMode = resolveTextEntryMode(command)
-    let target = focusTextInputForTextEntry(app: activeApp, x: command.x, y: command.y)
+    let target: TextEntryTarget
+    if let selectorKey = command.selectorKey, let selectorValue = command.selectorValue {
+      let match = findElement(
+        app: activeApp,
+        selectorKey: selectorKey,
+        selectorValue: selectorValue,
+        allowNonHittableFallback: command.allowNonHittableCoordinateFallback == true
+      )
+      if match.isAmbiguous {
+        return Response(ok: false, error: ErrorPayload(code: "AMBIGUOUS_MATCH", message: "selector matched multiple elements"))
+      }
+      guard let element = match.element else {
+        return Response(ok: false, error: ErrorPayload(code: "NO_MATCH", message: "selector did not match an element"))
+      }
+      guard isTextEntryElement(element) else {
+        return Response(ok: false, error: ErrorPayload(code: "INVALID_TARGET", message: "selector did not match a text input"))
+      }
+      target = focusTextInputForTextEntry(app: activeApp, element: element)
+    } else {
+      target = focusTextInputForTextEntry(app: activeApp, x: command.x, y: command.y)
+    }
     if textEntryMode == .replacement {
       guard target.element != nil else {
         let message =
@@ -791,6 +919,17 @@ extension RunnerTests {
         )
       )
     }
-    return Response(ok: true, data: DataPayload(message: textResult.repaired ? "typed after repair" : "typed"))
+    let point = target.refreshPoint
+    let frame = activeApp.frame
+    return Response(
+      ok: true,
+      data: DataPayload(
+        message: textResult.repaired ? "typed after repair" : "typed",
+        x: point.map { Double($0.x) },
+        y: point.map { Double($0.y) },
+        referenceWidth: frame.isEmpty ? nil : Double(frame.width),
+        referenceHeight: frame.isEmpty ? nil : Double(frame.height)
+      )
+    )
   }
 }