mobile-automator 0.23.8

package/src/device/semantic-press/resolver.js

@@ -0,0 +1,100 @@
+'use strict';
+
+const { ALLOW_LABELS, DENY_LABELS, findByLabels } = require('./labels');
+
+// Raised when a semantic action cannot be performed on the current screen/
+// platform. `.kind`/`.hint` let the CLI map it onto the `device` envelope.
+class SemanticResolutionError extends Error {
+  constructor(message, hint) {
+    super(message);
+    this.name = 'SemanticResolutionError';
+    this.kind = 'device';
+    this.hint = hint;
+  }
+}
+
+// iOS return/confirm keys that dismiss the keyboard when tapped.
+const IOS_RETURN_KEYS = ['return', 'done', 'go', 'search', 'send', 'next'];
+
+class SemanticResolver {
+  constructor(bridge) {
+    this.bridge = bridge;
+  }
+
+  async _tapByLabels(labels, intent) {
+    const el = findByLabels(await this.bridge.listElements(), labels);
+    if (!el) {
+      throw new SemanticResolutionError(
+        `Could not find a "${intent}" affordance on screen.`,
+        'Ensure the relevant system dialog/control is visible before this step.'
+      );
+    }
+    await this.bridge.tap({ x: el.element.center[0], y: el.element.center[1] });
+    return { mechanism: `tap:${el.label}` };
+  }
+}
+
+class AndroidResolver extends SemanticResolver {
+  async pressBack() {
+    await this.bridge.pressButton('BACK');
+    return { mechanism: 'button:BACK' };
+  }
+
+  // BACK also hides the IME on Android. Caveat: with no keyboard open this pops
+  // the screen — accepted; mobile-mcp exposes no reliable IME-visible signal.
+  async dismissKeyboard() {
+    await this.bridge.pressButton('BACK');
+    return { mechanism: 'button:BACK' };
+  }
+
+  async grantPermission() {
+    return this._tapByLabels(ALLOW_LABELS.android, 'grant permission');
+  }
+
+  async denyPermission() {
+    return this._tapByLabels(DENY_LABELS.android, 'deny permission');
+  }
+}
+
+class IOSResolver extends SemanticResolver {
+  // No hardware back on iOS: left-edge interactive-pop gesture.
+  async pressBack() {
+    const { width, height } = await this.bridge.getScreenSize();
+    // Without a real screen size the swipe would be a degenerate no-op that
+    // still reports success — hard-fail instead of silently doing nothing.
+    if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+      throw new SemanticResolutionError(
+        `Cannot perform the iOS back gesture without a valid screen size (got ${width}x${height}).`,
+        'Ensure a device or simulator is connected.'
+      );
+    }
+    await this.bridge.swipe({
+      direction: 'right',
+      x: 1,
+      y: Math.round(height / 2),
+      distance: Math.round(width * 0.6),
+    });
+    return { mechanism: 'edge_swipe' };
+  }
+
+  // Primary: tap a return/Done key. Fallback: swipe down to dismiss.
+  async dismissKeyboard() {
+    const el = findByLabels(await this.bridge.listElements(), IOS_RETURN_KEYS);
+    if (el) {
+      await this.bridge.tap({ x: el.element.center[0], y: el.element.center[1] });
+      return { mechanism: `tap:${el.label}` };
+    }
+    await this.bridge.swipe({ direction: 'down' });
+    return { mechanism: 'swipe:down' };
+  }
+
+  async grantPermission() {
+    return this._tapByLabels(ALLOW_LABELS.ios, 'grant permission');
+  }
+
+  async denyPermission() {
+    return this._tapByLabels(DENY_LABELS.ios, 'deny permission');
+  }
+}
+
+module.exports = { SemanticResolver, AndroidResolver, IOSResolver, SemanticResolutionError };

package/src/device/session-client.js

@@ -0,0 +1,173 @@
+'use strict';
+
+// Client side of the device session daemon protocol.
+//
+// tryConnect(projectRoot) returns a { call, close } pair shaped EXACTLY like
+// mobile-mcp-client.createCall, so a daemon-backed bridge is a drop-in for a
+// one-shot bridge. Returns null when no live daemon is reachable (the caller
+// then falls back to a one-shot spawn). Requests are correlated by id so a
+// single connection can multiplex concurrent calls.
+
+const net = require('net');
+
+const paths = require('./session-paths');
+const { FrameParser } = require('./session-protocol');
+
+const DEFAULT_TIMEOUT_MS = 30000;
+
+// Connect a socket to the daemon, or resolve null if it cannot connect.
+function connectSocket(socketPath) {
+  return new Promise((resolve) => {
+    const socket = net.createConnection(socketPath);
+    let settled = false;
+    const done = (val) => {
+      if (settled) return;
+      settled = true;
+      resolve(val);
+    };
+    socket.once('connect', () => done(socket));
+    socket.once('error', () => done(null));
+  });
+}
+
+// Build a { call, close, request } client over an already-connected socket.
+function wrapSocket(socket) {
+  const parser = new FrameParser();
+  const pending = new Map();
+  let nextId = 1;
+  let closed = false;
+
+  socket.setEncoding('utf8');
+  socket.on('data', (chunk) => {
+    for (const f of parser.push(chunk)) {
+      if (f.error) continue; // ignore malformed responses
+      const res = f.value;
+      const entry = pending.get(res.id);
+      if (entry) {
+        pending.delete(res.id);
+        entry.resolve(res);
+      }
+    }
+  });
+
+  const failAll = (err) => {
+    for (const [, entry] of pending) entry.reject(err);
+    pending.clear();
+  };
+  socket.on('error', (err) => failAll(err));
+  socket.on('close', () => {
+    if (!closed) failAll(new Error('session daemon connection closed'));
+  });
+
+  function request(frame, { timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+    const id = nextId++;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        reject(new Error('session daemon request timed out'));
+      }, timeoutMs);
+      if (typeof timer.unref === 'function') timer.unref();
+      pending.set(id, {
+        resolve: (res) => {
+          clearTimeout(timer);
+          resolve(res);
+        },
+        reject: (err) => {
+          clearTimeout(timer);
+          reject(err);
+        },
+      });
+      socket.write(FrameParser.encode({ id, ...frame }));
+    });
+  }
+
+  async function call(tool, args = {}) {
+    const res = await request({ type: 'call', tool, args });
+    if (!res.ok) {
+      // Carry the daemon's kind/hint (e.g. kind:'timeout' + partial-execution
+      // hint) so the CLI can surface them instead of defaulting to 'device'.
+      const e = new Error((res.error && res.error.message) || 'session call failed');
+      if (res.error && res.error.kind) e.kind = res.error.kind;
+      if (res.error && res.error.hint) e.hint = res.error.hint;
+      throw e;
+    }
+    return res.result;
+  }
+
+  function close() {
+    closed = true;
+    try {
+      socket.end();
+    } catch (_) {
+      /* ignore */
+    }
+    return Promise.resolve();
+  }
+
+  return { call, close, request };
+}
+
+// Returns { call, close } against a live daemon, or null when unreachable.
+async function tryConnect(projectRoot) {
+  const socket = await connectSocket(paths.socketPath(projectRoot));
+  if (!socket) return null;
+  const { call, close } = wrapSocket(socket);
+  return { call, close };
+}
+
+// Liveness probe: connect + ping. Returns the handle device on success, false
+// otherwise. Used to decide daemon-vs-oneshot and to poll a spawned daemon.
+async function isAlive(projectRoot) {
+  const socket = await connectSocket(paths.socketPath(projectRoot));
+  if (!socket) return false;
+  const client = wrapSocket(socket);
+  try {
+    const res = await client.request({ type: 'ping' }, { timeoutMs: 2000 });
+    return !!(res && res.ok);
+  } catch (_) {
+    return false;
+  } finally {
+    await client.close();
+  }
+}
+
+// Ask a live daemon to shut down. Resolves true when a daemon acknowledged,
+// false when none was reachable.
+async function requestShutdown(projectRoot) {
+  const socket = await connectSocket(paths.socketPath(projectRoot));
+  if (!socket) return false;
+  const client = wrapSocket(socket);
+  try {
+    const res = await client.request({ type: 'shutdown' }, { timeoutMs: 5000 });
+    return !!(res && res.ok);
+  } catch (_) {
+    return false;
+  } finally {
+    await client.close();
+  }
+}
+
+// Rich status probe: connect + ping and report whether a daemon is running,
+// how many device calls are currently in flight (the double-execution window
+// is visible here), and which device it is pinned to. `null`s when not running.
+async function getSessionStatus(projectRoot) {
+  const socket = await connectSocket(paths.socketPath(projectRoot));
+  if (!socket) return { running: false, in_flight: null, device: null };
+  const client = wrapSocket(socket);
+  try {
+    const res = await client.request({ type: 'ping' }, { timeoutMs: 2000 });
+    if (!(res && res.ok)) return { running: false, in_flight: null, device: null };
+    const result = res.result || {};
+    return {
+      running: true,
+      in_flight: typeof result.in_flight === 'number' ? result.in_flight : null,
+      device: result.device != null ? result.device : null,
+    };
+  } catch (_) {
+    return { running: false, in_flight: null, device: null };
+  } finally {
+    await client.close();
+  }
+}
+
+module.exports = { tryConnect, isAlive, requestShutdown, getSessionStatus, DEFAULT_TIMEOUT_MS };