@houwert/conductor 0.16.0 → 0.17.0

package/dist/commands/assert-visible.js

@@ -22,6 +22,7 @@ const ios_js_1 = require("../drivers/ios.js");
 const android_js_1 = require("../drivers/android.js");
 const web_js_1 = require("../drivers/web.js");
 const wait_js_1 = require("../drivers/wait.js");
+const direct_ios_selector_js_1 = require("../drivers/direct-ios-selector.js");
 async function assertVisible(element, opts = {}, sessionName = 'default', flags = {}) {
     if (!element && !flags.id && !flags.text) {
         (0, output_js_1.printError)('assert-visible requires <element> or --id <id>', opts);
@@ -49,7 +50,7 @@ async function assertVisible(element, opts = {}, sessionName = 'default', flags
         const driver = await (0, runner_js_1.getDriver)(sessionName);
         const find = async () => {
             if (driver instanceof ios_js_1.IOSDriver) {
-                return (0, wait_js_1.waitForIOSElement)(() => driver.viewHierarchy().then((h) => h.axElement), sel, timeoutMs);
+                return (0, wait_js_1.waitForIOSElement)((o) => driver.viewHierarchy(false, [], { cache: o?.cached }).then((h) => h.axElement), sel, timeoutMs, undefined, (0, direct_ios_selector_js_1.makeIOSDirectResolver)(driver, sel));
             }
             else if (driver instanceof web_js_1.WebDriver) {
                 return (0, wait_js_1.waitForWebElement)(() => driver.viewHierarchy(), sel, timeoutMs);

package/dist/commands/clipboard.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HELP = void 0;
+exports.clipboardRead = clipboardRead;
+exports.clipboardWrite = clipboardWrite;
+exports.paste = paste;
+exports.HELP = `  clipboard read                       Print the iOS simulator clipboard
+  clipboard write <text>               Set the iOS simulator clipboard
+  paste                                Paste the clipboard into the focused field (iOS only)`;
+const runner_js_1 = require("../runner.js");
+const output_js_1 = require("../output.js");
+const ios_js_1 = require("../drivers/ios.js");
+const android_js_1 = require("../drivers/android.js");
+const web_js_1 = require("../drivers/web.js");
+const ANDROID_MSG = 'clipboard is iOS-only. On Android, use `conductor input-text` to type instead.';
+async function clipboardRead(opts = {}, sessionName = 'default') {
+    const result = await (0, runner_js_1.runDirect)(async (driver) => {
+        if (driver instanceof ios_js_1.IOSDriver)
+            return await driver.clipboardRead();
+        if (driver instanceof android_js_1.AndroidDriver)
+            throw new Error(ANDROID_MSG);
+        if (driver instanceof web_js_1.WebDriver)
+            throw new Error('clipboard read is not supported on Web');
+        return '';
+    }, sessionName);
+    if (result.success) {
+        if (opts.json)
+            (0, output_js_1.printData)({ text: result.stdout }, opts);
+        else
+            process.stdout.write(result.stdout);
+        return 0;
+    }
+    else {
+        (0, output_js_1.printError)(`clipboard read — failed\n${result.stderr}`, opts);
+        return 1;
+    }
+}
+async function clipboardWrite(text, opts = {}, sessionName = 'default') {
+    const result = await (0, runner_js_1.runDirect)(async (driver) => {
+        if (driver instanceof ios_js_1.IOSDriver) {
+            await driver.clipboardWrite(text);
+        }
+        else if (driver instanceof android_js_1.AndroidDriver) {
+            throw new Error(ANDROID_MSG);
+        }
+        else if (driver instanceof web_js_1.WebDriver) {
+            throw new Error('clipboard write is not supported on Web');
+        }
+    }, sessionName);
+    if (result.success) {
+        (0, output_js_1.printSuccess)('clipboard write — done', opts);
+        return 0;
+    }
+    else {
+        (0, output_js_1.printError)(`clipboard write — failed\n${result.stderr}`, opts);
+        return 1;
+    }
+}
+async function paste(opts = {}, sessionName = 'default') {
+    const result = await (0, runner_js_1.runDirect)(async (driver) => {
+        if (driver instanceof ios_js_1.IOSDriver) {
+            // iOS has no universal OS-level paste — read the clipboard and type it into
+            // the focused field. For app-specific Cmd+V handling, callers should issue
+            // press-key paste explicitly via the keyboard route.
+            const text = await driver.clipboardRead();
+            if (text)
+                await driver.inputText(text);
+        }
+        else if (driver instanceof android_js_1.AndroidDriver) {
+            throw new Error('paste is iOS-only. On Android, use `conductor input-text` instead.');
+        }
+        else if (driver instanceof web_js_1.WebDriver) {
+            throw new Error('paste is not supported on Web');
+        }
+    }, sessionName);
+    if (result.success) {
+        (0, output_js_1.printSuccess)('paste — done', opts);
+        return 0;
+    }
+    else {
+        (0, output_js_1.printError)(`paste — failed\n${result.stderr}`, opts);
+        return 1;
+    }
+}

package/dist/commands/crashes.js

@@ -0,0 +1,262 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HELP = void 0;
+exports.crashesList = crashesList;
+exports.crashesShow = crashesShow;
+exports.crashesTail = crashesTail;
+exports.HELP = `  crashes list [--app <bundleId>] [--since <duration>]
+                                       List recent crash reports (iOS host + Android logcat)
+  crashes show <id>                    Print a specific crash report
+  crashes tail                         Stream new crash reports as they appear`;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const output_js_1 = require("../output.js");
+const bootstrap_js_1 = require("../drivers/bootstrap.js");
+const sdk_js_1 = require("../android/sdk.js");
+const IOS_REPORTS_DIR = path_1.default.join(os_1.default.homedir(), 'Library', 'Logs', 'DiagnosticReports');
+function parseSince(s) {
+    if (!s)
+        return 0;
+    const m = s.match(/^(\d+)(s|m|h|d)?$/);
+    if (!m)
+        return 0;
+    const n = Number(m[1]);
+    const unit = m[2] ?? 's';
+    const mult = { s: 1000, m: 60000, h: 3600000, d: 86400000 }[unit] ?? 1000;
+    return n * mult;
+}
+function listIosReports(opts) {
+    if (!fs_1.default.existsSync(IOS_REPORTS_DIR))
+        return [];
+    const now = Date.now();
+    const entries = fs_1.default.readdirSync(IOS_REPORTS_DIR);
+    const out = [];
+    for (const file of entries) {
+        if (!file.endsWith('.ips') && !file.endsWith('.crash'))
+            continue;
+        const full = path_1.default.join(IOS_REPORTS_DIR, file);
+        let stat;
+        try {
+            stat = fs_1.default.statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (opts.sinceMs > 0 && now - stat.mtimeMs > opts.sinceMs)
+            continue;
+        const text = (() => {
+            try {
+                return fs_1.default.readFileSync(full, 'utf-8');
+            }
+            catch {
+                return '';
+            }
+        })();
+        const report = parseIpsReport(file, full, text, stat.mtimeMs);
+        if (opts.app && report.app && !report.app.includes(opts.app))
+            continue;
+        out.push(report);
+    }
+    return out.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+}
+function parseIpsReport(id, full, text, mtimeMs) {
+    // Newer .ips files are JSON-LD style: first line is summary JSON, then body JSON.
+    // Older .crash files are plain text. Be defensive.
+    let app = null;
+    let signal = null;
+    let threadName = null;
+    const topFrames = [];
+    let type = 'crash';
+    try {
+        const firstNewline = text.indexOf('\n');
+        if (firstNewline > 0) {
+            const summary = JSON.parse(text.slice(0, firstNewline));
+            app = summary.bundleID ?? summary.app_name ?? null;
+        }
+    }
+    catch {
+        // ignore — fall back to text parsing
+    }
+    const procMatch = text.match(/Process:\s+(\S+)/);
+    if (!app && procMatch)
+        app = procMatch[1];
+    const sigMatch = text.match(/Exception Type:\s+(\S+)/);
+    if (sigMatch)
+        signal = sigMatch[1];
+    const threadMatch = text.match(/Thread \d+ (Crashed|name):\s*([^\n]+)/);
+    if (threadMatch)
+        threadName = threadMatch[2].trim();
+    const faultMatch = text.includes('fault');
+    if (faultMatch)
+        type = 'fault';
+    const frameLines = text.split('\n');
+    for (const line of frameLines) {
+        if (/^\s*\d+\s+\S+\s+0x[0-9a-f]+/i.test(line)) {
+            topFrames.push(line.trim());
+            if (topFrames.length >= 10)
+                break;
+        }
+    }
+    return {
+        id,
+        timestamp: new Date(mtimeMs).toISOString(),
+        app,
+        type,
+        signal,
+        threadName,
+        topFrames,
+        sourceFile: full,
+        platform: 'ios',
+    };
+}
+async function listAndroidReports(deviceId, opts) {
+    const adb = (0, sdk_js_1.resolveAndroidTool)('adb');
+    const env = (0, sdk_js_1.androidSpawnEnv)();
+    const sinceArg = opts.sinceMs > 0 ? ['-T', String(Math.floor((Date.now() - opts.sinceMs) / 1000))] : [];
+    const output = await new Promise((resolve) => {
+        const proc = (0, child_process_1.spawn)(adb, ['-s', deviceId, 'logcat', '-d', '-b', 'crash', ...sinceArg], {
+            stdio: ['ignore', 'pipe', 'ignore'],
+            env,
+        });
+        let buf = '';
+        proc.stdout.on('data', (c) => {
+            buf += c.toString();
+        });
+        proc.on('close', () => resolve(buf));
+        proc.on('error', () => resolve(''));
+    });
+    const reports = [];
+    const blocks = output.split(/\n(?=\d{2}-\d{2} \d{2}:\d{2}:\d{2})/);
+    for (let i = 0; i < blocks.length; i++) {
+        const block = blocks[i];
+        if (!/FATAL EXCEPTION|AndroidRuntime|tombstone/i.test(block))
+            continue;
+        const appMatch = block.match(/Process: ([\w.]+)/);
+        const app = appMatch ? appMatch[1] : null;
+        if (opts.app && app && !app.includes(opts.app))
+            continue;
+        const tsMatch = block.match(/^(\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+)/);
+        const sigMatch = block.match(/Signal\s+\d+\s+\(([^)]+)\)/);
+        const topFrames = [];
+        for (const line of block.split('\n')) {
+            if (/^\s+at\s/.test(line)) {
+                topFrames.push(line.trim());
+                if (topFrames.length >= 10)
+                    break;
+            }
+        }
+        reports.push({
+            id: `android-${i}-${tsMatch?.[1] ?? Date.now()}`,
+            timestamp: tsMatch
+                ? new Date().getFullYear() + '-' + tsMatch[1].replace(' ', 'T')
+                : new Date().toISOString(),
+            app,
+            type: 'logcat',
+            signal: sigMatch ? sigMatch[1] : null,
+            threadName: null,
+            topFrames,
+            sourceFile: null,
+            platform: 'android',
+        });
+    }
+    return reports;
+}
+async function crashesList(opts, sessionName, listOpts) {
+    const sinceMs = parseSince(listOpts.since);
+    const platform = sessionName !== 'default' ? await (0, bootstrap_js_1.detectPlatform)(sessionName).catch(() => null) : null;
+    const reports = [];
+    // Always include iOS host-side reports — they aren't device-scoped.
+    reports.push(...listIosReports({ app: listOpts.app, sinceMs }));
+    if (platform === 'android' && sessionName !== 'default') {
+        reports.push(...(await listAndroidReports(sessionName, { app: listOpts.app, sinceMs })));
+    }
+    if (opts.json) {
+        (0, output_js_1.printData)({ count: reports.length, reports }, opts);
+    }
+    else {
+        if (reports.length === 0)
+            console.log('No crash reports found.');
+        for (const r of reports) {
+            console.log(`${r.timestamp}  ${r.platform}  ${r.type}  ${r.app ?? '?'}  ${r.signal ?? '-'}  ${r.id}`);
+        }
+    }
+    return 0;
+}
+async function crashesShow(id, opts) {
+    if (!id) {
+        (0, output_js_1.printError)('crashes show requires an <id>', opts);
+        return 1;
+    }
+    // For iOS, id is the file name in DiagnosticReports.
+    const ios = path_1.default.join(IOS_REPORTS_DIR, id);
+    if (fs_1.default.existsSync(ios)) {
+        const text = fs_1.default.readFileSync(ios, 'utf-8');
+        if (opts.json)
+            (0, output_js_1.printData)({ id, source: ios, body: text }, opts);
+        else
+            console.log(text);
+        return 0;
+    }
+    (0, output_js_1.printError)(`crashes show — no report found for "${id}"`, opts);
+    return 1;
+}
+async function crashesTail(opts, sessionName) {
+    console.log('Watching for new crash reports… (Ctrl+C to stop)');
+    // iOS host directory watcher
+    let lastSeen = Date.now();
+    if (fs_1.default.existsSync(IOS_REPORTS_DIR)) {
+        fs_1.default.watch(IOS_REPORTS_DIR, (event, file) => {
+            if (!file)
+                return;
+            const full = path_1.default.join(IOS_REPORTS_DIR, file);
+            try {
+                const stat = fs_1.default.statSync(full);
+                if (stat.mtimeMs <= lastSeen)
+                    return;
+                lastSeen = stat.mtimeMs;
+                const text = fs_1.default.readFileSync(full, 'utf-8');
+                const report = parseIpsReport(file, full, text, stat.mtimeMs);
+                if (opts.json)
+                    (0, output_js_1.printData)(report, opts);
+                else
+                    console.log(`${report.timestamp}  ios  ${report.type}  ${report.app ?? '?'}  ${report.signal ?? '-'}  ${report.id}`);
+            }
+            catch {
+                // ignore
+            }
+        });
+    }
+    // Android: spawn `adb logcat -b crash` streaming
+    if (sessionName !== 'default') {
+        const platform = await (0, bootstrap_js_1.detectPlatform)(sessionName).catch(() => null);
+        if (platform === 'android') {
+            const adb = (0, sdk_js_1.resolveAndroidTool)('adb');
+            const proc = (0, child_process_1.spawn)(adb, ['-s', sessionName, 'logcat', '-b', 'crash'], {
+                stdio: ['ignore', 'pipe', 'ignore'],
+                env: (0, sdk_js_1.androidSpawnEnv)(),
+            });
+            let buf = '';
+            proc.stdout.on('data', (chunk) => {
+                buf += chunk.toString();
+                const lines = buf.split('\n');
+                buf = lines.pop() ?? '';
+                for (const line of lines) {
+                    if (/FATAL EXCEPTION|AndroidRuntime|tombstone/.test(line)) {
+                        if (opts.json)
+                            (0, output_js_1.printData)({ platform: 'android', line }, opts);
+                        else
+                            console.log(`android  ${line}`);
+                    }
+                }
+            });
+        }
+    }
+    // Keep alive
+    await new Promise(() => { });
+    return 0;
+}

package/dist/commands/debug.js

@@ -0,0 +1,244 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HELP = void 0;
+exports.debugStatus = debugStatus;
+exports.debugEvaluate = debugEvaluate;
+exports.debugComponentTree = debugComponentTree;
+exports.debugInspectElement = debugInspectElement;
+exports.debugLogRegistry = debugLogRegistry;
+exports.debugReload = debugReload;
+exports.HELP = `  debug status [--port N]              Show RN debugger connection info
+  debug evaluate <expr> [--port N]     Run JS in the app runtime (Hermes/Fusebox)
+  debug component-tree [--port N]      Print the React component tree (on-screen)
+  debug inspect-element <x,y>          Print the React component at a screen point
+  debug log-registry [--source metro]  Summarize recent Metro/Hermes console logs`;
+const crypto_1 = __importDefault(require("crypto"));
+const output_js_1 = require("../output.js");
+const metro_cdp_js_1 = require("../drivers/metro-cdp.js");
+const bootstrap_js_1 = require("../drivers/bootstrap.js");
+const metro_js_1 = require("../drivers/log-sources/metro.js");
+const metro_scripts_js_1 = require("../drivers/metro-scripts.js");
+const logs_js_1 = require("./logs.js");
+function newRequestId() {
+    return crypto_1.default.randomBytes(6).toString('hex');
+}
+function resolveSession(sessionName) {
+    if (!sessionName || sessionName === 'default') {
+        return { deviceId: undefined, platformPromise: Promise.resolve(undefined) };
+    }
+    return {
+        deviceId: sessionName,
+        platformPromise: (0, bootstrap_js_1.detectPlatform)(sessionName).catch(() => undefined),
+    };
+}
+async function debugStatus(opts, sessionName, debugOpts) {
+    const port = debugOpts.port ?? 8081;
+    try {
+        const targets = await (0, metro_js_1.fetchTargets)(port, 'localhost');
+        const { deviceId, platformPromise } = resolveSession(sessionName);
+        const platform = await platformPromise;
+        const client = new metro_cdp_js_1.MetroCdpClient();
+        await client.connect({ port, deviceId, platform, targetIndex: debugOpts.targetIndex });
+        await client.enableDomain('Runtime');
+        await client.enableDomain('Debugger');
+        // Give a beat for Debugger.scriptParsed events to flow in before reporting count.
+        await new Promise((r) => setTimeout(r, 300));
+        const info = {
+            port,
+            host: 'localhost',
+            deviceId: deviceId ?? null,
+            platform: platform ?? null,
+            connected: client.isConnected(),
+            enabledDomains: [...client.getEnabledDomains()],
+            loadedScripts: client.getLoadedScripts().size,
+            targets: targets.map((t) => ({
+                title: t.title ?? null,
+                deviceName: t.deviceName ?? null,
+                appId: t.appId ?? null,
+                id: t.id ?? null,
+            })),
+        };
+        client.close();
+        if (opts.json)
+            (0, output_js_1.printData)(info, opts);
+        else {
+            console.log(`port:           ${info.port}\n` +
+                `deviceId:       ${info.deviceId ?? '(none)'}\n` +
+                `platform:       ${info.platform ?? '(none)'}\n` +
+                `connected:      ${info.connected}\n` +
+                `enabledDomains: ${info.enabledDomains.join(', ')}\n` +
+                `loadedScripts:  ${info.loadedScripts}\n` +
+                `targets (${info.targets.length}):\n` +
+                info.targets
+                    .map((t, i) => `  ${i}: ${t.title ?? '(no title)'}  device=${t.deviceName}`)
+                    .join('\n'));
+        }
+        return 0;
+    }
+    catch (err) {
+        (0, output_js_1.printError)(`debug status — ${err instanceof Error ? err.message : String(err)}`, opts);
+        return 1;
+    }
+}
+async function debugEvaluate(expr, opts, sessionName, debugOpts) {
+    if (!expr) {
+        (0, output_js_1.printError)('debug evaluate requires a JS expression', opts);
+        return 1;
+    }
+    const port = debugOpts.port ?? 8081;
+    const { deviceId, platformPromise } = resolveSession(sessionName);
+    try {
+        const platform = await platformPromise;
+        const client = new metro_cdp_js_1.MetroCdpClient();
+        await client.connect({ port, deviceId, platform, targetIndex: debugOpts.targetIndex });
+        const value = await client.evaluate(expr);
+        client.close();
+        if (opts.json)
+            (0, output_js_1.printData)({ result: value }, opts);
+        else
+            console.log(typeof value === 'string' ? value : JSON.stringify(value, null, 2));
+        return 0;
+    }
+    catch (err) {
+        (0, output_js_1.printError)(`debug evaluate — ${err instanceof Error ? err.message : String(err)}`, opts);
+        return 1;
+    }
+}
+async function debugComponentTree(opts, sessionName, debugOpts) {
+    const port = debugOpts.port ?? 8081;
+    const { deviceId, platformPromise } = resolveSession(sessionName);
+    try {
+        const platform = await platformPromise;
+        const client = new metro_cdp_js_1.MetroCdpClient();
+        await client.connect({ port, deviceId, platform, targetIndex: debugOpts.targetIndex });
+        const awaitCallback = await client.installCallbackBinding();
+        const requestId = newRequestId();
+        const pending = awaitCallback(requestId, 15000);
+        await client.evaluate((0, metro_scripts_js_1.makeComponentTreeScript)(requestId), false);
+        const result = (await pending);
+        client.close();
+        if (result.error) {
+            (0, output_js_1.printError)(`debug component-tree — ${result.error}`, opts);
+            return 1;
+        }
+        const components = result.components ?? [];
+        // Filter to on-screen components: rect present and inside the screen.
+        const screenW = result.screenW ?? 0;
+        const screenH = result.screenH ?? 0;
+        const onScreen = components.filter((c) => {
+            if (!c.rect)
+                return false;
+            const { x, y, w, h } = c.rect;
+            if (w <= 0 || h <= 0)
+                return false;
+            if (screenW > 0 && (x + w < 0 || x > screenW))
+                return false;
+            if (screenH > 0 && (y + h < 0 || y > screenH))
+                return false;
+            return true;
+        });
+        if (opts.json) {
+            (0, output_js_1.printData)({
+                count: onScreen.length,
+                total: components.length,
+                fabric: result.fabric ?? false,
+                screenW,
+                screenH,
+                components: onScreen,
+            }, opts);
+        }
+        else {
+            for (const c of onScreen) {
+                const parts = ['  '.repeat(c.depth) + c.name];
+                if (c.testID)
+                    parts.push(`testID=${c.testID}`);
+                if (c.label)
+                    parts.push(`label=${JSON.stringify(c.label)}`);
+                if (c.text)
+                    parts.push(`text=${JSON.stringify(c.text.slice(0, 40))}`);
+                if (c.rect) {
+                    const r = c.rect;
+                    parts.push(`[${Math.round(r.x)},${Math.round(r.y)} ${Math.round(r.w)}x${Math.round(r.h)}]`);
+                }
+                console.log(parts.join(' '));
+            }
+            console.log(`\n${onScreen.length} on-screen / ${components.length} total (${result.fabric ? 'Fabric' : 'Paper'})`);
+        }
+        return 0;
+    }
+    catch (err) {
+        (0, output_js_1.printError)(`debug component-tree — ${err instanceof Error ? err.message : String(err)}`, opts);
+        return 1;
+    }
+}
+async function debugInspectElement(at, opts, sessionName, debugOpts) {
+    const m = at.match(/^\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*$/);
+    if (!m) {
+        (0, output_js_1.printError)('debug inspect-element expects "<x>,<y>"', opts);
+        return 1;
+    }
+    const x = Number(m[1]);
+    const y = Number(m[2]);
+    const port = debugOpts.port ?? 8081;
+    const { deviceId, platformPromise } = resolveSession(sessionName);
+    try {
+        const platform = await platformPromise;
+        const client = new metro_cdp_js_1.MetroCdpClient();
+        await client.connect({ port, deviceId, platform, targetIndex: debugOpts.targetIndex });
+        const awaitCallback = await client.installCallbackBinding();
+        const requestId = newRequestId();
+        const pending = awaitCallback(requestId, 8000);
+        await client.evaluate((0, metro_scripts_js_1.makeInspectElementScript)(x, y, requestId), false);
+        const result = (await pending);
+        client.close();
+        if (result.error) {
+            (0, output_js_1.printError)(`debug inspect-element — ${result.error}`, opts);
+            return 1;
+        }
+        if (opts.json)
+            (0, output_js_1.printData)(result, opts);
+        else {
+            console.log(`Components at (${x}, ${y}) — closest first:`);
+            for (const item of result.items ?? []) {
+                const src = item.frame
+                    ? `  (${item.frame.file}:${item.frame.line}${item.frame.original ? ' [original]' : ''})`
+                    : '';
+                console.log(`${'  '.repeat(item.depth)}${item.name}${src}`);
+            }
+        }
+        return 0;
+    }
+    catch (err) {
+        (0, output_js_1.printError)(`debug inspect-element — ${err instanceof Error ? err.message : String(err)}`, opts);
+        return 1;
+    }
+}
+async function debugLogRegistry(opts, sessionName) {
+    // Delegate to the existing `logs` command in summary mode (--list).
+    return (0, logs_js_1.logs)(opts, sessionName, { source: 'metro', list: true });
+}
+async function debugReload(opts, sessionName, debugOpts) {
+    const port = debugOpts.port ?? 8081;
+    const { deviceId, platformPromise } = resolveSession(sessionName);
+    try {
+        const platform = await platformPromise;
+        await (0, metro_cdp_js_1.cdpCall)('Page.reload', undefined, {
+            port,
+            deviceId,
+            platform,
+            targetIndex: debugOpts.targetIndex,
+        });
+        if (opts.json)
+            (0, output_js_1.printData)({ reloaded: true, port, method: 'cdp' }, opts);
+        else
+            console.log(`reloaded port=${port}`);
+        return 0;
+    }
+    catch (err) {
+        (0, output_js_1.printError)(`debug reload — ${err instanceof Error ? err.message : String(err)}`, opts);
+        return 1;
+    }
+}

package/dist/commands/flow-record.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HELP = void 0;
+exports.flowRecord = flowRecord;
+exports.HELP = `  flow record start [--out path]       Start a YAML flow recording for this session
+  flow record finish                   Close the active recording, print the file path
+  flow record echo <text>              Insert a console.log step
+  flow record status                   Show the active recording path (if any)`;
+const output_js_1 = require("../output.js");
+const flow_recorder_js_1 = require("../drivers/flow-recorder.js");
+const session_js_1 = require("../session.js");
+async function flowRecord(sub, rest, opts, sessionName, argv) {
+    if (sub === 'start') {
+        const out = argv['out'];
+        const session = await (0, session_js_1.getSession)(sessionName);
+        const target = await (0, flow_recorder_js_1.startRecording)(sessionName, out, session.appId);
+        if (opts.json)
+            (0, output_js_1.printData)({ recordingPath: target }, opts);
+        else
+            (0, output_js_1.printSuccess)(`flow record start — writing to ${target}`, opts);
+        return 0;
+    }
+    if (sub === 'finish') {
+        const out = await (0, flow_recorder_js_1.finishRecording)(sessionName);
+        if (!out) {
+            (0, output_js_1.printError)('flow record finish — no active recording for this session', opts);
+            return 1;
+        }
+        if (opts.json)
+            (0, output_js_1.printData)({ recordingPath: out }, opts);
+        else
+            (0, output_js_1.printSuccess)(`flow record finish — closed ${out}`, opts);
+        return 0;
+    }
+    if (sub === 'echo') {
+        const active = await (0, flow_recorder_js_1.getActiveRecording)(sessionName);
+        if (!active) {
+            (0, output_js_1.printError)('flow record echo — no active recording (run `flow record start` first)', opts);
+            return 1;
+        }
+        (0, flow_recorder_js_1.appendEcho)(active, rest.join(' '));
+        if (opts.json)
+            (0, output_js_1.printData)({ ok: true }, opts);
+        else
+            (0, output_js_1.printSuccess)('flow record echo — appended', opts);
+        return 0;
+    }
+    if (sub === 'status') {
+        const active = await (0, flow_recorder_js_1.getActiveRecording)(sessionName);
+        if (opts.json)
+            (0, output_js_1.printData)({ active }, opts);
+        else
+            console.log(active ? `recording: ${active}` : 'no active recording');
+        return 0;
+    }
+    (0, output_js_1.printError)('Usage: conductor flow record <start|finish|echo|status>', opts);
+    return 1;
+}