simframe 0.6.2 → 0.7.2

package/src/input.js

@@ -3,6 +3,7 @@
 // even available?" before it answers anything else.
 import { execFile } from 'node:child_process';
 import * as control from './control.js';
+import { capabilitiesFor, geometryFor, inputDriverFor, setPasteboard } from './platform/index.js';
 import { promisify } from 'node:util';
 
 const run = promisify(execFile);
@@ -20,6 +21,12 @@ let driverCache = null;
  * iOS. idb remains the fallback so a machine without the daemon still works.
  */
 export async function driverFor(udid) {
+  // A platform that carries its own input path answers first: there is no
+  // daemon to ask and no idb to fall back to, and reporting either for an
+  // Android emulator is how doctor came to claim "input driver: idb" about a
+  // tool that has never spoken to one.
+  const own = udid ? inputDriverFor(udid) : null;
+  if (own) return { name: own.id, available: true, version: own.detail, reason: null, viaSocket: false };
   if (udid && control.available(udid)) {
     try {
       const status = await control.status(udid);
@@ -140,6 +147,15 @@ export async function screenInfo(udid, { refresh = false } = {}) {
 }
 
 async function readScreenInfo(udid) {
+  // The platform first, where it can answer at all: on Android it is the only
+  // source, and the alternative is `deviceGeometry`'s last-resort guess, which
+  // is an iPhone's numbers and silently wrong for everything else.
+  try {
+    const geo = await geometryFor(udid);
+    if (geo?.pointWidth && geo?.pointHeight) return geo;
+  } catch {
+    /* the backend could not say; the daemon or idb may still be able to */
+  }
   // Ask the daemon first. It holds the device's own point size and scale, which
   // makes it both authoritative and free — and it means geometry no longer
   // needs idb at all. Going to idb first meant a machine without idb could
@@ -191,6 +207,14 @@ export async function describeAll(udid) {
       /* daemon went away mid-call; fall through to idb */
     }
   }
+  // A platform with no accessibility tree is not a machine missing idb.
+  // `doctor` learned that when it reported "input driver: idb" for an emulator;
+  // this path had not, so every Android screen map carried a note telling the
+  // reader to brew-install a tool that has never spoken to an Android device —
+  // and on a machine where idb *is* installed, spawned it against an emulator
+  // serial on every map build.
+  const ax = capabilitiesFor(udid).ax;
+  if (!ax.supported) throw new Error(`no accessibility tree on this device — ${ax.note}`);
   // Passing --json here yields empty output; the default already emits JSON.
   const out = await idb(['ui', 'describe-all', '--udid', udid]);
   const nodes = [];
@@ -300,6 +324,11 @@ export function centerOf(node) {
 
 export async function tapPoint(udid, x, y, { durationMs } = {}) {
   const point = { x: Math.round(x), y: Math.round(y) };
+  const own = inputDriverFor(udid);
+  if (own) {
+    await own.tap(udid, point.x, point.y, durationMs ? { durationMs } : {});
+    return point;
+  }
   if (control.available(udid)) {
     await control.tap(udid, point.x, point.y, durationMs ? { durationMs } : {});
     return point;
@@ -318,6 +347,15 @@ export async function tapLabel(udid, query, { index, durationMs } = {}) {
 }
 
 export async function typeText(udid, value) {
+  const own = inputDriverFor(udid);
+  if (own) {
+    // No pasteboard on Android (docs/DEFERRED.md), so exact text goes through
+    // the same keystroke path as everything else. `event text` carries
+    // characters rather than key positions, so a non-Latin host layout does not
+    // reinterpret them — which is the reason the pasteboard exists on iOS.
+    await own.text(udid, String(value));
+    return;
+  }
   if (control.available(udid)) {
     // The daemon's paste path carries characters rather than key positions, so
     // it is not reinterpreted by the device's keyboard layout.
@@ -327,8 +365,46 @@ export async function typeText(udid, value) {
   await idb(['ui', 'text', '--udid', udid, String(value)]);
 }
 
+/**
+ * Put text on the pasteboard **and deliver it** into the focused field.
+ *
+ * The delivery is the whole point, and it is what was missing: the `paste` step
+ * used to set the pasteboard, long-press the field, and report success while
+ * the field stayed empty — on both platforms, not just the one it was filed
+ * against. iOS had the mechanism and did not use it (the daemon's `paste` is
+ * pbcopy *plus* Cmd-V) and Android had the keycode sitting unused in `KEYS`.
+ *
+ * When nothing can deliver the keystroke this throws rather than returning a
+ * cheerful description of half the job. A step that cannot do what it says has
+ * to say so; `type` still works on every device.
+ */
+export async function pasteText(udid, value) {
+  const own = inputDriverFor(udid);
+  if (own?.key) {
+    // The clipboard goes over gRPC; KEYCODE_PASTE is what puts it in the field.
+    await setPasteboard(udid, String(value));
+    await own.key(udid, 'paste');
+    return;
+  }
+  if (control.available(udid)) {
+    // One round trip: the daemon copies and presses Cmd-V.
+    await control.paste(udid, String(value));
+    return;
+  }
+  await setPasteboard(udid, String(value));
+  throw new Error(
+    'the text is on the pasteboard but nothing here can paste it: the keystroke needs the simframe ' +
+      'daemon (start it with `simframe start`), or use `type`, which carries the characters itself',
+  );
+}
+
 /** Key events rather than text: for shortcuts and search-as-you-type. */
 export async function typeKeys(udid, value) {
+  const own = inputDriverFor(udid);
+  if (own) {
+    await own.text(udid, String(value));
+    return;
+  }
   if (control.available(udid)) {
     await control.type(udid, String(value));
     return;
@@ -337,6 +413,11 @@ export async function typeKeys(udid, value) {
 }
 
 export async function pressKey(udid, keycode) {
+  const own = inputDriverFor(udid);
+  if (own) {
+    await own.key(udid, keycode);
+    return;
+  }
   await idb(['ui', 'key', '--udid', udid, String(keycode)]);
 }
 
@@ -363,6 +444,13 @@ export async function resetSession(udid) {
 }
 
 export async function pressButton(udid, name) {
+  const own = inputDriverFor(udid);
+  if (own) {
+    // Android's whole key vocabulary is safe to offer: `input keyevent` takes
+    // names through a public API, so unlike Indigo there is nothing to guess.
+    await own.key(udid, name);
+    return;
+  }
   if (control.available(udid)) {
     try {
       await control.press(udid, String(name).toLowerCase());
@@ -376,6 +464,11 @@ export async function pressButton(udid, name) {
 }
 
 export async function swipe(udid, from, to, { durationMs = 300 } = {}) {
+  const own = inputDriverFor(udid);
+  if (own) {
+    await own.swipe(udid, from, to, { durationMs });
+    return;
+  }
   if (control.available(udid)) {
     await control.swipe(udid, from, to, { durationMs });
     return;

package/src/mcp.js

@@ -14,14 +14,14 @@ import * as actions from './actions.js';
 import * as api from './index.js';
 import * as input from './input.js';
 import * as navigate from './navigate.js';
-import { bootedDevices, PERMISSION_SERVICES } from './simctl.js';
+import { bootedDevices, permissionServices } from './platform/index.js';
 import * as store from './store.js';
 import * as view from './view.js';
 
 const deviceProp = {
   device: {
     type: 'string',
-    description: 'Simulator UDID or name substring. Defaults to the booted simulator.',
+    description: 'Device UDID or name substring — a simulator udid or an emulator serial. Defaults to the booted device.',
   },
 };
 
@@ -180,7 +180,7 @@ const TOOLS = [
   },
   {
     name: 'sim_open_url',
-    description: 'Open a URL or deep link on the simulator — the fastest way to reach a screen when the app has a link for it.',
+    description: 'Open a URL or deep link on the device — the fastest way to reach a screen when the app has a link for it.',
     inputSchema: {
       type: 'object',
       properties: { ...deviceProp, url: { type: 'string' } },
@@ -189,7 +189,7 @@ const TOOLS = [
   },
   {
     name: 'sim_permission',
-    description: `Grant, revoke or reset a privacy permission for an app. Do this instead of tapping the system alert: the alert is not part of the app under test, and its buttons move between iOS versions. Services: ${PERMISSION_SERVICES.join(', ')}.`,
+    description: `Grant, revoke or reset a privacy permission for an app. Do this instead of tapping the system alert: the alert is not part of the app under test, and its buttons move between OS versions. Not every service exists on every platform — the device's own backend refuses one it does not have. Services: ${permissionServices().join(', ')}.`,
     inputSchema: {
       type: 'object',
       properties: {
@@ -304,7 +304,7 @@ const TOOLS = [
   },
   {
     name: 'sim_devices',
-    description: 'List booted iOS simulators that simframe can capture.',
+    description: 'List the booted devices simframe can drive — iOS simulators and Android emulators.',
     inputSchema: { type: 'object', properties: {} },
   },
 ];
@@ -826,7 +826,7 @@ function listStateDirs() {
 
 async function devices() {
   const booted = await bootedDevices();
-  if (!booted.length) return { content: [text('no booted simulators')] };
+  if (!booted.length) return { content: [text('no booted devices')] };
   return {
     content: [text(booted.map((d) => `${d.name} · ${d.runtime} · ${d.udid}`).join('\n'))],
   };

package/src/navigate.js

@@ -51,6 +51,13 @@ export async function goto(deviceQuery, target, { options, ...runOptions } = {})
     return { ok: true, already: true, screen: found.name, steps: [] };
   }
 
+  // `hashTokens` returns null for an empty token set on purpose — a constant
+  // hash for "I could read nothing" is the self-confirming-emptiness bug. So a
+  // screen with no identity has to be reported, not sliced: this threw
+  // `Cannot read properties of null (reading 'slice')` instead of answering.
+  // Not hypothetical on Android, where README's own table puts the launcher at
+  // one token.
+  if (!here.hash) return { ok: false, reason: 'no-identity', to: found.name };
   const path_ = graph.route(udid, { hash: here.hash, tokens: here.tokens }, found.node.hash);
   if (!path_) return { ok: false, reason: 'no-route', from: here.hash.slice(0, 8), to: found.name };
 
@@ -65,7 +72,7 @@ export async function goto(deviceQuery, target, { options, ...runOptions } = {})
     steps,
     ranSteps: result.ranSteps,
     results: result.results,
-    arrived: arrived.hash.slice(0, 8),
+    arrived: arrived.hash ? arrived.hash.slice(0, 8) : null,
   };
 }