@anuraghq/mobius 0.1.0 → 0.1.1

package/dist/execution/observe.js

@@ -152,7 +152,9 @@ export class ObservationStore {
     nextId() { return `o${++this.seq}`; }
     add(obs, fps) {
         this.history.push({ obs, fps });
-        if (this.history.length > 5)
+        // ponytail: settle/verify polls add an observation every ~100 ms, so a small window evicts the ids the agent
+        // just got from observe after one slow action. 64 covers a full verify timeout; the on-disk copy stays at 5.
+        if (this.history.length > 64)
             this.history.shift();
         if (!this.file)
             return;

package/dist/execution/session.d.ts

@@ -20,10 +20,15 @@ export declare const DEFAULT_ACTION_TIMEOUT_MS = 20000;
 export declare const DEFAULT_EXPECT_TIMEOUT_MS = 6000;
 /** Cold app launches (Flutter/RN on iOS) take longer than a tap to show; live run: Scapia was still on SpringBoard at 6 s. */
 export declare const LAUNCH_EXPECT_TIMEOUT_MS = 20000;
-/** Where to touch an element: the center of its on-screen part (an element partly above/left of the screen has negative
- *  bounds; its raw center can be off-screen). Given the screen, a point not covered by a smaller clickable element inside
- *  it: tapping a big card's center must not hit the item drawn there (live run: Swiggy's restaurant card opened a burger). */
-export declare const center: (e: Element, screen?: readonly Element[]) => {
+/**
+ * Where to tap an element: inside its on-screen part, off its own clickable children (a card's inner button),
+ * and off anything drawn over it (a floating toolbar, tab bar or sheet: a later element that isn't its ancestor).
+ * Throws when no point of it is visibly tappable, so a covered or off-screen target is never tapped "successfully".
+ */
+export declare const center: (e: Element, screen?: readonly Element[], size?: {
+    width: number;
+    height: number;
+}) => {
     x: number;
     y: number;
 };
@@ -32,6 +37,8 @@ export declare function expectationMet(obs: Observation, ex: Expect): boolean;
 export declare class DeviceSession {
     readonly connector: Connector;
     readonly store: ObservationStore;
+    /** The observation last shown to the agent (observe / list / snapshot): short refs like @e5 point into it, not into internal polls. */
+    shown: string | null;
     private readonly audit;
     private readonly policy;
     private readonly approver;
@@ -46,7 +53,11 @@ export declare class DeviceSession {
     /** Serialize work per device: one action at a time, no interleaved taps. */
     private exclusive;
     observe(): Promise<Observation>;
-    /** Re-observe until two consecutive screens hash the same (UI settled), bounded. State-based, no fixed sleeps. */
+    /**
+     * Re-observe until two consecutive screens hash the same (UI settled), bounded. State-based, no fixed sleeps.
+     * Two identical frames of the *pre-action* screen only count after a grace window: a tap that launches an
+     * activity takes a beat before the window changes, and settling early reports the old screen as the result.
+     */
     private settle;
     /** Every element containing the point on the latest screen (overlays, the button below them, its labels). */
     elementsAt(x: number, y: number): Element[];

package/dist/execution/session.js

@@ -10,32 +10,49 @@ export const DEFAULT_EXPECT_TIMEOUT_MS = 6_000;
 export const LAUNCH_EXPECT_TIMEOUT_MS = 20_000;
 /** Pause between re-reads while waiting for the screen. */
 const POLL_MS = 100;
+/** How long an unchanged pre-action screen is waited on before settle accepts it (see settle). */
+const SETTLE_GRACE_MS = 600;
 /** Text read from pixels, as an element the policy can judge like any label. */
 const drawnText = (text, bounds) => ({ id: 'drawn', role: 'text', text, label: null, resource_id: null,
     clickable: false, long_clickable: false, enabled: true, focused: false, scrollable: false, editable: false, checked: null, selected: false,
     sensitive: false, bounds, dup_index: 0 });
-/** Where to touch an element: the center of its on-screen part (an element partly above/left of the screen has negative
- *  bounds; its raw center can be off-screen). Given the screen, a point not covered by a smaller clickable element inside
- *  it: tapping a big card's center must not hit the item drawn there (live run: Swiggy's restaurant card opened a burger). */
-export const center = (e, screen) => {
+const has = (b, p) => p.x >= b.x && p.x <= b.x + b.width && p.y >= b.y && p.y <= b.y + b.height;
+const holds = (o, i) => o.x <= i.x && o.y <= i.y && o.x + o.width >= i.x + i.width && o.y + o.height >= i.y + i.height;
+/**
+ * Where to tap an element: inside its on-screen part, off its own clickable children (a card's inner button),
+ * and off anything drawn over it (a floating toolbar, tab bar or sheet: a later element that isn't its ancestor).
+ * Throws when no point of it is visibly tappable, so a covered or off-screen target is never tapped "successfully".
+ */
+export const center = (e, screen, size) => {
+    const W = size?.width || Infinity, H = size?.height || Infinity;
     const x1 = Math.max(e.bounds.x, 0), y1 = Math.max(e.bounds.y, 0);
-    const x2 = Math.max(e.bounds.x + e.bounds.width, x1), y2 = Math.max(e.bounds.y + e.bounds.height, y1);
+    const x2 = Math.min(e.bounds.x + e.bounds.width, W), y2 = Math.min(e.bounds.y + e.bounds.height, H);
+    if (x2 <= x1 || y2 <= y1) {
+        if (size)
+            throw new MobiusError('ELEMENT_NOT_FOUND', `${e.id} is off screen`, { hint: 'Scroll it into view, observe, then tap.' });
+        return { x: Math.max(x1, Math.min(x2, (x1 + x2) / 2)), y: Math.max(y1, Math.min(y2, (y1 + y2) / 2)) };
+    }
     const mid = { x: (x1 + x2) / 2, y: (y1 + y2) / 2 };
     if (!screen)
         return mid;
-    const inside = (o) => o.bounds.x >= e.bounds.x && o.bounds.y >= e.bounds.y && o.bounds.x + o.bounds.width <= e.bounds.x + e.bounds.width
-        && o.bounds.y + o.bounds.height <= e.bounds.y + e.bounds.height && o.bounds.width * o.bounds.height < e.bounds.width * e.bounds.height;
-    const kids = screen.filter(o => o !== e && o.id !== e.id && (o.clickable || o.editable) && inside(o));
-    if (!kids.length)
-        return mid;
-    const hit = (p) => kids.some(k => p.x >= k.bounds.x && p.x <= k.bounds.x + k.bounds.width && p.y >= k.bounds.y && p.y <= k.bounds.y + k.bounds.height);
+    const idx = screen.findIndex(o => o === e || o.id === e.id);
+    const area = (b) => b.width * b.height;
+    const kids = screen.filter(o => o !== e && o.id !== e.id && (o.clickable || o.editable) && holds(e.bounds, o.bounds) && area(o.bounds) < area(e.bounds));
+    // Drawn on top: later in tree order, overlapping, neither its ancestor nor its descendant, and not a decoration
+    // that passes touches through (plain text/images inside the overlap still block a tap on what's below).
+    const over = idx < 0 ? [] : screen.slice(idx + 1).filter(o => !holds(o.bounds, e.bounds) && !holds(e.bounds, o.bounds)
+        && (o.clickable || o.editable || o.scrollable || /toolbar|tab ?bar|navigation bar|sheet/i.test(`${o.label ?? ''} ${o.text ?? ''}`)));
+    const blocked = (p) => kids.some(k => has(k.bounds, p)) || over.some(o => has(o.bounds, p));
     const at = (fx, fy) => ({ x: x1 + (x2 - x1) * fx, y: y1 + (y2 - y1) * fy });
     for (const [fx, fy] of [[0.5, 0.5], [0.5, 0.12], [0.12, 0.5], [0.88, 0.5], [0.5, 0.88], [0.12, 0.12], [0.88, 0.12], [0.12, 0.88], [0.88, 0.88], [0.3, 0.12], [0.7, 0.12]]) {
         const p = at(fx, fy);
-        if (!hit(p))
+        if (!blocked(p))
             return p;
     }
-    return mid; // fully covered: the children are the target in practice
+    if (over.length && [[0.5, 0.5], [0.12, 0.12], [0.88, 0.88]].every(([fx, fy]) => over.some(o => has(o.bounds, at(fx, fy))))) {
+        throw new MobiusError('ELEMENT_NOT_FOUND', `${e.id} is covered by ${over.map(o => o.label || o.text || o.role).slice(0, 2).join(', ')}`, { hint: 'Scroll it into view, observe, then tap.' });
+    }
+    return mid; // fully covered by its own children: the children are the target in practice
 };
 function withTimeout(p, ms, what) {
     let timer;
@@ -62,6 +79,8 @@ export function expectationMet(obs, ex) {
 export class DeviceSession {
     connector;
     store;
+    /** The observation last shown to the agent (observe / list / snapshot): short refs like @e5 point into it, not into internal polls. */
+    shown = null;
     audit;
     policy;
     approver;
@@ -86,7 +105,7 @@ export class DeviceSession {
             await this.observe();
         const latest = this.store.latest();
         let target = guard.targetId ? this.store.resolve(guard.targetId) : guard.point ? this.elementAt(guard.point.x, guard.point.y) : null;
-        const p = guard.point ?? (target ? center(target, latest?.elements) : null);
+        const p = guard.point ?? (target ? center(target, latest?.elements, latest?.screen) : null);
         const under = p ? this.elementsAt(p.x, p.y) : [];
         // Pixels, not just labels: on a screen showing an amount due, read the text actually drawn where the finger lands
         // (OCR), so a Pay button can't hide behind an accessibility label that says "Close".
@@ -159,13 +178,18 @@ export class DeviceSession {
         this.store.add(obs, fps);
         return obs;
     }
-    /** Re-observe until two consecutive screens hash the same (UI settled), bounded. State-based, no fixed sleeps. */
-    async settle(deadline) {
+    /**
+     * Re-observe until two consecutive screens hash the same (UI settled), bounded. State-based, no fixed sleeps.
+     * Two identical frames of the *pre-action* screen only count after a grace window: a tap that launches an
+     * activity takes a beat before the window changes, and settling early reports the old screen as the result.
+     */
+    async settle(deadline, preHash = null) {
+        const graceEnd = Date.now() + SETTLE_GRACE_MS;
         let prev = await this.observe();
         while (Date.now() < deadline) {
             await new Promise(r => setTimeout(r, POLL_MS));
             const next = await this.observe();
-            if (next.screen_hash === prev.screen_hash)
+            if (next.screen_hash === prev.screen_hash && (next.screen_hash !== preHash || Date.now() >= graceEnd))
                 return next;
             prev = next;
         }
@@ -199,7 +223,7 @@ export class DeviceSession {
             const el = this.store.resolve(element_id);
             if (!el.enabled)
                 throw new MobiusError('ELEMENT_NOT_FOUND', `${element_id} is disabled`, { hint: 'Wait for it to enable or pick another element.' });
-            return { ...center(el, this.store.latest()?.elements), el };
+            return { ...center(el, this.store.latest()?.elements, this.store.latest()?.screen), el };
         }
         if (x !== undefined && y !== undefined) {
             const s = this.store.latest()?.screen;
@@ -235,7 +259,7 @@ export class DeviceSession {
                 const message = await withTimeout(exec(target), opts.timeoutMs ?? DEFAULT_ACTION_TIMEOUT_MS, tool);
                 const verifying = !!opts.expect || !!opts.check;
                 const deadline = Date.now() + (verifying ? opts.verifyMs ?? DEFAULT_EXPECT_TIMEOUT_MS : 2_500);
-                let obs = await this.settle(Math.min(deadline, Date.now() + 2_500));
+                let obs = await this.settle(Math.min(deadline, Date.now() + 2_500), preHash);
                 let verified = null;
                 let why = '';
                 const evaluate = (o) => {

package/dist/interface/mcp.js

@@ -116,6 +116,7 @@ export function createServer(mobius) {
         const obs = await s.observe();
         if (s.isBlockedApp(obs.foreground_app))
             return json(blockedView(obs));
+        s.shown = obs.observation_id;
         const out = json(compactObservation(obs));
         if (!screenshot)
             return out;

package/dist/interface/mobius-tools.js

@@ -9,6 +9,7 @@ import { driverPath } from "../execution/drivers/mobiusagent.js";
 import { z } from 'zod';
 import { MobiusError } from "../execution/connector.js";
 import { scrub } from "../execution/observe.js";
+import { center } from "../execution/session.js";
 const device = z.string().describe('The device identifier. Use mobius_list_available_devices to find which devices are available.');
 const xy = {
     x: z.coerce.number().min(0).optional().describe('x in screen coordinates. Required unless ref is given.'),
@@ -29,15 +30,18 @@ export function registerMobiusTools(server, handlers, mobius, h) {
         if (aliases)
             server.registerTool(`mobile_${name}`, cfg, cb);
     };
-    /** "@e5" (short ref) → the id on the latest observation of that device. */
+    /**
+     * "@e5" (short ref) → the id on the observation the agent last saw (list_elements / snapshot), so a ref the agent
+     * read is resolved by identity (or refused as stale) after the screen moves, never re-pointed at whatever is e5 now.
+     */
     const elementId = async (dev, ref) => {
         if (!ref)
             return undefined;
         if (!ref.startsWith('@'))
             return ref;
         const s = await mobius.session(dev);
-        const obs = s.store.latest() ?? await s.observe();
-        return `${obs.observation_id}:${ref.slice(1)}`;
+        const shown = s.shown ?? s.store.latest()?.observation_id ?? (await s.observe()).observation_id;
+        return `${shown}:${ref.slice(1)}`;
     };
     /** A driver operation beyond the core set, through the same pipeline (gate + audit) as every other action. */
     const extra = async (dev, tool, op, args, opts) => {
@@ -101,14 +105,49 @@ export function registerMobiusTools(server, handlers, mobius, h) {
         const hay = [e.text, e.label].filter(Boolean).map(v => norm(String(v)));
         return exact ? hay.some(h => h === norm(q)) : hay.some(h => h.includes(norm(q)));
     };
+    /** Visibly tappable: on screen and not under a floating bar (the same rule the tap itself applies). */
+    const tappable = (e, o) => { try {
+        center(e, o.elements, o.screen);
+        return true;
+    }
+    catch {
+        return false;
+    } };
+    /** Scroll until an element showing `text` is tappable, or the list stops moving. */
+    const scrollTo = async (device, text, direction, max) => {
+        const s = await mobius.session(device);
+        let prev = '';
+        for (let i = 0; i <= max; i++) {
+            const o = await s.observe();
+            const el = o.elements.find(e => matches(e, text, false) && tappable(e, o));
+            if (el) {
+                s.shown = o.observation_id;
+                return { ...el, swipes: i };
+            }
+            if (o.screen_hash === prev)
+                return null; // end of the list
+            prev = o.screen_hash;
+            const r = await call('scroll', { device_id: device, direction });
+            if (r.isError)
+                throw new MobiusError(JSON.parse(r.content[0].text).error?.code ?? 'INTERNAL', JSON.parse(r.content[0].text).message ?? 'scroll failed');
+        }
+        return null;
+    };
     tool('tap_text', 'Tap Text', 'Find the element showing this text (or accessibility label) on the current screen and tap it. Prefers buttons and clickable elements. Saves an observe + pick round-trip.', { device, text: z.string().min(1), exact: z.boolean().optional(), index: z.number().int().min(0).optional().describe('Which match, if several (default 0).') }, async ({ device, text, exact, index }) => {
         const s = await mobius.session(device);
         const o = await s.observe();
         const hits = o.elements.filter(e => matches(e, text, !!exact));
         const ranked = [...hits.filter(e => e.clickable || e.role === 'button'), ...hits.filter(e => !(e.clickable || e.role === 'button'))];
         const el = ranked[index ?? 0];
-        if (el)
+        if (el && tappable(el, o))
             return call('tap', { device_id: device, element_id: el.id });
+        if (el) {
+            // On screen in the tree but off its edge or under a floating bar: bring it into view, then tap the fresh match.
+            const found = await scrollTo(device, text, el.bounds.y > o.screen.height / 2 ? 'down' : 'up', 5);
+            if (found)
+                return call('tap', { device_id: device, element_id: found.id });
+            throw new MobiusError('ELEMENT_NOT_FOUND', `"${text}" is on this screen but covered or off its edge, and scrolling did not reveal it`, { hint: 'Scroll manually, observe, then tap.' });
+        }
         // Not in the accessibility tree: read what's drawn on screen (OCR) and tap it by position. Coordinate taps go
         // through the same gate (and count as unidentified targets where policy asks).
         const ocr = s.connector.extra ? await s.connector.extra('ocr', {}).catch(() => null) : null;
@@ -119,20 +158,9 @@ export function registerMobiusTools(server, handlers, mobius, h) {
         return call('tap', { device_id: device, x: x + w / 2, y: y + h / 2 });
     });
     tool('scroll_until_visible', 'Scroll Until Visible', 'Scroll until an element showing this text is on screen (or the list stops moving). Returns its ref.', { device, text: z.string().min(1), direction: z.enum(['up', 'down', 'left', 'right']).optional(), max_swipes: z.number().int().min(1).max(30).optional() }, async ({ device, text, direction, max_swipes }) => {
-        const s = await mobius.session(device);
-        let prev = '';
-        for (let i = 0; i <= (max_swipes ?? 10); i++) {
-            const o = await s.observe();
-            const el = o.elements.find(e => matches(e, text, false) && e.bounds.width > 0 && e.bounds.y >= 0 && e.bounds.y + e.bounds.height <= o.screen.height);
-            if (el)
-                return json({ found: true, ref: el.id, swipes: i, element: { role: el.role, text: el.text, label: el.label, box: [el.bounds.x, el.bounds.y, el.bounds.width, el.bounds.height] } });
-            if (o.screen_hash === prev)
-                break; // end of the list
-            prev = o.screen_hash;
-            const r = await call('scroll', { device_id: device, direction: direction ?? 'down' });
-            if (r.isError)
-                return r;
-        }
+        const el = await scrollTo(device, text, direction ?? 'down', max_swipes ?? 10);
+        if (el)
+            return json({ found: true, ref: el.id, swipes: el.swipes, element: { role: el.role, text: el.text, label: el.label, box: [el.bounds.x, el.bounds.y, el.bounds.width, el.bounds.height] } });
         return json({ found: false, hint: `"${text}" did not appear; try the other direction or check the screen.` });
     }, true);
     tool('wait_for', 'Wait For', 'Wait until text appears, disappears, or an app is in the foreground (polls the screen, no fixed sleeps).', { device, text_visible: z.string().optional(), text_gone: z.string().optional(), app: z.string().optional(), timeout_ms: z.number().int().min(500).max(120_000).optional() }, ({ device, ...rest }) => call('wait_for', { device_id: device, ...rest }), true);
@@ -181,7 +209,18 @@ export function registerMobiusTools(server, handlers, mobius, h) {
     drv('performance_report', 'Performance Report', 'Full performance report for an app: cold/warm launch time, CPU, memory (with leak trend), threads, frame rate and jank, battery, crashes during the session. Optional budgets give pass/fail (e.g. {"launch_cold_ms":2000,"jank_percent":5,"memory_max_mb":400}). Writes an HTML report when `output` ends in .html.', { packageName: app, seconds: z.number().int().min(3).max(1800).optional(), budget: z.record(z.string(), z.number()).optional(), output: z.string().optional() }, 'perf_report', a => ({ app: a.packageName, seconds: a.seconds ?? 30, ...(a.budget ? { budget: a.budget } : {}), ...(a.output ? { output: a.output } : {}) }), { mutating: true, app: a => a.packageName });
     drv('accessibility_audit', 'Accessibility Audit', 'Audit the current screen: unlabeled controls, touch targets below 44pt/48dp, duplicate labels, with a score.', {}, 'a11y_audit', () => ({}), { readOnly: true, scrub: true });
     drv('screen_diff', 'Screen Diff', 'What changed on screen since the last snapshot or diff (added/removed elements). Read the change, not the whole tree.', {}, 'diff', () => ({}), { readOnly: true, scrub: true });
-    drv('snapshot', 'Text Snapshot', 'The screen as compact text, one element per line with refs (@e5) usable by click tools.', {}, 'snapshot', () => ({}), { readOnly: true, scrub: true });
+    tool('snapshot', 'Text Snapshot', 'The screen as compact text, one element per line with refs (@e5) usable by click tools.', { device }, async ({ device }) => {
+        const s = await mobius.session(device);
+        const o = await s.observe();
+        s.shown = o.observation_id;
+        const lines = o.elements.map(e => {
+            const words = [e.text, e.label && e.label !== e.text ? e.label : ''].filter(Boolean).map(t => JSON.stringify(t)).join(' ');
+            const rid = e.resource_id ? ` #${e.resource_id.replace(/^[\w.]+:id\//, '')}` : '';
+            const flags = [e.clickable && 'clickable', e.editable && 'editable', e.scrollable && 'scrollable', !e.enabled && 'disabled', e.focused && 'focused', e.sensitive && 'sensitive'].filter(Boolean);
+            return `@${e.id.split(':')[1]} [${e.role}] ${words}${rid}${flags.length ? ` (${flags.join(', ')})` : ''}`.replace(/  +/g, ' ');
+        });
+        return json({ app: o.foreground_app, observation_id: o.observation_id, snapshot: lines.join('\n') });
+    }, true);
     drv('wait_until_idle', 'Wait Until Idle', 'Wait until the screen stops changing.', { timeout_ms: z.number().int().min(200).max(60_000).optional() }, 'wait_idle', a => ({ timeout_ms: a.timeout_ms ?? 5000 }), { readOnly: true });
     drv('read_screen_text', 'Read Screen Text (OCR)', 'Every piece of text drawn on screen with its box, including unlabeled buttons and images. Secrets are masked.', {}, 'ocr', () => ({}), { readOnly: true, scrub: true });
     drv('set_dark_mode', 'Set Dark Mode', 'Turn dark mode on or off (Android, iOS simulators/devices).', { on: z.boolean() }, 'dark_mode', a => ({ on: a.on }), { mutating: true });
@@ -201,7 +240,8 @@ export function registerMobiusTools(server, handlers, mobius, h) {
         const s = await mobius.session(a.device);
         if ((await s.observe()).elements.some(e => e.sensitive))
             throw new MobiusError('POLICY_BLOCKED', 'A password, PIN, OTP or card number is on screen, so no screenshot was taken');
-        const { data } = await extra(a.device, 'element_screenshot', 'element_screenshot', { ref: a.ref }, { mutating: false, describe: 'Element screenshot' });
+        const el = s.store.resolve((await elementId(a.device, a.ref)));
+        const { data } = await extra(a.device, 'element_screenshot', 'element_screenshot', { box: [el.bounds.x, el.bounds.y, el.bounds.width, el.bounds.height] }, { mutating: false, describe: 'Element screenshot' });
         return { content: [{ type: 'image', data: data.data, mimeType: data.mimeType }] };
     }, true);
     drv('play_gps_route', 'Play GPS Route', 'Move the device along waypoints ("lat,lon;lat,lon") at a speed, for ride and delivery flows.', { points: z.string(), speed_kmh: z.number().min(1).max(300).optional(), interval_s: z.number().min(0.2).max(10).optional() }, 'gps_route', a => ({ points: a.points, speed_kmh: a.speed_kmh ?? 30, interval_s: a.interval_s ?? 1 }), { mutating: true });

package/ios-agent/setup.sh

@@ -15,12 +15,18 @@ cd "$DIR"
 # Mobius fast touch (tap/swipe without WebDriverAgent's app lookup and settle wait). BSD-3 allows shipping a modified build.
 PATCH="$HERE/wda-mobius-fast-touch.patch"
 git apply --check "$PATCH" 2>/dev/null && git apply "$PATCH" && echo "applied Mobius fast-touch patch"
-xcodebuild build-for-testing -project WebDriverAgent.xcodeproj -scheme WebDriverAgentRunner \
+# Run xcodebuild into a log and stop on failure: piping it through grep would hide a failed build, and a stale
+# .xctestrun from an earlier build would then pass the final check.
+build() { # build <log name> <xcodebuild args...>
+  log="$DIR/$1.log"; shift
+  if xcodebuild "$@" >"$log" 2>&1; then grep -E "\*\* " "$log" || true; else grep -E "error:|\*\* " "$log"; echo "xcodebuild failed (full log: $log)" >&2; exit 1; fi
+}
+build build-device build-for-testing -project WebDriverAgent.xcodeproj -scheme WebDriverAgentRunner \
   -destination 'generic/platform=iOS' DEVELOPMENT_TEAM="$TEAM" CODE_SIGN_STYLE=Automatic \
   PRODUCT_BUNDLE_IDENTIFIER="${MOBIUS_WDA_BUNDLE:-dev.mobius.wda}" \
-  -allowProvisioningUpdates -allowProvisioningDeviceRegistration -derivedDataPath "$DIR/build" | grep -E "error:|\*\* " || true
+  -allowProvisioningUpdates -allowProvisioningDeviceRegistration -derivedDataPath "$DIR/build"
 "$HERE/brand.sh"
 # Simulators: an unsigned simulator build (no team needed).
-xcodebuild build-for-testing -project WebDriverAgent.xcodeproj -scheme WebDriverAgentRunner \
-  -destination 'generic/platform=iOS Simulator' -derivedDataPath "$DIR/build-sim" CODE_SIGNING_ALLOWED=NO | grep -E "error:|\*\* " || true
+build build-sim build-for-testing -project WebDriverAgent.xcodeproj -scheme WebDriverAgentRunner \
+  -destination 'generic/platform=iOS Simulator' -derivedDataPath "$DIR/build-sim" CODE_SIGNING_ALLOWED=NO
 ls "$DIR"/build/Build/Products/*.xctestrun >/dev/null && echo "WebDriverAgent ready in $DIR"

package/package.json

@@ -1,18 +1,47 @@
 {
   "name": "@anuraghq/mobius",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Let AI agents use a real phone, safely. MCP server + its own fast device driver for Android, iPhones and iOS simulators: 75 tools, approvals, policy, masking, signed audit, performance and accessibility reports.",
   "license": "Apache-2.0",
   "type": "module",
-  "bin": { "mobius": "dist/cli.js" },
-  "files": ["dist", "bin", "ios-agent", "README.md", "LICENSE"],
-  "engines": { "node": ">=22.5" },
-  "keywords": ["mcp", "model-context-protocol", "android", "ios", "iphone", "simulator", "emulator", "mobile", "ai-agent", "agent-safety", "claude", "automation", "testing", "qa", "performance", "accessibility"],
+  "bin": {
+    "mobius": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "ios-agent",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22.5"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "android",
+    "ios",
+    "iphone",
+    "simulator",
+    "emulator",
+    "mobile",
+    "ai-agent",
+    "agent-safety",
+    "claude",
+    "automation",
+    "testing",
+    "qa",
+    "performance",
+    "accessibility"
+  ],
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.build.json",
     "prepack": "npm run build && node scripts/prepack.mjs"
   },
-  "publishConfig": { "access": "public" },
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": "github:Anu-Code07/mobius",
   "homepage": "https://github.com/Anu-Code07/mobius#readme",
   "dependencies": {