simframe 0.1.0 → 0.4.1

package/src/actions.js

@@ -0,0 +1,244 @@
+// The batch engine. A flow that would cost one model round trip per tap runs
+// here as a single call: act, wait for the screen to settle, assert, repeat.
+// Waiting uses a baseline captured BEFORE each action, which is the whole
+// reason these scripts are reliable rather than racy.
+import * as api from './index.js';
+import * as input from './input.js';
+import * as intent from './intent.js';
+import { launchApp, openUrl, setPasteboard, terminateApp } from './simctl.js';
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const MAX_PAUSE_MS = 5000;
+
+const ACTION_STEPS = new Set([
+  'tap', 'tapAt', 'type', 'paste', 'swipe', 'scroll', 'button', 'key',
+  'launch', 'terminate', 'openUrl', 'confirm', 'chooseAny',
+]);
+
+/** Accept both `{tap: "Save"}` shorthand and `{action: "tap", target: "Save"}`. */
+export function normalizeStep(raw) {
+  if (typeof raw === 'string') return { action: raw };
+  if (raw.action) return { ...raw };
+  const [key] = Object.keys(raw);
+  if (!key) throw new Error('empty step');
+  // Siblings like timeoutMs sit alongside the shorthand key and must survive.
+  const { [key]: value, ...rest } = raw;
+  const inline = value && typeof value === 'object' && !Array.isArray(value) ? value : { value };
+  return { ...rest, ...inline, action: key };
+}
+
+export async function runScript(
+  deviceQuery,
+  { steps, autoSettle = true, stableMs = 500, timeoutMs = 8000, continueOnError = false, options } = {},
+) {
+  if (!Array.isArray(steps) || !steps.length) throw new Error('a script needs at least one step');
+  const { device } = await api.ensureDaemon(deviceQuery, options);
+  const udid = device.udid;
+  const startedAt = Date.now();
+
+  const needsInput = steps.some((s) => ACTION_STEPS.has(normalizeStep(s).action));
+  if (needsInput) {
+    const driver = await input.detectDriver();
+    if (!driver.available) throw new Error(driver.reason);
+  }
+
+  let geometry = null;
+  const screen = async () => (geometry ??= await input.screenInfo(udid));
+
+  const results = [];
+  const frames = [];
+  let failed = false;
+
+  for (const [i, raw] of steps.entries()) {
+    const step = normalizeStep(raw);
+    const stepStart = Date.now();
+    // The baseline for "did the screen react" must predate the action itself.
+    const before = (await api.getState(deviceQuery, { options })).state.hash;
+    try {
+      const detail = await runStep(deviceQuery, udid, step, { screen, options, frames });
+      let settled = null;
+      if (autoSettle && ACTION_STEPS.has(step.action)) {
+        const w = await api.waitFor(deviceQuery, {
+          mode: 'settle',
+          since: before,
+          stableMs: step.stableMs ?? stableMs,
+          timeoutMs: step.timeoutMs ?? timeoutMs,
+          options,
+        });
+        settled = {
+          ok: w.satisfied,
+          waitedMs: w.waitedMs,
+          sawChange: w.sawChange,
+          stalled: Boolean(w.stalled),
+          noVisibleChange: Boolean(w.noVisibleChange),
+        };
+      }
+      const note = settled?.noVisibleChange ? ' [no visible change]' : '';
+      results.push({
+        index: i,
+        action: step.action,
+        ok: true,
+        ms: Date.now() - stepStart,
+        detail: `${detail}${note}`,
+        settled,
+      });
+    } catch (err) {
+      results.push({ index: i, action: step.action, ok: false, ms: Date.now() - stepStart, error: err.message });
+      failed = true;
+      if (!continueOnError) break;
+    }
+  }
+
+  return {
+    device,
+    results,
+    ok: !failed,
+    totalMs: Date.now() - startedAt,
+    ranSteps: results.length,
+    totalSteps: steps.length,
+    frames,
+  };
+}
+
+async function runStep(deviceQuery, udid, step, ctx) {
+  switch (step.action) {
+    case 'tap': {
+      const query = step.value ?? step.target ?? step.label;
+      // Screen memory first: a familiar screen needs no tree read and no OCR.
+      const found = await api.locate(deviceQuery, query, { index: step.index, refresh: step.refresh });
+      await input.tapPoint(udid, found.target.x, found.target.y, { durationMs: step.durationMs });
+      return `tapped "${found.target.label}" at ${found.target.x},${found.target.y} (${found.from}${found.from === 'memory' ? ` d=${found.distance}` : ''}, via ${found.target.source})`;
+    }
+    case 'tapAt': {
+      const geo = await ctx.screen();
+      let { x, y } = step;
+      if (step.space === 'image') {
+        const frame = await api.getFrame(deviceQuery, { options: ctx.options });
+        ({ x, y } = input.imageToPoints({ x, y }, {
+          imageWidth: frame.width,
+          imageHeight: frame.height,
+          pointWidth: geo.pointWidth,
+          pointHeight: geo.pointHeight,
+        }));
+      }
+      await input.tapPoint(udid, x, y, { durationMs: step.durationMs });
+      return `tapped ${x},${y}`;
+    }
+    case 'type': {
+      if (step.into) {
+        const { node } = await input.tapLabel(udid, step.into, { index: step.index });
+        await sleep(150);
+        await input.typeText(udid, step.text ?? step.value);
+        return `typed into "${node.label ?? step.into}"`;
+      }
+      await input.typeText(udid, step.text ?? step.value);
+      return 'typed text';
+    }
+    case 'paste': {
+      // Long strings are much faster on the pasteboard than through the keyboard.
+      await setPasteboard(udid, step.text ?? step.value);
+      if (step.into) await input.tapLabel(udid, step.into, { index: step.index, durationMs: 900 });
+      return 'placed text on the pasteboard';
+    }
+    case 'swipe': {
+      const from = { x: step.from?.[0] ?? step.from?.x, y: step.from?.[1] ?? step.from?.y };
+      const to = { x: step.to?.[0] ?? step.to?.x, y: step.to?.[1] ?? step.to?.y };
+      await input.swipe(udid, from, to, { durationMs: step.durationMs });
+      return `swiped ${from.x},${from.y} -> ${to.x},${to.y}`;
+    }
+    case 'scroll': {
+      const geo = await ctx.screen();
+      const dir = String(step.value ?? step.direction ?? 'down').toLowerCase();
+      const midX = Math.round(geo.pointWidth / 2);
+      const midY = Math.round(geo.pointHeight / 2);
+      const span = Math.round(geo.pointHeight * 0.3);
+      const moves = {
+        down: [{ x: midX, y: midY + span }, { x: midX, y: midY - span }],
+        up: [{ x: midX, y: midY - span }, { x: midX, y: midY + span }],
+        left: [{ x: midX + span, y: midY }, { x: midX - span, y: midY }],
+        right: [{ x: midX - span, y: midY }, { x: midX + span, y: midY }],
+      };
+      if (!moves[dir]) throw new Error(`unknown scroll direction "${dir}"`);
+      await input.swipe(udid, moves[dir][0], moves[dir][1], { durationMs: step.durationMs ?? 250 });
+      return `scrolled ${dir}`;
+    }
+    case 'button':
+      await input.pressButton(udid, step.value ?? step.name);
+      return `pressed ${step.value ?? step.name}`;
+    case 'key':
+      await input.pressKey(udid, step.value ?? step.code);
+      return `pressed key ${step.value ?? step.code}`;
+    case 'launch':
+      await launchApp(udid, step.value ?? step.bundleId);
+      return `launched ${step.value ?? step.bundleId}`;
+    case 'terminate':
+      await terminateApp(udid, step.value ?? step.bundleId);
+      return `terminated ${step.value ?? step.bundleId}`;
+    case 'openUrl':
+      await openUrl(udid, step.value ?? step.url);
+      return `opened ${step.value ?? step.url}`;
+
+    // Human-level steps: act on what is on screen without reasoning about it.
+    case 'confirm': {
+      const geo = await ctx.screen();
+      const r = await intent.confirm(udid, { geo });
+      return `confirmed via "${r.label}" at ${r.point.x},${r.point.y}`;
+    }
+    case 'chooseAny': {
+      const geo = await ctx.screen();
+      const r = await intent.chooseAny(udid, { prefer: step.value ?? step.prefer, geo });
+      return `chose "${r.label}" of ${r.optionCount} options`;
+    }
+    case 'settle': {
+      const w = await api.waitFor(deviceQuery, {
+        mode: step.mode ?? 'stable',
+        stableMs: step.stableMs ?? 500,
+        timeoutMs: step.timeoutMs ?? 8000,
+        options: ctx.options,
+      });
+      if (!w.satisfied) throw new Error(w.stalled ? w.live.note : `screen did not settle within ${w.waitedMs}ms`);
+      return `settled after ${w.waitedMs}ms`;
+    }
+    case 'waitText': {
+      const target = step.value ?? step.text;
+      const limit = Date.now() + (step.timeoutMs ?? 8000);
+      let lastError = 'never appeared';
+      while (Date.now() < limit) {
+        try {
+          const node = input.matchElement(await input.describeAll(udid), target, { index: step.index });
+          return `"${node.label ?? target}" appeared`;
+        } catch (err) {
+          lastError = err.message;
+        }
+        await sleep(250);
+      }
+      throw new Error(`waited ${step.timeoutMs ?? 8000}ms for "${target}": ${lastError}`);
+    }
+    case 'assertText': {
+      const target = step.value ?? step.text;
+      const node = input.matchElement(await input.describeAll(udid), target, { index: step.index });
+      return `"${node.label ?? target}" is on screen`;
+    }
+    case 'assertGone': {
+      const target = step.value ?? step.text;
+      try {
+        input.matchElement(await input.describeAll(udid), target, { index: step.index });
+      } catch {
+        return `"${target}" is gone`;
+      }
+      throw new Error(`"${target}" is still on screen`);
+    }
+    case 'look': {
+      const frame = await api.getFrame(deviceQuery, { detail: step.detail ?? 'normal', options: ctx.options });
+      ctx.frames.push({ label: step.label ?? `step frame`, png: frame.png });
+      return `captured a frame (${frame.width}x${frame.height})`;
+    }
+    case 'pause': {
+      const ms = Math.min(MAX_PAUSE_MS, Number(step.value ?? step.ms ?? 0));
+      await sleep(ms);
+      return `paused ${ms}ms`;
+    }
+    default:
+      throw new Error(`unknown step "${step.action}"`);
+  }
+}

package/src/analyze.js

@@ -63,3 +63,62 @@ export function regionMap(deltas, cols = REGION_COLS) {
   }
   return lines.join('\n');
 }
+
+/** Signatures live in state.json, so they are stored as compact hex. */
+export function signatureToHex(sig) {
+  return sig.map((v) => v.toString(16).padStart(2, '0')).join('');
+}
+
+export function hexToSignature(hex) {
+  const out = [];
+  for (let i = 0; i < hex.length; i += 2) out.push(parseInt(hex.slice(i, i + 2), 16));
+  return out;
+}
+
+/**
+ * A hash of the screen's LAYOUT rather than its content.
+ *
+ * The frame hash changes whenever any pixel group changes — a clock digit, a new
+ * row of data — which makes it useless as a key for "have I seen this screen
+ * before?". This one skips the status bar and thresholds a coarse grid, so two
+ * visits to the same list with different rows still land close together, while a
+ * genuinely different screen lands far away.
+ */
+export const LAYOUT_COLS = 12;
+export const LAYOUT_ROWS = 24;
+export const LAYOUT_TOP_SKIP = 0.07; // the status bar, as a fraction of height
+
+export function layoutHash(bmp) {
+  const top = Math.floor(bmp.height * LAYOUT_TOP_SKIP);
+  const cropped = {
+    width: bmp.width,
+    height: bmp.height - top,
+    data: bmp.data.subarray(top * bmp.width * 4),
+  };
+  // A difference hash: each bit compares a cell with its right-hand neighbour.
+  // Thresholding against a global mean collapses low-contrast app screens onto
+  // the same value; local gradients stay discriminative.
+  const { gray } = grayGrid(cropped, LAYOUT_COLS + 1, LAYOUT_ROWS);
+  const bits = [];
+  for (let r = 0; r < LAYOUT_ROWS; r++) {
+    for (let c = 0; c < LAYOUT_COLS; c++) {
+      const i = r * (LAYOUT_COLS + 1) + c;
+      bits.push(gray[i] > gray[i + 1] ? 1 : 0);
+    }
+  }
+  let hex = '';
+  for (let i = 0; i < bits.length; i += 4) {
+    hex += (bits[i] | (bits[i + 1] << 1) | (bits[i + 2] << 2) | (bits[i + 3] << 3)).toString(16);
+  }
+  return hex;
+}
+
+const BITS = [0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4];
+
+/** Hamming distance between two hex hashes of equal length. */
+export function hashDistance(a, b) {
+  if (!a || !b || a.length !== b.length) return Infinity;
+  let d = 0;
+  for (let i = 0; i < a.length; i++) d += BITS[(parseInt(a[i], 16) ^ parseInt(b[i], 16)) & 0xf];
+  return d;
+}

package/src/cli.js

@@ -3,7 +3,9 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { runDaemon, DEFAULTS } from './daemon.js';
 import { bootedDevices, listDevices, resolveDevice } from './simctl.js';
+import * as actions from './actions.js';
 import * as api from './index.js';
+import * as input from './input.js';
 import * as store from './store.js';
 
 const USAGE = `simframe — always-warm iOS Simulator frames
@@ -14,8 +16,13 @@ const USAGE = `simframe — always-warm iOS Simulator frames
   simframe status  [device]          show daemon and newest-frame status
   simframe frame   [device]          write the newest frame to a file
   simframe state   [device]          print frame metadata and the change map
-  simframe wait    [device]          wait for the screen to settle
+  simframe mark    [device]          print the current frame hash, to use as --since
+  simframe wait    [device]          wait for the screen to react (see --mode)
   simframe strip   [device]          write a contact sheet of recent frames
+  simframe recall  [device]          what happened in the last minute (--ago=<ms> for a frame)
+  simframe ui      [device]          read the screen as an accessibility tree
+  simframe tap     <label>            tap an element by its accessibility label
+  simframe do      <script.json>      run a scripted flow (see below)
   simframe devices                   list simulators
   simframe doctor                    check that this machine can capture
 
@@ -25,9 +32,28 @@ Options
   --detail=low|normal|high|full   or --detail=<max pixels>
   --fps=<n>              capture rate while the screen is moving (default ${DEFAULTS.fps})
   --count=<n>            frames in a strip (default 5)
+  --since=<hash|seq>     compare against this frame (see: simframe mark)
+  --mode=settle|change|stable   what wait waits for (default settle)
   --stable-ms=<n>        settle window for wait (default 600)
   --timeout-ms=<n>       give up after this long (default 8000)
+  --force                let stop kill a loop another client is using
   --json                 machine-readable output
+
+A script is a JSON array of steps, run in one go with a settle between each:
+
+  [{"tap":"Assets"},{"tap":"Add Asset"},
+   {"type":{"into":"Name","text":"Fryer 3"}},
+   {"tap":"Save"},{"waitText":"Saved","timeoutMs":5000}]
+
+Input needs idb (brew tap facebook/fb && brew install idb-companion,
+then pipx install fb-idb). Observation works without it.
+
+The reliable pattern around an action is:
+
+  H=$(simframe mark)
+  ...tap, launch or navigate...
+  simframe wait --since=$H --mode=settle
+  simframe state --since=$H
 `;
 
 function parseArgs(argv) {
@@ -99,8 +125,16 @@ async function main() {
           : []
         : [(await resolveDevice(device)).udid];
       let stopped = 0;
-      for (const udid of targets) if (api.stopDaemon(udid)) stopped++;
-      console.log(`stopped ${stopped} daemon${stopped === 1 ? '' : 's'}`);
+      let inUse = 0;
+      for (const udid of targets) {
+        const result = api.stopDaemon(udid, { force: Boolean(flags.force) });
+        if (result === 'in-use') inUse++;
+        else if (result) stopped++;
+      }
+      console.log(
+        `stopped ${stopped} daemon${stopped === 1 ? '' : 's'}` +
+          (inUse ? `; left ${inUse} in use by another client (pass --force to stop anyway)` : ''),
+      );
       return;
     }
 
@@ -147,30 +181,71 @@ async function main() {
       return;
     }
 
-    case 'state': {
+    case 'mark': {
       const res = await api.getState(device, { options });
+      console.log(res.state.hash);
+      return;
+    }
+
+    case 'state': {
+      const res = await api.getState(device, { since: flags.since, options });
       if (flags.json) {
-        console.log(JSON.stringify({ ...res.state, ageMs: res.ageMs }, null, 2));
+        console.log(JSON.stringify({ ...res.state, history: undefined, ageMs: res.ageMs, since: res.since, live: res.live }, null, 2));
       } else {
         const s = res.state;
-        console.log(
-          `${res.device.name}  frame #${s.seq}  age ${res.ageMs}ms  ${s.width}x${s.height}\n` +
-            `hash ${s.hash}  diff ${s.diff}  stable ${s.stableForMs}ms\n${res.map}`,
-        );
+        const out = [];
+        if (!res.live.ok) out.push(`WARNING: ${res.live.note}`);
+        out.push(`${res.device.name}  frame #${s.seq}  age ${res.ageMs}ms  ${s.width}x${s.height}`);
+        out.push(`hash ${s.hash}  stable ${s.stableForMs}ms`);
+        if (res.since?.kind === 'history') {
+          out.push(
+            res.since.changed
+              ? `CHANGED since ${res.since.ageMs}ms ago: ${(res.since.diff * 100).toFixed(1)}% of the screen`
+              : `unchanged since ${res.since.ageMs}ms ago`,
+            res.since.map,
+          );
+        } else if (res.since?.kind === 'coarse') {
+          out.push(`${res.since.changed ? 'CHANGED' : 'unchanged'} since your baseline (too old for a detailed diff)`);
+        } else if (res.since?.kind === 'unmatched') {
+          out.push(`baseline ${res.since.requested} is not in the buffered history`);
+        } else {
+          out.push(
+            s.firstFrame
+              ? 'first frame of this capture loop — nothing to compare against yet'
+              : `change vs the previous frame only: ${(s.diff * 100).toFixed(1)}%`,
+          );
+          if (!s.firstFrame) out.push(res.map);
+        }
+        console.log(out.join('\n'));
       }
       return;
     }
 
     case 'wait': {
       const res = await api.waitFor(device, {
-        mode: flags.mode || (flags.change ? 'change' : 'stable'),
+        mode: flags.mode || (flags.change ? 'change' : 'settle'),
+        since: flags.since,
         stableMs: num(flags.stableMs, 600),
         timeoutMs: num(flags.timeoutMs, 8000),
         options,
       });
-      console.log(
-        `${res.satisfied ? 'settled' : 'timed out'} after ${res.waitedMs}ms — frame #${res.state.seq}, stable ${res.state.stableForMs}ms`,
-      );
+      if (res.satisfied) {
+        console.log(
+          `${res.mode === 'change' ? 'changed' : 'settled'} after ${res.waitedMs}ms — frame #${res.state.seq}` +
+            (res.changedBeforeWait ? ' (change had already happened before the call)' : ''),
+        );
+      } else if (res.noVisibleChange) {
+        console.log(
+          `no visible change after ${res.waitedMs}ms — screen stable, nothing moved (the action may have had no visible effect)`,
+        );
+      } else if (res.stalled) {
+        console.log(`capture stalled after ${res.waitedMs}ms — ${res.live.note}`);
+      } else {
+        console.log(
+          `timed out after ${res.waitedMs}ms — no ${res.mode === 'change' ? 'change' : 'settle'}` +
+            (res.sawChange ? '' : '; if the change happened before this call, pass `--since` from `simframe mark`'),
+        );
+      }
       process.exitCode = res.satisfied ? 0 : 1;
       return;
     }
@@ -189,6 +264,100 @@ async function main() {
       return;
     }
 
+    case 'recall': {
+      if (flags.ago != null) {
+        const res = await api.getFrameAt(device, { msAgo: num(flags.ago), options });
+        const out = flags.out || path.join(process.cwd(), 'simframe-recall.png');
+        fs.writeFileSync(out, res.png);
+        console.log(
+          `${out} — frame #${res.seq} from ${Math.round(res.actualMsAgo)}ms ago ` +
+            `(memory reaches back ${Math.round(res.oldestMsAgo / 1000)}s)`,
+        );
+        return;
+      }
+      const res = await api.getTimeline(device, { spanMs: num(flags.spanMs, 60_000), options });
+      if (flags.json) {
+        console.log(JSON.stringify({ ...res, state: undefined }, null, 2));
+        return;
+      }
+      console.log(
+        `${res.device.name} — remembering ${Math.round(res.coveredMs / 1000)}s, ${res.buffered} frames buffered`,
+      );
+      if (!res.events.length) {
+        console.log(`nothing changed; still for ${Math.round(res.idleForMs / 1000)}s`);
+      } else {
+        for (const e of res.events) {
+          console.log(
+            `  ${(e.startedMsAgo / 1000).toFixed(1)}s ago  ${e.level === 'major' ? 'screen changed' : 'small change '}  ` +
+              `${(e.magnitude * 100).toFixed(0)}%  over ${(e.durationMs / 1000).toFixed(1)}s`,
+          );
+        }
+        console.log(`still for ${(res.idleForMs / 1000).toFixed(1)}s`);
+      }
+      return;
+    }
+
+    case 'ui': {
+      const { device: dev } = await api.ensureDaemon(device, options);
+      const driver = await input.detectDriver();
+      if (!driver.available) {
+        process.stderr.write(`${driver.reason}\n`);
+        process.exitCode = 1;
+        return;
+      }
+      let nodes = await input.describeAll(dev.udid);
+      if (flags.filter) {
+        const q = String(flags.filter).toLowerCase();
+        nodes = nodes.filter((n) => [n.label, n.value, n.identifier].filter(Boolean).join(' ').toLowerCase().includes(q));
+      }
+      if (flags.json) {
+        console.log(JSON.stringify(nodes.map(({ raw, ...n }) => n), null, 2));
+        return;
+      }
+      for (const n of nodes) {
+        const c = input.centerOf(n);
+        console.log(
+          `${(n.type || '?').padEnd(14)} ${String(`${c.x},${c.y}`).padEnd(10)} ` +
+            `${[n.label, n.value && `= ${n.value}`, n.identifier && `#${n.identifier}`].filter(Boolean).join(' ') || '(unlabelled)'}`,
+        );
+      }
+      return;
+    }
+
+    case 'tap': {
+      const label = positional[0];
+      if (!label) throw new Error('usage: simframe tap <label>');
+      const res = await actions.runScript(flags.device, {
+        steps: [{ tap: label, index: flags.index != null ? num(flags.index) : undefined }],
+        options,
+      });
+      const step = res.results[0];
+      if (!step.ok) throw new Error(step.error);
+      console.log(`${step.detail}${step.settled?.ok ? `, settled in ${step.settled.waitedMs}ms` : ''}`);
+      return;
+    }
+
+    case 'do': {
+      const file = positional[0];
+      if (!file) throw new Error('usage: simframe do <script.json>');
+      const steps = JSON.parse(fs.readFileSync(file, 'utf8'));
+      const res = await actions.runScript(flags.device, {
+        steps,
+        autoSettle: flags.autoSettle !== 'false',
+        stableMs: num(flags.stableMs, 500),
+        timeoutMs: num(flags.timeoutMs, 8000),
+        continueOnError: Boolean(flags.continueOnError),
+        options,
+      });
+      for (const r of res.results) {
+        const settle = r.settled ? (r.settled.ok ? ` (settled ${r.settled.waitedMs}ms)` : ' (never settled)') : '';
+        console.log(`${r.ok ? 'ok  ' : 'FAIL'} [${r.index}] ${r.action}: ${r.ok ? r.detail : r.error}${settle}`);
+      }
+      console.log(`${res.ok ? 'flow completed' : 'FLOW FAILED'} — ${res.ranSteps}/${res.totalSteps} steps in ${res.totalMs}ms`);
+      process.exitCode = res.ok ? 0 : 1;
+      return;
+    }
+
     case 'devices': {
       const all = await listDevices();
       const shown = flags.all ? all : all.filter((d) => d.state === 'Booted');
@@ -231,6 +400,15 @@ async function doctor() {
   } catch (err) {
     add('sips', false, err.message);
   }
+  const driver = await input.detectDriver();
+  add('input driver (idb)', driver.available, driver.available ? driver.version : driver.reason);
+  try {
+    const ocr = await import('./ocr.js');
+    const built = await ocr.ensureBinary();
+    add('on-device OCR', built.available, built.available ? 'available' : built.reason);
+  } catch (err) {
+    add('on-device OCR', false, err.message);
+  }
   try {
     const booted = await bootedDevices();
     add('booted simulator', booted.length > 0, booted.map((d) => `${d.name} (${d.runtime})`).join(', ') || 'none');
@@ -243,8 +421,13 @@ async function doctor() {
     add('capture', false, err.message);
   }
 
-  for (const c of checks) console.log(`${c.ok ? 'ok  ' : 'FAIL'} ${c.name.padEnd(18)} ${c.detail}`);
-  process.exitCode = checks.every((c) => c.ok) ? 0 : 1;
+  for (const c of checks) {
+    const mark = c.ok ? 'ok  ' : c.name.startsWith('input driver') ? 'none' : 'FAIL';
+    console.log(`${mark} ${c.name.padEnd(18)} ${c.detail}`);
+  }
+  // Input is optional: simframe is still useful as a pure observer.
+  const required = checks.filter((c) => !c.name.startsWith('input driver'));
+  process.exitCode = required.every((c) => c.ok) ? 0 : 1;
 }
 
 main().catch((err) => {