verikun 0.4.1 → 0.7.0

package/dist/ui/ios-parse.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInteresting = isInteresting;
+exports.parseIosHierarchy = parseIosHierarchy;
+// XCUIElementType names (idb `type`) that are meaningful tap targets — used to
+// derive `clickable`, which iOS accessibility does not expose as a flag.
+const TAPPABLE_TYPES = new Set([
+    'Button', 'Cell', 'Link', 'MenuItem', 'MenuButton', 'PopUpButton', 'CheckBox',
+    'RadioButton', 'Switch', 'Toggle', 'SegmentedControl', 'Tab', 'Key', 'Stepper',
+    'Icon', 'SearchField', 'TextField', 'SecureTextField', 'DatePicker',
+]);
+const SCROLLABLE_TYPES = new Set(['ScrollView', 'Table', 'TableView', 'CollectionView', 'WebView']);
+const CHECKABLE_TYPES = new Set(['Switch', 'Toggle', 'CheckBox', 'RadioButton']);
+const TEXT_INPUT_TYPES = new Set(['TextField', 'SecureTextField', 'SearchField', 'TextView']);
+function str(v) {
+    return typeof v === 'string' ? v : v == null ? '' : String(v);
+}
+function isTrue(v) {
+    if (v === true)
+        return true;
+    const s = str(v).trim().toLowerCase();
+    return s === '1' || s === 'true' || s === 'on' || s === 'yes';
+}
+function stripAx(role) {
+    return role.startsWith('AX') ? role.slice(2) : role;
+}
+function parseFrame(raw) {
+    const f = raw.frame;
+    if (f &&
+        typeof f.x === 'number' &&
+        typeof f.y === 'number' &&
+        typeof f.width === 'number' &&
+        typeof f.height === 'number') {
+        return {
+            x1: Math.round(f.x),
+            y1: Math.round(f.y),
+            x2: Math.round(f.x + f.width),
+            y2: Math.round(f.y + f.height),
+        };
+    }
+    // Fallback: AXFrame is a string like "{{x, y}, {w, h}}".
+    const m = /\{\{\s*(-?[\d.]+),\s*(-?[\d.]+)\s*\},\s*\{\s*(-?[\d.]+),\s*(-?[\d.]+)\s*\}\}/.exec(str(raw.AXFrame));
+    if (m) {
+        const x = parseFloat(m[1]);
+        const y = parseFloat(m[2]);
+        const w = parseFloat(m[3]);
+        const h = parseFloat(m[4]);
+        return { x1: Math.round(x), y1: Math.round(y), x2: Math.round(x + w), y2: Math.round(y + h) };
+    }
+    return { x1: 0, y1: 0, x2: 0, y2: 0 };
+}
+function buildElement(raw) {
+    const bounds = parseFrame(raw);
+    const id = str(raw.AXUniqueId);
+    const type = str(raw.type) || stripAx(str(raw.role)) || 'Other';
+    const cls = str(raw.role) || type;
+    // iOS conflates "visible text" and "content-desc" into accessibilityLabel; a
+    // filled text field surfaces its contents as AXValue. Prefer the label, then a
+    // title, then the value, as the identifying text. `help` (accessibilityHint) is
+    // the closest analog to Android's content-desc, so it becomes `desc`.
+    const text = str(raw.AXLabel) || str(raw.title) || str(raw.AXValue);
+    const checkable = CHECKABLE_TYPES.has(type);
+    const clickable = TAPPABLE_TYPES.has(type) || (Array.isArray(raw.custom_actions) && raw.custom_actions.length > 0);
+    return {
+        index: -1,
+        class: cls,
+        type,
+        id,
+        idShort: id.includes('/') ? id.slice(id.lastIndexOf('/') + 1) : id,
+        text,
+        desc: str(raw.help),
+        bounds,
+        center: {
+            x: Math.floor((bounds.x1 + bounds.x2) / 2),
+            y: Math.floor((bounds.y1 + bounds.y2) / 2),
+        },
+        depth: 0,
+        clickable,
+        longClickable: false,
+        checkable,
+        checked: checkable && isTrue(raw.AXValue),
+        focusable: false,
+        focused: false,
+        scrollable: SCROLLABLE_TYPES.has(type),
+        enabled: raw.enabled === undefined ? true : isTrue(raw.enabled),
+        selected: false,
+        password: type === 'SecureTextField',
+    };
+}
+/**
+ * "Interesting" = something an agent can act on or read. Mirrors the Android
+ * filter's intent (drop pure layout containers) with iOS predicates.
+ */
+function isInteresting(el) {
+    const w = el.bounds.x2 - el.bounds.x1;
+    const h = el.bounds.y2 - el.bounds.y1;
+    if (w <= 0 || h <= 0)
+        return false; // not visible / not tappable
+    if (el.text.trim())
+        return true;
+    if (el.desc.trim())
+        return true;
+    if (el.id)
+        return true;
+    if (el.clickable || el.checkable || el.scrollable)
+        return true;
+    if (TEXT_INPUT_TYPES.has(el.type))
+        return true;
+    return false;
+}
+function parseIosHierarchy(jsonText, opts = {}) {
+    const all = parseIdbJson(jsonText).map(buildElement);
+    const result = opts.all ? all : all.filter(isInteresting);
+    result.forEach((el, idx) => {
+        el.index = idx;
+    });
+    return result;
+}
+/** idb `--json` emits a JSON array; tolerate NDJSON (one object per line) too. */
+function parseIdbJson(text) {
+    const t = text.trim();
+    if (!t)
+        return [];
+    try {
+        const parsed = JSON.parse(t);
+        if (Array.isArray(parsed))
+            return parsed;
+        if (parsed && typeof parsed === 'object')
+            return [parsed];
+    }
+    catch {
+        /* fall through to NDJSON */
+    }
+    const out = [];
+    for (const line of t.split('\n')) {
+        const s = line.trim();
+        if (!s)
+            continue;
+        try {
+            const o = JSON.parse(s);
+            if (o && typeof o === 'object')
+                out.push(o);
+        }
+        catch {
+            /* skip a malformed line rather than fail the whole dump */
+        }
+    }
+    return out;
+}

package/dist/version.js

@@ -3,4 +3,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // GENERATED by scripts/gen-version.mjs from package.json's "version" at build time
 // (the `prebuild` script). Do NOT edit by hand; bump package.json instead.
-exports.VERSION = '0.4.1';
+exports.VERSION = '0.7.0';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "verikun",
-  "version": "0.4.1",
-  "description": "Drive Android emulators/devices (and later iOS simulators) for AI agents: tap, type, swipe, screenshot, and inspect the UI hierarchy by semantic identifiers — like Puppeteer for native apps.",
+  "version": "0.7.0",
+  "description": "Drive Android emulators/devices and iOS simulators for AI agents: tap, type, swipe, screenshot, and inspect the UI hierarchy by semantic identifiers — like Puppeteer for native apps.",
   "keywords": [
     "android",
     "adb",