@houwert/conductor 0.19.1 → 0.21.0

package/dist/daemon/web-server.js

@@ -71,6 +71,52 @@ function attachConsoleListeners(page) {
             source: 'console',
         });
     });
+    attachNetworkListeners(page);
+}
+const MAX_NETWORK_BUFFER = 500;
+const _networkBuffer = [];
+let _netSeq = 0;
+function pushNetworkEntry(entry) {
+    _networkBuffer.push(entry);
+    if (_networkBuffer.length > MAX_NETWORK_BUFFER) {
+        _networkBuffer.splice(0, _networkBuffer.length - MAX_NETWORK_BUFFER);
+    }
+}
+/**
+ * Capture all page network traffic via Playwright events — covers fetch/XHR plus
+ * document/script/image/media loads (a canvas webtv app's API calls included), without
+ * injecting a shim into the page (unlike the React Native Metro path).
+ */
+function attachNetworkListeners(page) {
+    const inflight = new WeakMap();
+    page.on('request', (req) => {
+        const entry = {
+            id: _netSeq++,
+            timestamp: new Date().toISOString(),
+            method: req.method(),
+            url: req.url(),
+            resourceType: req.resourceType(),
+            status: null,
+            durationMs: null,
+            error: null,
+        };
+        inflight.set(req, { entry, start: Date.now() });
+        pushNetworkEntry(entry);
+    });
+    page.on('response', (res) => {
+        const rec = inflight.get(res.request());
+        if (rec) {
+            rec.entry.status = res.status();
+            rec.entry.durationMs = Date.now() - rec.start;
+        }
+    });
+    page.on('requestfailed', (req) => {
+        const rec = inflight.get(req);
+        if (rec) {
+            rec.entry.error = req.failure()?.errorText ?? 'request failed';
+            rec.entry.durationMs = Date.now() - rec.start;
+        }
+    });
 }
 // ── ARIA snapshot parser ─────────────────────────────────────────────────────
 /**
@@ -423,6 +469,113 @@ async function stampFocusFromDocumentActiveElement(page, elements) {
         rectPick.best.focused = true;
     }
 }
+/** IoU + center-inside score of a candidate node's bounds against a mirror rect. */
+function overlapScore(bounds, m) {
+    const x1 = Math.max(m.x, bounds.x);
+    const y1 = Math.max(m.y, bounds.y);
+    const x2 = Math.min(m.x + m.width, bounds.x + bounds.width);
+    const y2 = Math.min(m.y + m.height, bounds.y + bounds.height);
+    const inter = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);
+    if (inter <= 0)
+        return 0;
+    const union = m.width * m.height + bounds.width * bounds.height - inter;
+    const iou = union > 0 ? inter / union : 0;
+    const mcx = m.x + m.width / 2;
+    const mcy = m.y + m.height / 2;
+    const centerInside = mcx >= bounds.x &&
+        mcx <= bounds.x + bounds.width &&
+        mcy >= bounds.y &&
+        mcy <= bounds.y + bounds.height;
+    return centerInside ? iou + 1 : iou;
+}
+/** Find the existing tree node whose bounds best overlap a mirror rect (>0.5 score). */
+function bestOverlappingNode(elements, m) {
+    let best = null;
+    let bestScore = 0.5;
+    const walk = (els) => {
+        for (const el of els) {
+            if (el.bounds) {
+                const s = overlapScore(el.bounds, m);
+                if (s > bestScore) {
+                    bestScore = s;
+                    best = el;
+                }
+            }
+            if (el.children)
+                walk(el.children);
+        }
+    };
+    walk(elements);
+    return best;
+}
+/**
+ * Harvest a canvas DOM-inspector mirror into the hierarchy. Canvas webtv frameworks
+ * (Lightning/WPE/RDK) render the whole UI into one `<canvas>` and expose the scene graph as
+ * off-screen `<div>`s carrying `data-testid` (real identity) and `data-focused="true"` (focus
+ * — the canvas owns `document.activeElement`, so the normal focus path can't see it).
+ *
+ * Each mirror node is matched to an existing ARIA node by bounds overlap and used to enrich it
+ * (testId + focus); unmatched mirror nodes are appended as new nodes. Mirror rects come from
+ * `getBoundingClientRect`, i.e. the same viewport-CSS-pixel space taps use — drive TV apps at
+ * the app's native resolution (e.g. `set-viewport 1920 1080`) so lower nodes aren't off-screen.
+ */
+async function harvestDomMirror(page, elements) {
+    let mirror = null;
+    try {
+        mirror = (await page.evaluate(`(() => {
+      const nodes = document.querySelectorAll('[data-testid],[data-focused]');
+      if (!nodes.length) return null;
+      const out = [];
+      nodes.forEach((el) => {
+        const r = el.getBoundingClientRect();
+        out.push({
+          testId: el.getAttribute('data-testid') || '',
+          focused: el.getAttribute('data-focused') === 'true',
+          role: el.getAttribute('role') || 'generic',
+          name: (el.getAttribute('aria-label') || el.textContent || '').trim().slice(0, 200),
+          disabled: el.getAttribute('aria-disabled') === 'true',
+          x: r.x, y: r.y, width: r.width, height: r.height,
+        });
+      });
+      return out;
+    })()`));
+    }
+    catch {
+        return;
+    }
+    if (!mirror || mirror.length === 0)
+        return;
+    // data-focused is authoritative for canvas apps (activeElement is the <canvas>, never the
+    // focused scene node), so clear any focus already inferred from the ARIA snapshot.
+    if (mirror.some((m) => m.focused))
+        clearFocusedFlags(elements);
+    for (const m of mirror) {
+        const bounds = m.width > 0 && m.height > 0
+            ? { x: m.x, y: m.y, width: m.width, height: m.height }
+            : undefined;
+        const target = bounds ? bestOverlappingNode(elements, m) : null;
+        if (target) {
+            if (m.testId)
+                target.testId = m.testId;
+            if (m.focused)
+                target.focused = true;
+            if (!target.name && m.name)
+                target.name = m.name;
+        }
+        else {
+            elements.push({
+                role: m.role,
+                name: m.name,
+                ref: '',
+                testId: m.testId || undefined,
+                bounds,
+                enabled: !m.disabled,
+                focused: m.focused,
+                children: [],
+            });
+        }
+    }
+}
 // ── Web server ───────────────────────────────────────────────────────────────
 const DEFAULT_VIEWPORT = { width: 1280, height: 720 };
 let _browser = null;
@@ -832,6 +985,9 @@ async function handleRequest(req, res, dlog) {
                 await resolveBoundingBoxesByRole(p, elements);
                 clearFocusedFlags(elements);
                 applyFocusFromAriaSnapshotYaml(ariaSnapshot, elements);
+                // Canvas webtv: merge the data-testid/data-focused mirror before falling back to
+                // document.activeElement (which is the <canvas>, not the focused scene node).
+                await harvestDomMirror(p, elements);
                 await stampFocusFromDocumentActiveElement(p, elements);
                 jsonResponse(res, {
                     url: p.url(),
@@ -937,6 +1093,17 @@ async function handleRequest(req, res, dlog) {
                 jsonResponse(res, { entries });
                 return;
             }
+            case '/networkLogs': {
+                const since = parsedUrl.query['since'] ?? '';
+                const limit = Number(parsedUrl.query['limit'] ?? 0);
+                let entries = since
+                    ? _networkBuffer.filter((e) => e.timestamp > since)
+                    : _networkBuffer.slice();
+                if (limit > 0)
+                    entries = entries.slice(-limit);
+                jsonResponse(res, { entries });
+                return;
+            }
             default: {
                 res.writeHead(404);
                 res.end('Not found');
@@ -1005,6 +1172,58 @@ async function handleRequest(req, res, dlog) {
                 jsonResponse(res, { ok: true });
                 return;
             }
+            case '/evaluate': {
+                const expr = body['expr'];
+                if (!expr) {
+                    jsonResponse(res, { error: 'expr is required' }, 400);
+                    return;
+                }
+                const p = await getPage(dlog);
+                try {
+                    // Wrap so a bare expression (e.g. `1+1`) and a statement block both work.
+                    const result = await p.evaluate(`(() => { return (${expr}); })()`).catch(
+                    // Fall back to evaluating as-is for IIFEs / `async () => …` expressions.
+                    () => p.evaluate(expr));
+                    jsonResponse(res, { result });
+                }
+                catch (e) {
+                    jsonResponse(res, { error: e instanceof Error ? e.message : String(e) });
+                }
+                return;
+            }
+            case '/networkRequest': {
+                const url = body['url'];
+                if (!url) {
+                    jsonResponse(res, { error: 'url is required' }, 400);
+                    return;
+                }
+                const reqMethod = (body['method'] ?? 'GET').toUpperCase();
+                const headers = body['headers'] ?? {};
+                const data = body['body'];
+                if (!_context) {
+                    jsonResponse(res, { error: 'no browser context' }, 500);
+                    return;
+                }
+                try {
+                    const apiRes = await _context.request.fetch(url, {
+                        method: reqMethod,
+                        headers,
+                        ...(data !== undefined ? { data } : {}),
+                    });
+                    const hdrs = apiRes.headers();
+                    const text = await apiRes.text();
+                    jsonResponse(res, {
+                        ok: apiRes.ok(),
+                        status: apiRes.status(),
+                        headers: hdrs,
+                        body: text,
+                    });
+                }
+                catch (e) {
+                    jsonResponse(res, { ok: false, error: e instanceof Error ? e.message : String(e) });
+                }
+                return;
+            }
             case '/navigate':
             case '/launchApp': {
                 const targetUrl = (body['url'] ?? body['bundleId'] ?? body['appId']);

package/dist/drivers/element-resolver.js

@@ -439,7 +439,7 @@ function collectWebElements(nodes, results) {
     for (const node of nodes) {
         const visible = node.bounds && node.bounds.width > 0 && node.bounds.height > 0;
         if (visible) {
-            const hasContent = !!(node.name || node.ref);
+            const hasContent = !!(node.name || node.ref || node.testId);
             const isLeaf = !node.children || node.children.length === 0;
             if (hasContent || isLeaf) {
                 results.push(node);
@@ -450,10 +450,14 @@ function collectWebElements(nodes, results) {
         }
     }
 }
+/** Web id field: prefer the canvas mirror's `data-testid`, else the ARIA `ref`. */
+function webElementId(node) {
+    return node.testId || node.ref;
+}
 function matchesWebElement(node, sel) {
     if (sel.query) {
         const textOk = matchPatternAgainstAnyTextField(sel.query, [node.name]);
-        const idOk = matchPatternAgainstElementId(sel.query, node.ref);
+        const idOk = matchPatternAgainstElementId(sel.query, webElementId(node));
         if (!textOk && !idOk)
             return false;
     }
@@ -462,7 +466,7 @@ function matchesWebElement(node, sel) {
             return false;
     }
     if (sel.id) {
-        if (!matchPatternAgainstElementId(sel.id, node.ref))
+        if (!matchPatternAgainstElementId(sel.id, webElementId(node)))
             return false;
     }
     if (sel.enabled !== undefined && node.enabled !== sel.enabled)
@@ -532,7 +536,7 @@ function findWebElement(hierarchy, sel) {
     matches.forEach((n, i) => {
         const b = n.bounds;
         const interactive = WEB_INTERACTIVE_ROLES.has(n.role);
-        (0, verbose_js_1.log)(`  [${i}] text="${n.name}" ref="${n.ref}" role="${n.role}" ` +
+        (0, verbose_js_1.log)(`  [${i}] text="${n.name}" id="${webElementId(n)}" role="${n.role}" ` +
             `bounds=[${Math.round(b.x)},${Math.round(b.y)}][${Math.round(b.x + b.width)},${Math.round(b.y + b.height)}]` +
             `${interactive ? ' (interactive)' : ''}`);
     });
@@ -554,7 +558,7 @@ function findWebElement(hierarchy, sel) {
         return null;
     }
     const b = node.bounds;
-    (0, verbose_js_1.log)(`[Web] chose [${idx}] text="${node.name}" ref="${node.ref}" role="${node.role}" ` +
+    (0, verbose_js_1.log)(`[Web] chose [${idx}] text="${node.name}" id="${webElementId(node)}" role="${node.role}" ` +
         `bounds=[${Math.round(b.x)},${Math.round(b.y)}][${Math.round(b.x + b.width)},${Math.round(b.y + b.height)}] ` +
         `→ tap (${Math.round(b.x + b.width / 2)}, ${Math.round(b.y + b.height / 2)})`);
     return {
@@ -562,7 +566,7 @@ function findWebElement(hierarchy, sel) {
         centerY: b.y + b.height / 2,
         bounds: { x: b.x, y: b.y, width: b.width, height: b.height },
         text: node.name || undefined,
-        id: node.ref || undefined,
+        id: webElementId(node) || undefined,
     };
 }
 /**
@@ -579,6 +583,8 @@ function visitWeb(nodes, lines, depth) {
         parts.push(node.role);
         if (node.name)
             parts.push(`"${node.name}"`);
+        if (node.testId)
+            parts.push(`id=${node.testId}`);
         if (node.ref)
             parts.push(`ref=${node.ref}`);
         if (node.bounds) {
@@ -588,7 +594,10 @@ function visitWeb(nodes, lines, depth) {
         if (!node.enabled)
             parts.push('disabled');
         // Only output nodes that have content
-        if (node.name || node.ref || (node.bounds && (!node.children || node.children.length === 0))) {
+        if (node.name ||
+            node.ref ||
+            node.testId ||
+            (node.bounds && (!node.children || node.children.length === 0))) {
             lines.push(`${'  '.repeat(depth)}${parts.join(' ')}`);
         }
         if (node.children) {

package/dist/drivers/web.js

@@ -60,6 +60,14 @@ class WebDriver {
         }
         return JSON.parse(data.toString('utf-8'));
     }
+    /** POST that returns the parsed JSON response body (unlike `post`, which discards it). */
+    async postJson(path, body) {
+        const { status, data } = await this.request('POST', `/${path}`, body);
+        if (status < 200 || status >= 300) {
+            throw new Error(`Web driver ${path} failed (HTTP ${status}): ${data.toString('utf-8').slice(0, 200)}`);
+        }
+        return JSON.parse(data.toString('utf-8'));
+    }
     async isAlive() {
         try {
             const { status } = await this.request('GET', '/status');
@@ -154,6 +162,24 @@ class WebDriver {
         }
         return data.toString('utf-8');
     }
+    /** Recent page network traffic captured via Playwright request/response events. */
+    async networkLogs(opts = {}) {
+        const qs = new URLSearchParams();
+        if (opts.limit)
+            qs.set('limit', String(opts.limit));
+        if (opts.since)
+            qs.set('since', opts.since);
+        const s = qs.toString();
+        return this.get(`networkLogs${s ? `?${s}` : ''}`);
+    }
+    /** Issue an HTTP request from the browser context (shares cookies/session with the page). */
+    async networkRequest(url, opts = {}) {
+        return this.postJson('networkRequest', { url, ...opts });
+    }
+    /** Evaluate a JS expression in the page runtime and return its (JSON-serializable) value. */
+    async evaluate(expr) {
+        return this.postJson('evaluate', { expr });
+    }
     async eraseAllText(count = 50) {
         await this.post('eraseText', { count });
     }

package/dist/enum-options.js

@@ -0,0 +1,130 @@
+"use strict";
+// Central registry of commands/parameters that only accept a fixed set of
+// enumerated values. The `list-options` command and the global `--options`
+// flag read from here so agents (and humans) can discover valid values without
+// trial-and-error.
+//
+// Where a value list already exists as the canonical source elsewhere, we
+// import it so this registry can never drift from what the command validates.
+// Small, stable 2–4 value lists are inlined with a pointer to their source.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENUM_PARAMS = void 0;
+exports.commandsWithEnums = commandsWithEnums;
+exports.findEnumParams = findEnumParams;
+const press_key_js_1 = require("./commands/press-key.js");
+const set_viewport_js_1 = require("./commands/set-viewport.js");
+const utils_js_1 = require("./utils.js");
+const types_js_1 = require("./drivers/log-sources/types.js");
+const DIRECTION_VALUES = utils_js_1.DIRECTIONS.map((d) => ({ value: d }));
+// `--level` accepts every key of LEVEL_SEVERITY (includes the `warn` alias).
+const LOG_LEVELS = Object.keys(types_js_1.LEVEL_SEVERITY).map((value) => ({ value }));
+exports.ENUM_PARAMS = [
+    {
+        command: 'press-key',
+        param: '<key>',
+        description: 'Key, hardware button, or remote button to press',
+        values: press_key_js_1.VALID_KEYS.map((value) => ({ value })),
+        note: 'Matched case-insensitively. Availability varies by platform: "Remote …" / "TV …" keys target tvOS and Android TV; hardware buttons (Home, Lock, Power, Volume…) target iOS/Android.',
+    },
+    {
+        command: 'scroll',
+        param: '--direction',
+        description: 'Scroll direction (default: down)',
+        values: DIRECTION_VALUES,
+    },
+    {
+        command: 'swipe',
+        param: '--direction',
+        description: 'Swipe direction (required unless --start/--end are given)',
+        values: DIRECTION_VALUES,
+    },
+    {
+        command: 'scroll-until-visible',
+        param: '--direction',
+        description: 'Scroll direction while searching (default: down)',
+        values: DIRECTION_VALUES,
+    },
+    {
+        command: 'set-orientation',
+        param: '<orientation>',
+        description: 'Device orientation',
+        // Source: VALID in commands/set-orientation.ts
+        values: [{ value: 'portrait' }, { value: 'landscape' }],
+    },
+    {
+        command: 'start-device',
+        param: '--platform',
+        description: 'Platform of the device to start',
+        // Source: switch in commands/start-device.ts
+        values: [{ value: 'ios' }, { value: 'android' }, { value: 'tvos' }, { value: 'web' }],
+    },
+    {
+        command: 'install-web',
+        param: '[browser]',
+        description: 'Playwright browser to install (default: chromium)',
+        // Source: validBrowsers in commands/install.ts
+        values: [{ value: 'chromium' }, { value: 'firefox' }, { value: 'webkit' }],
+    },
+    {
+        command: 'set-viewport',
+        param: '--preset',
+        description: 'Device size preset instead of explicit width/height (web only)',
+        values: Object.entries(set_viewport_js_1.PRESETS).map(([value, p]) => ({
+            value,
+            description: `${p.width}x${p.height} @${p.deviceScaleFactor}x${p.isMobile ? ', mobile' : ''}`,
+        })),
+    },
+    {
+        command: 'set-viewport',
+        param: '--color-scheme',
+        description: 'Emulate prefers-color-scheme (web only)',
+        values: [{ value: 'dark' }, { value: 'light' }],
+    },
+    {
+        command: 'logs',
+        param: '--source',
+        description: 'Filter logs by source (default: both)',
+        // Source: sourceFilter in commands/logs.ts
+        values: [{ value: 'metro' }, { value: 'device' }],
+    },
+    {
+        command: 'logs',
+        param: '--level',
+        description: 'Minimum log level to show',
+        values: LOG_LEVELS,
+        note: '"warn" is an alias for "warning".',
+    },
+    {
+        command: 'list-devices',
+        param: '--platform',
+        description: 'Filter listed devices by platform (also a global filter on most commands)',
+        values: [{ value: 'ios' }, { value: 'android' }, { value: 'tvos' }, { value: 'web' }],
+    },
+];
+/** All distinct command names that have at least one enumerated parameter. */
+function commandsWithEnums() {
+    return [...new Set(exports.ENUM_PARAMS.map((p) => p.command))];
+}
+/**
+ * Find enumerated parameters matching a query. Matches a command name (e.g.
+ * "press-key"), a bare parameter name (e.g. "direction", "--level"), or a
+ * value (e.g. "tvos"). Returns all params when query is empty.
+ */
+function findEnumParams(query) {
+    if (!query)
+        return exports.ENUM_PARAMS;
+    const norm = (s) => s
+        .toLowerCase()
+        .replace(/^-+/, '')
+        .replace(/[<>[\]]/g, '');
+    const q = norm(query);
+    // Exact matches (command, param, or value) take precedence so that an exact
+    // command name like "scroll" doesn't also drag in "scroll-until-visible".
+    const exact = exports.ENUM_PARAMS.filter((p) => p.command.toLowerCase() === q ||
+        norm(p.param) === q ||
+        p.values.some((v) => v.value.toLowerCase() === q));
+    if (exact.length > 0)
+        return exact;
+    // Otherwise fall back to substring matching to forgive partial queries.
+    return exports.ENUM_PARAMS.filter((p) => p.command.toLowerCase().includes(q) || norm(p.param).includes(q));
+}

package/dist/index.js

@@ -28,6 +28,7 @@ const press_key_js_1 = require("./commands/press-key.js");
 const session_js_1 = require("./commands/session.js");
 const daemon_js_1 = require("./commands/daemon.js");
 const install_js_1 = require("./commands/install.js");
+const init_js_1 = require("./commands/init.js");
 const device_pool_js_1 = require("./commands/device-pool.js");
 const run_parallel_js_1 = require("./commands/run-parallel.js");
 const run_sequence_js_1 = require("./commands/run-sequence.js");
@@ -59,6 +60,7 @@ const logs_js_1 = require("./commands/logs.js");
 const memory_js_1 = require("./commands/memory.js");
 const metro_js_1 = require("./commands/metro.js");
 const clipboard_js_1 = require("./commands/clipboard.js");
+const options_js_1 = require("./commands/options.js");
 const device_picker_js_1 = require("./device-picker.js");
 const update_check_js_1 = require("./update-check.js");
 const pkg_root_js_1 = require("./pkg-root.js");
@@ -101,6 +103,7 @@ const COMMAND_HELP = {
     'run-flow-inline': run_flow_inline_js_1.HELP,
     session: session_js_1.HELP,
     'install-web': install_js_1.HELP_INSTALL_WEB,
+    init: init_js_1.HELP,
     'daemon-start': daemon_js_1.HELP_DAEMON_START,
     'daemon-stop': daemon_js_1.HELP_DAEMON_STOP,
     'daemon-status': daemon_js_1.HELP_DAEMON_STATUS,
@@ -119,12 +122,14 @@ const COMMAND_HELP = {
     metro: metro_js_1.HELP,
     clipboard: clipboard_js_1.HELP,
     paste: '  paste                                Trigger OS-level paste (or type clipboard on iOS)',
+    'list-options': options_js_1.HELP,
 };
 const OPTIONS_HELP = `Options:
   --device <id>     Target device ID (also keys the session and daemon)
   --device-name <n> Target a booted device by name (resolved to ID from booted devices)
   --platform <p>    Filter to devices of this platform (ios, android, tvos, web)
   --json            Output as machine-readable JSON
+  --options         List valid values for a command's enumerated parameters and exit
   --verbose, -v     Log daemon calls, fallbacks, and raw output
   --version, -V     Print version number
   --help, -h        Show this help`;
@@ -141,6 +146,7 @@ async function main() {
         boolean: [
             'json',
             'help',
+            'options',
             'version',
             'clear',
             'list',
@@ -163,6 +169,9 @@ async function main() {
             'leaks',
             'snapshots',
             'growth-only',
+            'global',
+            'force',
+            'yes',
         ],
         string: [
             'device',
@@ -222,7 +231,7 @@ async function main() {
             'user-agent',
             'color-scheme',
         ],
-        alias: { h: 'help', v: 'verbose', V: 'version', o: 'output' },
+        alias: { h: 'help', v: 'verbose', V: 'version', o: 'output', y: 'yes' },
     });
     if (argv['verbose'])
         (0, verbose_js_1.setVerbose)(true);
@@ -234,6 +243,12 @@ async function main() {
         console.log(pkg.version);
         process.exit(0);
     }
+    // `<command> --options` lists the valid values for that command's enumerated
+    // parameters and exits — no device resolution needed. With no command it
+    // lists every enumerated parameter. `--help` still wins if both are passed.
+    if (argv['options'] && !argv['help'] && command !== 'list-options') {
+        process.exit((0, options_js_1.listOptions)(command, opts));
+    }
     // Handle help and unknown commands before device resolution —
     // no point prompting for a device if we're just printing help or erroring out.
     if (!command || argv['help']) {
@@ -252,11 +267,13 @@ async function main() {
         'stop-device',
         'delete-device',
         'install-web',
+        'init',
         'copy-app',
         'device-pool',
         'run-parallel',
         'metro',
         'workspace',
+        'list-options',
         // `logs --list` and `logs --source metro` only query Metro on localhost — no device needed
         // `logs` always needs a device session — Metro discovery is device-scoped.
         // `daemon-stop --all` stops every daemon — no device needed
@@ -418,6 +435,10 @@ async function main() {
             exitCode = await (0, press_key_js_1.pressKey)(key, opts, sessionName);
             break;
         }
+        case 'list-options': {
+            exitCode = (0, options_js_1.listOptions)(rest[0], opts);
+            break;
+        }
         case 'scroll': {
             const dir = (argv['direction'] || 'down').toLowerCase();
             exitCode = await (0, scroll_js_1.scroll)(dir, opts, sessionName);
@@ -610,6 +631,13 @@ async function main() {
         case 'session':
             exitCode = await (0, session_js_1.sessionCmd)(argv['clear'], argv['list'], opts, sessionName);
             break;
+        case 'init':
+            exitCode = await (0, init_js_1.init)(opts, rest[0], {
+                global: argv['global'],
+                force: argv['force'],
+                yes: argv['yes'],
+            });
+            break;
         case 'install-web':
             exitCode = await (0, install_js_1.installWebCli)(opts, argv['check'], rest[0]);
             break;

package/dist/utils.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DIRECTIONS = void 0;
 exports.sleep = sleep;
 exports.swipeCoords = swipeCoords;
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+exports.DIRECTIONS = ['down', 'up', 'left', 'right'];
 function swipeCoords(dir) {
     switch (dir) {
         case 'down':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@houwert/conductor",
-  "version": "0.19.1",
+  "version": "0.21.0",
   "description": "CLI tool for mobile app interactions — optimized for AI agents",
   "license": "MIT",
   "repository": {
@@ -17,7 +17,8 @@
   "main": "./dist/index.js",
   "files": [
     "dist/",
-    "proto/"
+    "proto/",
+    "skills/"
   ],
   "scripts": {
     "build": "tsc",