mobile-automator 0.26.0 → 0.28.0

package/src/device/session-paths.js

@@ -74,6 +74,26 @@ function lockPath(projectRoot) {
   return path.join(sessionDir(projectRoot), LOCK_NAME);
 }
 
+// The workspace a daemon serves, as it appears on its command line (#156).
+// The daemon itself reads its root from env (MAUTO_SESSION_PROJECT_ROOT), which
+// `ps` cannot see, so every daemon's command line used to be identical. This
+// marker is what lets `session end` tell THIS workspace's daemon from another
+// workspace's before it signals a process group: a copied workspace (`cp -R`
+// carries daemon.pid) or a recycled pid can name a different live daemon.
+// The root is the LAST argument so a match can be anchored at the end.
+const DAEMON_ROOT_FLAG = '--project-root';
+
+function daemonArgv(projectRoot) {
+  return [DAEMON_ROOT_FLAG, path.resolve(projectRoot)];
+}
+
+// Does a `ps -o command=` line name exactly this workspace? Anchored at the end
+// of the line so `/a/proj` never matches a daemon serving `/a/proj2`.
+function commandNamesWorkspace(command, projectRoot) {
+  const line = String(command || '').replace(/\s+$/, '');
+  return line.endsWith(` ${DAEMON_ROOT_FLAG} ${path.resolve(projectRoot)}`);
+}
+
 module.exports = {
   SESSION_DIRNAME,
   SOCKET_NAME,
@@ -89,4 +109,7 @@ module.exports = {
   pidFilePath,
   handlePath,
   lockPath,
+  DAEMON_ROOT_FLAG,
+  daemonArgv,
+  commandNamesWorkspace,
 };

package/src/device/session-spawn.js

@@ -12,6 +12,8 @@ const childProcess = require('child_process');
 
 const sessionClient = require('./session-client');
 const sessionLog = require('./session-log');
+const paths = require('./session-paths');
+const reaper = require('./process-reaper');
 
 const DAEMON_BIN = path.join(__dirname, '..', '..', 'bin', 'mauto-session-daemon.js');
 const DEFAULT_READY_TIMEOUT_MS = 15000;
@@ -31,6 +33,10 @@ async function spawnDaemon({
   pollMs = DEFAULT_POLL_MS,
   isAlive = sessionClient.isAlive,
   openLog = sessionLog.openDaemonLog,
+  // Kills a daemon that never became ready (#156). group:true reaches the
+  // daemon AND its mobile-mcp engine: `detached: true` below makes the daemon
+  // a process-group leader, and the engine is spawned into its group.
+  terminate = (pid) => reaper.terminate(pid, { group: true }),
 } = {}) {
   if (!projectRoot) throw new TypeError('spawnDaemon requires projectRoot');
 
@@ -46,7 +52,9 @@ async function spawnDaemon({
   const log = openLog(projectRoot);
 
   try {
-    const child = spawn(process.execPath, [DAEMON_BIN], {
+    // The root in argv is an identity marker only (see paths.daemonArgv): env
+    // stays the daemon's source of truth, but `ps` can only see argv.
+    const child = spawn(process.execPath, [DAEMON_BIN, ...paths.daemonArgv(projectRoot)], {
       detached: true,
       stdio: log.stdio,
       env,
@@ -80,6 +88,18 @@ async function spawnDaemon({
       if (await isAlive(projectRoot)) return true;
       await sleep(pollMs);
     }
+
+    // Not ready in time. Without this the child lives on — typically still
+    // inside createCall, holding the O_EXCL lock — and every later verb burns
+    // its own readiness window against it (#156). Only OUR child, and only if
+    // it is still running: an ELOCKED spawn-race loser has already exited and
+    // must never signal anything. Node tracked this exact child, so its state
+    // needs no pidIdentity check and has no pid-reuse window.
+    if (child && child.pid && child.exitCode === null && child.signalCode === null) {
+      const outcome = await terminate(child.pid);
+      // The parent is the only witness to this kill — write it down (#163).
+      log.write(`mauto: daemon not ready after ${readyTimeoutMs}ms; terminated pid=${child.pid} (${outcome})\n`);
+    }
     return false;
   } finally {
     // The child holds its own dup, so the parent releases its descriptor rather
@@ -89,4 +109,4 @@ async function spawnDaemon({
   }
 }
 
-module.exports = { spawnDaemon, DAEMON_BIN };
+module.exports = { spawnDaemon, DAEMON_BIN, DEFAULT_READY_TIMEOUT_MS };

package/src/device/swipe-geometry.js

@@ -0,0 +1,39 @@
+'use strict';
+
+// Geometry for a direction-only swipe: start at centre + 30% of the axis
+// dimension and travel 60% of it, i.e. centre ± 30% (#199).
+//
+// Why mauto computes this instead of letting the engine choose: mobile-mcp
+// 0.0.55's adb and WDA robots used exactly this proportional travel, but 1.0.5
+// routes every device through mobilecli, whose direction-only swipe is a fixed
+// 400px centred stroke — about a third of the old travel on a phone, so
+// scroll-to-element needs ~3x the swipes. Every robot in both versions reads an
+// explicit {x, y, distance} the same way (start at x,y; move `distance` px in
+// `direction`), so sending it pins identical behaviour on either pin.
+//
+// Kept pure and in its own module (not inside DeviceBridge) so the arithmetic
+// is testable without an engine fake and the bridge stays a thin wrapper.
+// There is deliberately no platform branch: proportional geometry is what makes
+// it platform-agnostic.
+//
+// The integer formulas mirror 0.0.55's AndroidRobot (`Math.floor(n * 0.8)`,
+// `Math.floor(n * 0.2)`, centre `floor(n / 2)`) so the endpoints match its old
+// ones pixel-for-pixel, floating-point rounding included.
+function centredSwipe({ width, height }, direction) {
+  const hi = (n) => Math.floor(n * 0.8);
+  const lo = (n) => Math.floor(n * 0.2);
+  const cx = Math.floor(width / 2);
+  const cy = Math.floor(height / 2);
+  switch (direction) {
+    case 'up': return { x: cx, y: hi(height), distance: hi(height) - lo(height) };
+    case 'down': return { x: cx, y: lo(height), distance: hi(height) - lo(height) };
+    case 'left': return { x: hi(width), y: cy, distance: hi(width) - lo(width) };
+    case 'right': return { x: lo(width), y: cy, distance: hi(width) - lo(width) };
+    default:
+      // The CLI validates directions first; this guards other callers from a
+      // swipe with undefined geometry.
+      throw new Error(`Unknown swipe direction "${direction}".`);
+  }
+}
+
+module.exports = { centredSwipe };

package/src/device/tool-args.js

@@ -1,6 +1,8 @@
 'use strict';
 
-// mobile-mcp 0.0.55 requires `device` on every tool EXCEPT the discovery verb.
+// mobile-mcp 1.0.5 requires `device` on every tool EXCEPT the discovery verb;
+// tests/integration/mobile-mcp-contract.test.js enforces this against the
+// pinned engine's own tool schemas.
 // Centralizing the injection (and its one exception) here keeps every call
 // site correct. Pure + non-mutating so it is trivially testable.
 const NO_DEVICE_TOOLS = new Set(['mobile_list_available_devices']);

package/src/observe/event.js

@@ -120,10 +120,10 @@ const EVENT_FIELDS = {
   // src/device/mobile-mcp-tools.js. A daemon-minted counter needs no redaction
   // argument at all, on exactly the grounds dur_ms is cleared.
   call_id: sendable(integer({ min: 1 }), 'daemon-minted counter scoped to one session; never the client-supplied frame id'),
-  stop_reason: sendable(oneOf(STOP_REASONS), 'enumerated: idle|signal|shutdown|crash|explicit'),
+  stop_reason: sendable(oneOf(STOP_REASONS), 'enumerated: idle|signal|shutdown|crash|explicit|engine_exit'),
   // Errno NAMES only: the numeric codes an MCP server reports, and Node's
   // ERR_* codes, fail the check and are dropped rather than sent.
-  error_code: sendable(oneOf(ERROR_CODES), 'Node/libuv errno string (EADDRINUSE|EACCES|…) plus our own ELOCKED'),
+  error_code: sendable(oneOf(ERROR_CODES), 'Node/libuv errno string (EADDRINUSE|EACCES|…) plus our own ELOCKED|ENGINE_CONNECT_TIMEOUT|ENGINE_EXITED'),
 
   // --- crash (slice 4) ---------------------------------------------------
   // The ONLY new field slice 4 mints. As with `verb`, `tool` and `session_id`,

package/src/observe/vocab.js

@@ -43,6 +43,7 @@ const EVENT_NAMES = Object.freeze([
   'daemon.start_failure',
   'daemon.listen_failure',
   'daemon.connect_failure',
+  'daemon.engine_exit',
   'daemon.lock_conflict',
   'daemon.undeliverable',
   // Emitted by the flush path, which lands in a later slice-5 task; declared
@@ -86,11 +87,20 @@ const VERB_NAMES = Object.freeze([
 ]);
 
 // Why the daemon stopped. 'crash' is documented but not yet produced.
-const STOP_REASONS = Object.freeze(['idle', 'signal', 'shutdown', 'crash', 'explicit']);
+// 'engine_exit': the mobile-mcp engine died under a serving daemon (#156).
+const STOP_REASONS = Object.freeze(['idle', 'signal', 'shutdown', 'crash', 'explicit', 'engine_exit']);
 
-// Node/libuv errno names for this platform, plus our own ELOCKED (a lock
-// conflict, recorded by src/device/session-daemon.js). Names only: the numeric codes an MCP
-// server reports are not in this set and so never pass.
-const ERROR_CODES = Object.freeze([...Object.keys(os.constants.errno), 'ELOCKED']);
+// Node/libuv errno names for this platform, plus our own codes, all recorded by
+// src/device/: ELOCKED (a lock conflict, session-daemon.js),
+// ENGINE_CONNECT_TIMEOUT (initialize exceeded its bound, mobile-mcp-client.js)
+// and ENGINE_EXITED (the engine died before the daemon was serving,
+// session-daemon.js). Names only: the numeric codes an MCP server reports are
+// not in this set and so never pass.
+const ERROR_CODES = Object.freeze([
+  ...Object.keys(os.constants.errno),
+  'ELOCKED',
+  'ENGINE_CONNECT_TIMEOUT',
+  'ENGINE_EXITED',
+]);
 
 module.exports = { OS_NAMES, EVENT_NAMES, VERB_NAMES, STOP_REASONS, ERROR_CODES };