mobile-automator 0.30.0 → 0.30.1

package/bin/mauto.js

@@ -10,4 +10,5 @@ const { run, emitFatal } = require('../src/cli');
 // exit-on-reject listener.
 process.on('unhandledRejection', emitFatal);
 
-run(process.argv);
+// run() catches everything into emitFatal itself, so the promise never rejects.
+void run(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobile-automator",
-  "version": "0.30.0",
+  "version": "0.30.1",
   "description": "Host-agnostic mauto CLI for AI-driven mobile QA automation — analyzes a mobile project and drives devices through mobile-mcp.",
   "homepage": "https://github.com/sh3lan93/mobile-automator#readme",
   "repository": {
@@ -26,6 +26,7 @@
     "prepublishOnly": "npm test",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
+    "lint": "eslint .",
     "lint:guides": "jest tests/lint",
     "lint:schema-additive": "jest tests/lint/schema-additive.test.js",
     "test:unit": "jest tests/unit",
@@ -39,9 +40,15 @@
     "commander": "^12.1.0"
   },
   "devDependencies": {
+    "@eslint/js": "^9.39.5",
+    "@types/node": "^22.20.5",
+    "eslint": "^9.39.5",
+    "globals": "^17.13.0",
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
-    "js-yaml": "^4.3.2"
+    "js-yaml": "^4.3.2",
+    "typescript": "~6.0.3",
+    "typescript-eslint": "^8.72.0"
   },
   "engines": {
     "node": ">=22.12.0"

package/src/cli.js

@@ -7,7 +7,6 @@ const { Command } = require('commander');
 const { version: PKG_VERSION } = require('../package.json');
 
 const { ok, fail, render, exitCodeFor } = require('./output/envelope');
-const { DeviceBridge } = require('./device/bridge');
 const selectionStore = require('./device/selection');
 const { engineHint } = require('./device/engine-hints');
 const { ScenarioValidator } = require('./scenario/validator');
@@ -1210,7 +1209,7 @@ async function handleSessionStart(
     projectRoot,
     spawn = require('./device/session-spawn'),
     client = require('./device/session-client'),
-    readHandle = require('./device/resolve-connection').readHandleDevice,
+    readHandle: readHandleDevice = require('./device/resolve-connection').readHandleDevice,
   },
   opts = {}
 ) {
@@ -1233,7 +1232,7 @@ async function handleSessionStart(
     // pinned to A reported already_running:true, device:B while every verb
     // kept driving A. Fail with a hint instead — the agent stays in control
     // and decides whether to `session end` and repin.
-    const pinned = readHandle(projectRoot);
+    const pinned = readHandleDevice(projectRoot);
     if (device !== null && device !== pinned) {
       return {
         envelope: fail(
@@ -1391,7 +1390,7 @@ async function handleDevicesClear({
   store = selectionStore,
   projectRoot,
   isAlive = require('./device/connection').isSessionAlive,
-  readHandle = require('./device/resolve-connection').readHandleDevice,
+  readHandle: readHandleDevice = require('./device/resolve-connection').readHandleDevice,
 } = {}) {
   const previous = store.read(projectRoot);
   store.clear(projectRoot);
@@ -1403,7 +1402,7 @@ async function handleDevicesClear({
   if (!alive) {
     return { envelope: ok({ cleared: previous || null }), exitKind: 'ok' };
   }
-  const pinned = readHandle(projectRoot);
+  const pinned = readHandleDevice(projectRoot);
   return {
     envelope: ok(
       { cleared: previous || null, daemon_still_pinned: pinned },
@@ -2325,7 +2324,7 @@ function makeEmitters({ projectRoot = process.cwd() } = {}) {
   // needed). A Date.now() stamped at require time would measure from whenever
   // cli.js was loaded, which is not process start for anything that requires it
   // first (a test harness, bin/mauto.js's own guards).
-  function finish({ text = '', exitKind, ok, errorKind, exitCode = exitCodeFor(exitKind) }) {
+  function finish({ text = '', exitKind, ok: succeeded, errorKind, exitCode = exitCodeFor(exitKind) }) {
     // The flag-resolved id when a command parsed, the environment otherwise: a
     // parse failure reaches no preAction hook and so has no flag, but it is
     // still part of the run and is exactly the class of failure (#146) this
@@ -2355,7 +2354,7 @@ function makeEmitters({ projectRoot = process.cwd() } = {}) {
       // tying this line to a run. sends:false in the event catalog.
       run_id: runId || undefined,
       session_id: resolvedSessionId || undefined,
-      ok,
+      ok: succeeded,
       error_kind: errorKind,
       exit_code: exitCode,
       dur_ms: Math.round(process.uptime() * 1000),

package/src/device/bridge.js

@@ -44,7 +44,7 @@ class DeviceBridge {
   // Tap at absolute screen coordinates. The agent derives x,y from listElements
   // centers, so the bridge stays free of any element targeting logic.
   async tap({ x, y } = {}) {
-    return this._call('mobile_click_on_screen_at_coordinates', { x, y });
+    return await this._call('mobile_click_on_screen_at_coordinates', { x, y });
   }
 
   // Long-press at absolute screen coordinates. Optional duration (ms) overrides
@@ -52,18 +52,18 @@ class DeviceBridge {
   async longPress({ x, y, duration } = {}) {
     const args = { x, y };
     if (duration !== undefined) args.duration = duration;
-    return this._call('mobile_long_press_on_screen_at_coordinates', args);
+    return await this._call('mobile_long_press_on_screen_at_coordinates', args);
   }
 
   // Double-tap at absolute screen coordinates.
   async doubleTap({ x, y } = {}) {
-    return this._call('mobile_double_tap_on_screen', { x, y });
+    return await this._call('mobile_double_tap_on_screen', { x, y });
   }
 
   // Type into the focused element. We never auto-submit; pressing ENTER is a
   // distinct, explicit action via pressButton.
   async type(text) {
-    return this._call('mobile_type_keys', { text, submit: false });
+    return await this._call('mobile_type_keys', { text, submit: false });
   }
 
   // Swipe in a cardinal direction.
@@ -135,32 +135,32 @@ class DeviceBridge {
 
   // Press a hardware/system button (BACK, HOME, ENTER, ...).
   async pressButton(button) {
-    return this._call('mobile_press_button', { button });
+    return await this._call('mobile_press_button', { button });
   }
 
   // Launch an installed app by its package/bundle identifier.
   async launchApp(packageName) {
-    return this._call('mobile_launch_app', { packageName });
+    return await this._call('mobile_launch_app', { packageName });
   }
 
   // Install an app from a local artifact (apk/ipa) path.
   async installApp(appPath) {
-    return this._call('mobile_install_app', { path: appPath });
+    return await this._call('mobile_install_app', { path: appPath });
   }
 
   // Uninstall an app by its bundle/package identifier.
   async uninstallApp(appId) {
-    return this._call('mobile_uninstall_app', { bundle_id: appId });
+    return await this._call('mobile_uninstall_app', { bundle_id: appId });
   }
 
   // Open a URL (deep link or web) on the device.
   async openUrl(url) {
-    return this._call('mobile_open_url', { url });
+    return await this._call('mobile_open_url', { url });
   }
 
   // Set the device orientation ('portrait'/'landscape').
   async setOrientation(orientation) {
-    return this._call('mobile_set_orientation', { orientation });
+    return await this._call('mobile_set_orientation', { orientation });
   }
 
   // Crash reports currently readable on the device, as the agnostic crash

package/src/device/mobile-mcp-client.js

@@ -133,8 +133,8 @@ async function createCall({
     throw connectError(err, connectTimeoutMs);
   }
 
-  async function rawCall(toolName, args = {}) {
-    const res = await client.callTool({ name: toolName, arguments: args });
+  async function rawCall(toolName, toolArgs = {}) {
+    const res = await client.callTool({ name: toolName, arguments: toolArgs });
     return parseToolResult(res);
   }
   const { call } = makeCall({ rawCall, device });

package/src/device/resolve-connection.js

@@ -31,8 +31,6 @@ function defaultCreateCall(opts) {
   return require('./mobile-mcp-client').createCall(opts);
 }
 
-const NOOP_CLOSE = () => Promise.resolve();
-
 // Read the live daemon's pinned device from its handle, or null. A null pin
 // means the daemon serves whatever device mobile-mcp selected (matches any
 // request that doesn't pin a specific device).

package/src/device/session-daemon.js

@@ -386,7 +386,13 @@ async function startDaemon({
     clearFlush();
     if (!flush || stopping) return;
     if (!(delayMs > 0) || !Number.isFinite(delayMs)) return;
-    flushTimer = setTimeout(async () => {
+    // tick() never rejects (its flush() is wrapped), so `void` is honest here.
+    flushTimer = setTimeout(() => {
+      void tick();
+    }, delayMs);
+    if (typeof flushTimer.unref === 'function') flushTimer.unref();
+
+    async function tick() {
       if (stopping) return;
       if (inFlight > 0) {
         armFlush(delayMs);
@@ -402,8 +408,7 @@ async function startDaemon({
         // current caller.
       }
       armFlush(next);
-    }, delayMs);
-    if (typeof flushTimer.unref === 'function') flushTimer.unref();
+    }
   }
 
   async function stop(reason = 'explicit') {
@@ -541,7 +546,27 @@ async function startDaemon({
       return true;
     };
 
-    socket.on('data', async (chunk) => {
+    // A plain listener around an async body, never `socket.on('data', async …)`:
+    // the emitter ignores the returned promise, so a throw in the body would be
+    // an unhandled rejection, and bin/mauto-session-daemon.js exits on those.
+    // Found by @typescript-eslint/no-misused-promises (#164).
+    socket.on('data', (chunk) => {
+      handleData(chunk).catch(onHandlerError);
+    });
+
+    // Recorded, then the idle clock re-armed: handleData paused it for the
+    // frame that threw, and nothing else would restart it. The remaining frames
+    // of that chunk are lost; the socket and the daemon both keep serving.
+    function onHandlerError(err) {
+      safeObserve({
+        level: 'error',
+        event: 'daemon.handler_error',
+        message: err && (err.message || String(err)),
+      });
+      armIdle();
+    }
+
+    async function handleData(chunk) {
       const frames = parser.push(chunk);
       for (const f of frames) {
         // Pause the idle clock while we handle a frame so it can never fire
@@ -554,11 +579,20 @@ async function startDaemon({
           continue;
         }
         const req = f.value;
+        // Valid JSON is not yet a request: `null` would throw on `req.type`
+        // below, and a primitive or array is no frame the protocol defines.
+        if (req === null || typeof req !== 'object' || Array.isArray(req)) {
+          await reply({ id: null, ok: false, error: { message: 'malformed frame: not a JSON object' } });
+          armIdle();
+          continue;
+        }
 
         if (req.type === 'shutdown') {
           await reply({ id: req.id, ok: true, result: { stopping: true } });
           // Reply already flushed (awaited) — now tear down.
-          setImmediate(() => stop('shutdown').catch(() => {}));
+          setImmediate(() => {
+            stop('shutdown').catch(() => {});
+          });
           continue;
         }
         if (req.type === 'ping') {
@@ -616,7 +650,7 @@ async function startDaemon({
         await reply({ id: req.id, ok: false, error: { message: `unknown request type: ${req.type}` } });
         armIdle();
       }
-    });
+    }
 
     socket.on('error', () => {
       sockets.delete(socket);

package/src/mcp/server.js

@@ -31,11 +31,14 @@ function buildServer({ projectRoot } = {}) {
     { capabilities: { prompts: {} } }
   );
 
-  server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+  // Plain functions, not async: both handlers are synchronous, and the SDK
+  // accepts a result or a promise of one. It calls them inside a .then(), so a
+  // throw (an unknown prompt name) still becomes an MCP error reply.
+  server.setRequestHandler(ListPromptsRequestSchema, () => ({
     prompts: handlers.listPrompts(),
   }));
 
-  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+  server.setRequestHandler(GetPromptRequestSchema, (request) => {
     return handlers.getPrompt(request.params.name);
   });
 

package/src/memory/entries.js

@@ -12,6 +12,7 @@ const ENTRY_RE = /^-\s+\[(\d{4}-\d{2}-\d{2})\]\[asserted\]\s+(.*)$/;
 
 function sanitizeEntryText(raw) {
   return String(raw == null ? '' : raw)
+    // eslint-disable-next-line no-control-regex -- matching control chars is the point
     .replace(/[\u0000-\u001F\u007F]+/g, ' ') // control chars / newlines / tabs -> space
     .replace(/\s+/g, ' ')
     .trim();

package/src/observe/vocab.js

@@ -46,6 +46,7 @@ const EVENT_NAMES = Object.freeze([
   'daemon.engine_exit',
   'daemon.lock_conflict',
   'daemon.undeliverable',
+  'daemon.handler_error',
   // Emitted by the flush path, which lands in a later slice-5 task; declared
   // now because its event shape is already exercised by unit tests.
   'telemetry.flush',