@houwert/conductor 0.2.0

package/dist/commands/inspect.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspect = inspect;
+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 element_resolver_js_1 = require("../drivers/element-resolver.js");
+async function inspect(opts = {}, sessionName = 'default') {
+    try {
+        const driver = await (0, runner_js_1.getDriver)(sessionName);
+        let text;
+        if (driver instanceof ios_js_1.IOSDriver) {
+            const hierarchy = await driver.viewHierarchy(false);
+            text = (0, element_resolver_js_1.inspectIOSToText)(hierarchy.axElement);
+        }
+        else if (driver instanceof android_js_1.AndroidDriver) {
+            const xml = await driver.viewHierarchy();
+            text = (0, element_resolver_js_1.inspectAndroidToText)(xml);
+        }
+        else {
+            throw new Error('Unknown driver type');
+        }
+        if (opts.json) {
+            console.log(JSON.stringify({ status: 'ok', hierarchy: text }));
+        }
+        else {
+            console.log(text);
+        }
+        return 0;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        (0, output_js_1.printError)(`inspect — failed\n${msg}`, opts);
+        return 1;
+    }
+}

package/dist/commands/install.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installSkills = installSkills;
+exports.installPlugin = installPlugin;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const output_js_1 = require("../output.js");
+const pkg_root_js_1 = require("../pkg-root.js");
+async function installSkills(opts) {
+    try {
+        installPlugin();
+        (0, output_js_1.printSuccess)('Conductor Claude Code plugin installed', opts);
+        return 0;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        (0, output_js_1.printError)(`Plugin install failed: ${message}`, opts);
+        return 1;
+    }
+}
+function installPlugin() {
+    const pkgRoot = (0, pkg_root_js_1.findPkgRoot)(__dirname);
+    const pkgJsonPath = path_1.default.join(pkgRoot, 'package.json');
+    const pkg = JSON.parse(fs_1.default.readFileSync(pkgJsonPath, 'utf8'));
+    const version = pkg.version;
+    const pluginCacheDir = path_1.default.join(os_1.default.homedir(), '.claude', 'plugins', 'cache', 'conductor', 'conductor', version);
+    fs_1.default.mkdirSync(pluginCacheDir, { recursive: true });
+    const skillsSrc = path_1.default.join(pkgRoot, 'skills', 'conductor');
+    if (fs_1.default.existsSync(skillsSrc)) {
+        copyDir(skillsSrc, path_1.default.join(pluginCacheDir, 'skills', 'conductor'));
+    }
+    const pluginJsonSrc = path_1.default.join(pkgRoot, '.claude-plugin', 'plugin.json');
+    if (fs_1.default.existsSync(pluginJsonSrc)) {
+        const pluginMetaDir = path_1.default.join(pluginCacheDir, '.claude-plugin');
+        fs_1.default.mkdirSync(pluginMetaDir, { recursive: true });
+        fs_1.default.copyFileSync(pluginJsonSrc, path_1.default.join(pluginMetaDir, 'plugin.json'));
+    }
+    const installedPluginsPath = path_1.default.join(os_1.default.homedir(), '.claude', 'plugins', 'installed_plugins.json');
+    let installed = { plugins: [] };
+    if (fs_1.default.existsSync(installedPluginsPath)) {
+        installed = JSON.parse(fs_1.default.readFileSync(installedPluginsPath, 'utf8'));
+    }
+    installed.plugins = installed.plugins.filter((p) => p.name !== 'conductor');
+    installed.plugins.push({ name: 'conductor', version, path: pluginCacheDir });
+    fs_1.default.mkdirSync(path_1.default.dirname(installedPluginsPath), { recursive: true });
+    fs_1.default.writeFileSync(installedPluginsPath, JSON.stringify(installed, null, 2));
+}
+function copyDir(src, dest) {
+    fs_1.default.mkdirSync(dest, { recursive: true });
+    for (const entry of fs_1.default.readdirSync(src, { withFileTypes: true })) {
+        const srcPath = path_1.default.join(src, entry.name);
+        const destPath = path_1.default.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDir(srcPath, destPath);
+        }
+        else {
+            fs_1.default.copyFileSync(srcPath, destPath);
+        }
+    }
+}

package/dist/commands/launch-app.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launchApp = launchApp;
+const runner_js_1 = require("../runner.js");
+const session_js_1 = require("../session.js");
+const output_js_1 = require("../output.js");
+const ios_js_1 = require("../drivers/ios.js");
+const android_js_1 = require("../drivers/android.js");
+async function launchApp(appId, deviceId, opts = {}, sessionName = 'default', flags = {}) {
+    if (!appId) {
+        (0, output_js_1.printError)('launch-app requires <appId>', opts);
+        return 1;
+    }
+    await (0, session_js_1.updateSession)({ appId, ...(deviceId ? { deviceId } : {}) }, sessionName);
+    const result = await (0, runner_js_1.runDirect)(async (driver) => {
+        if (flags.clearKeychain)
+            await driver.clearKeychain();
+        if (flags.clearState)
+            await driver.clearAppState(appId);
+        const shouldStop = flags.stopApp ?? true;
+        if (shouldStop) {
+            if (driver instanceof ios_js_1.IOSDriver)
+                await driver.terminateApp(appId);
+            else if (driver instanceof android_js_1.AndroidDriver)
+                await driver.stopApp(appId);
+        }
+        if (driver instanceof ios_js_1.IOSDriver) {
+            await driver.launchApp(appId, flags.launchArgs);
+        }
+        else if (driver instanceof android_js_1.AndroidDriver) {
+            await driver.launchApp(appId, flags.launchArgs);
+        }
+    }, sessionName);
+    if (result.success) {
+        (0, output_js_1.printSuccess)(`launch-app "${appId}" — done`, opts);
+        return 0;
+    }
+    else {
+        (0, output_js_1.printError)(`launch-app "${appId}" — failed\n${result.stderr}`, opts);
+        return 1;
+    }
+}

package/dist/commands/list-apps.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listApps = listApps;
+const runner_js_1 = require("../runner.js");
+const session_js_1 = require("../session.js");
+const output_js_1 = require("../output.js");
+const bootstrap_js_1 = require("../drivers/bootstrap.js");
+async function resolveDeviceId(sessionName) {
+    if (sessionName !== 'default')
+        return sessionName;
+    const session = await (0, session_js_1.getSession)(sessionName);
+    return session.deviceId ?? (await (0, runner_js_1.detectFirstDevice)());
+}
+async function listApps(opts = {}, sessionName = 'default') {
+    const deviceId = await resolveDeviceId(sessionName);
+    if (!deviceId) {
+        (0, output_js_1.printError)('No device found. Connect a device or start a simulator first.', opts);
+        return 1;
+    }
+    const platform = await (0, bootstrap_js_1.detectPlatform)(deviceId);
+    let appIds;
+    if (platform === 'ios') {
+        const result = await (0, runner_js_1.spawnCommand)('bash', [
+            '-c',
+            `xcrun simctl listapps ${deviceId} | plutil -convert json - -o -`,
+        ]);
+        if (!result.success) {
+            (0, output_js_1.printError)(`list-apps failed: ${result.stderr}`, opts);
+            return 1;
+        }
+        try {
+            const parsed = JSON.parse(result.stdout);
+            appIds = Object.keys(parsed).sort();
+        }
+        catch {
+            (0, output_js_1.printError)('Failed to parse app list from simctl', opts);
+            return 1;
+        }
+    }
+    else {
+        const result = await (0, runner_js_1.spawnCommand)('adb', ['-s', deviceId, 'shell', 'pm', 'list', 'packages']);
+        if (!result.success) {
+            (0, output_js_1.printError)(`list-apps failed: ${result.stderr}`, opts);
+            return 1;
+        }
+        appIds = result.stdout
+            .split('\n')
+            .map((l) => l.trim().replace(/^package:/, ''))
+            .filter(Boolean)
+            .sort();
+    }
+    if (opts.json) {
+        (0, output_js_1.printData)({ status: 'ok', apps: appIds }, opts);
+    }
+    else {
+        for (const id of appIds)
+            console.log(id);
+    }
+    return 0;
+}

package/dist/commands/list-devices.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listDevices = listDevices;
+const runner_js_1 = require("../runner.js");
+const output_js_1 = require("../output.js");
+async function listDevices(opts) {
+    const devices = [];
+    // Try adb devices (Android)
+    const adb = await (0, runner_js_1.spawnCommand)('adb', ['devices', '-l']);
+    if (adb.success || adb.stdout.includes('List of devices')) {
+        const lines = adb.stdout.split('\n').slice(1); // skip header
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed === '')
+                continue;
+            const parts = trimmed.split(/\s+/);
+            const id = parts[0];
+            const status = parts[1] ?? 'unknown';
+            if (id && status) {
+                const modelMatch = trimmed.match(/model:(\S+)/);
+                const name = modelMatch ? modelMatch[1].replace(/_/g, ' ') : id;
+                devices.push({ id, name, platform: 'android', status });
+            }
+        }
+    }
+    // Try xcrun simctl list (iOS simulators)
+    const xcrun = await (0, runner_js_1.spawnCommand)('xcrun', ['simctl', 'list', 'devices', 'booted', '--json']);
+    if (xcrun.success) {
+        try {
+            const parsed = JSON.parse(xcrun.stdout);
+            for (const [_runtime, sims] of Object.entries(parsed.devices)) {
+                for (const sim of sims) {
+                    if (sim.state === 'Booted') {
+                        devices.push({
+                            id: sim.udid,
+                            name: sim.name,
+                            platform: 'ios',
+                            status: 'booted',
+                        });
+                    }
+                }
+            }
+        }
+        catch {
+            // ignore parse errors
+        }
+    }
+    if (devices.length === 0) {
+        (0, output_js_1.printError)('No devices found. Start an emulator or simulator first.', opts);
+        return 1;
+    }
+    if (opts.json) {
+        (0, output_js_1.printData)({ status: 'ok', devices }, opts);
+    }
+    else {
+        for (const d of devices) {
+            console.log(`${d.platform.padEnd(8)} ${d.status.padEnd(10)} ${d.id}  ${d.name}`);
+        }
+    }
+    return 0;
+}

package/dist/commands/open-link.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openLink = openLink;
+const runner_js_1 = require("../runner.js");
+const output_js_1 = require("../output.js");
+async function openLink(url, opts = {}, sessionName = 'default') {
+    if (!url) {
+        (0, output_js_1.printError)('open-link requires <url>', opts);
+        return 1;
+    }
+    const result = await (0, runner_js_1.runDirect)(async (driver) => {
+        await driver.openLink(url);
+    }, sessionName);
+    if (result.success) {
+        (0, output_js_1.printSuccess)(`open-link ${url} — done`, opts);
+        return 0;
+    }
+    else {
+        (0, output_js_1.printError)(`open-link ${url} — failed\n${result.stderr}`, opts);
+        return 1;
+    }
+}

package/dist/commands/press-key.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pressKey = pressKey;
+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 VALID_KEYS = [
+    'Enter',
+    'Backspace',
+    'Home',
+    'End',
+    'Tab',
+    'Delete',
+    'Escape',
+    'VolumeUp',
+    'VolumeDown',
+    'Power',
+    'Lock',
+    'Back',
+    'Camera',
+    'Search',
+];
+// iOS XCTest pressKey accepts these values (maps to XCUIKeyboardKey)
+const IOS_KEY_MAP = {
+    Backspace: 'delete',
+    Delete: 'delete',
+    Enter: 'enter',
+    Tab: 'tab',
+};
+// iOS pressButton for hardware buttons
+const IOS_BUTTON_MAP = {
+    Home: 'home',
+    Lock: 'lock',
+    Power: 'lock',
+};
+// Android keyevent codes
+const ANDROID_KEYCODE = {
+    Home: 3,
+    Back: 4,
+    Enter: 66,
+    Backspace: 67,
+    Delete: 67,
+    Tab: 61,
+    Lock: 26,
+    Power: 26,
+    VolumeUp: 24,
+    VolumeDown: 25,
+    Camera: 27,
+    Search: 84,
+    Escape: 111,
+    End: 123,
+};
+async function pressKey(key, opts = {}, sessionName = 'default') {
+    if (!key) {
+        (0, output_js_1.printError)(`press-key requires <key>. Valid keys: ${VALID_KEYS.join(', ')}`, opts);
+        return 1;
+    }
+    const matched = VALID_KEYS.find((k) => k.toLowerCase() === key.toLowerCase());
+    if (!matched) {
+        (0, output_js_1.printError)(`Unknown key "${key}". Valid keys: ${VALID_KEYS.join(', ')}`, opts);
+        return 1;
+    }
+    const result = await (0, runner_js_1.runDirect)(async (driver) => {
+        if (driver instanceof ios_js_1.IOSDriver) {
+            const iosKey = IOS_KEY_MAP[matched];
+            const iosButton = IOS_BUTTON_MAP[matched];
+            if (iosKey) {
+                await driver.pressKey(iosKey);
+            }
+            else if (iosButton) {
+                await driver.pressButton(iosButton);
+            }
+            // Keys not mapped on iOS (e.g. Back, VolumeUp) are silently ignored
+        }
+        else if (driver instanceof android_js_1.AndroidDriver) {
+            const code = ANDROID_KEYCODE[matched];
+            if (code !== undefined) {
+                await driver.pressKeyEvent(code);
+            }
+        }
+    }, sessionName);
+    if (result.success) {
+        (0, output_js_1.printSuccess)(`press-key ${matched} — done`, opts);
+        return 0;
+    }
+    else {
+        (0, output_js_1.printError)(`press-key ${matched} — failed\n${result.stderr}`, opts);
+        return 1;
+    }
+}

package/dist/commands/run-flow-inline.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFlowInline = runFlowInline;
+const runner_js_1 = require("../runner.js");
+const output_js_1 = require("../output.js");
+/** run-flow-inline: Execute inline Maestro YAML commands natively via the flow runner. */
+async function runFlowInline(yaml, opts = {}, sessionName = 'default', benchmark = false) {
+    if (!yaml) {
+        (0, output_js_1.printError)('run-flow-inline requires <yaml>', opts);
+        return 1;
+    }
+    const result = await (0, runner_js_1.runInlineFlow)(yaml, sessionName, benchmark);
+    if (result.success) {
+        (0, output_js_1.printSuccess)('run-flow-inline — done', opts);
+        if (!opts.json && result.stdout.trim()) {
+            console.log(result.stdout.trim());
+        }
+        return 0;
+    }
+    else {
+        const detail = result.stderr.trim() || result.stdout.trim();
+        (0, output_js_1.printError)(`run-flow-inline — failed\n${detail}`, opts);
+        return 1;
+    }
+}

package/dist/commands/run-flow.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFlow = runFlow;
+const path_1 = __importDefault(require("path"));
+const runner_js_1 = require("../runner.js");
+const flow_runner_js_1 = require("../drivers/flow-runner.js");
+const output_js_1 = require("../output.js");
+async function runFlow(file, opts = {}, sessionName = 'default', env = {}, benchmark = false) {
+    if (!file) {
+        (0, output_js_1.printError)('run-flow requires <file>', opts);
+        return 1;
+    }
+    const resolvedFile = path_1.default.resolve(process.cwd(), file);
+    try {
+        const driver = await (0, runner_js_1.getDriver)(sessionName);
+        const flow = await (0, flow_runner_js_1.parseFlowFile)(resolvedFile, env);
+        await (0, flow_runner_js_1.executeFlow)(flow, driver, { cwd: path_1.default.dirname(resolvedFile), env, benchmark });
+        (0, output_js_1.printSuccess)(`run-flow "${file}" — done`, opts);
+        return 0;
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        (0, output_js_1.printError)(`run-flow "${file}" — failed\n${detail}`, opts);
+        return 1;
+    }
+}

package/dist/commands/run-parallel.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runParallel = runParallel;
+/**
+ * run-parallel: Run Maestro YAML flows in parallel across all booted simulators.
+ *
+ * Usage:
+ *   conductor run-parallel --flows-dir ./tests
+ *   conductor run-parallel --flows-dir ./tests --devices auto
+ *
+ * - Auto-detects all booted simulators (and connected Android devices)
+ * - Distributes flow files round-robin across devices
+ * - Spawns one child process per shard
+ * - Collects and prints aggregated pass/fail results
+ */
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const output_js_1 = require("../output.js");
+async function runParallel(flowsDir, opts = {}) {
+    if (!flowsDir) {
+        (0, output_js_1.printError)('run-parallel requires --flows-dir <path>', opts);
+        return 1;
+    }
+    const resolvedDir = path_1.default.resolve(flowsDir);
+    if (!fs_1.default.existsSync(resolvedDir)) {
+        (0, output_js_1.printError)(`flows-dir not found: ${resolvedDir}`, opts);
+        return 1;
+    }
+    // Discover flow files
+    const flowFiles = fs_1.default
+        .readdirSync(resolvedDir)
+        .filter((f) => f.endsWith('.yaml') || f.endsWith('.yml'))
+        .map((f) => path_1.default.join(resolvedDir, f));
+    if (flowFiles.length === 0) {
+        (0, output_js_1.printError)(`No YAML flow files found in: ${resolvedDir}`, opts);
+        return 1;
+    }
+    // Discover devices
+    const devices = await discoverAllDevices();
+    if (devices.length === 0) {
+        (0, output_js_1.printError)('No devices found. Connect a device or start a simulator.', opts);
+        return 1;
+    }
+    console.log(`Found ${devices.length} device(s), ${flowFiles.length} flow(s). Distributing...`);
+    // Assign flows to devices (round-robin)
+    const assignments = flowFiles.map((f, i) => ({
+        deviceId: devices[i % devices.length],
+        flowFile: f,
+    }));
+    // Run all shards in parallel
+    const promises = assignments.map(({ deviceId, flowFile }) => runShard(deviceId, flowFile));
+    const results = await Promise.all(promises);
+    // Print results
+    const passed = results.filter((r) => r.success);
+    const failed = results.filter((r) => !r.success);
+    if (opts.json) {
+        console.log(JSON.stringify({
+            status: failed.length === 0 ? 'ok' : 'error',
+            total: results.length,
+            passed: passed.length,
+            failed: failed.length,
+            results: results.map((r) => ({
+                deviceId: r.deviceId,
+                flowFile: path_1.default.basename(r.flowFile),
+                success: r.success,
+            })),
+        }));
+    }
+    else {
+        console.log('\n─── Results ───────────────────────────────────────');
+        for (const r of results) {
+            const status = r.success ? '✓ PASS' : '✗ FAIL';
+            console.log(`${status}  ${path_1.default.basename(r.flowFile)}  [${r.deviceId.slice(0, 8)}...]`);
+            if (!r.success && r.output.trim()) {
+                console.log(`       ${r.output.trim().split('\n').join('\n       ')}`);
+            }
+        }
+        console.log(`\nTotal: ${results.length}  Passed: ${passed.length}  Failed: ${failed.length}`);
+    }
+    return failed.length === 0 ? 0 : 1;
+}
+async function runShard(deviceId, flowFile) {
+    return new Promise((resolve) => {
+        const proc = (0, child_process_1.spawn)(process.execPath, // node
+        [process.argv[1], 'run-flow', flowFile, '--device', deviceId], { stdio: ['ignore', 'pipe', 'pipe'] });
+        let output = '';
+        proc.stdout?.on('data', (c) => {
+            output += c.toString();
+        });
+        proc.stderr?.on('data', (c) => {
+            output += c.toString();
+        });
+        proc.on('close', (code) => {
+            resolve({ deviceId, flowFile, success: code === 0, output });
+        });
+        proc.on('error', (err) => {
+            resolve({ deviceId, flowFile, success: false, output: err.message });
+        });
+    });
+}
+async function discoverAllDevices() {
+    const devices = [];
+    try {
+        const out = await spawnCapture('adb', ['devices']);
+        for (const line of out.split('\n').slice(1)) {
+            const id = line.trim().split(/\s+/)[0];
+            if (id && !line.includes('offline') && id !== '')
+                devices.push(id);
+        }
+    }
+    catch {
+        /* ok */
+    }
+    try {
+        const out = await spawnCapture('xcrun', ['simctl', 'list', 'devices', 'booted', '--json']);
+        const parsed = JSON.parse(out);
+        for (const sims of Object.values(parsed.devices)) {
+            for (const sim of sims) {
+                if (sim.state === 'Booted')
+                    devices.push(sim.udid);
+            }
+        }
+    }
+    catch {
+        /* ok */
+    }
+    return devices;
+}
+function spawnCapture(cmd, args) {
+    return new Promise((resolve, reject) => {
+        const proc = (0, child_process_1.spawn)(cmd, args, { stdio: ['ignore', 'pipe', 'ignore'] });
+        let out = '';
+        proc.stdout?.on('data', (chunk) => {
+            out += chunk.toString();
+        });
+        proc.on('close', (code) => (code === 0 ? resolve(out) : reject(new Error(`${cmd} failed`))));
+        proc.on('error', reject);
+    });
+}

package/dist/commands/screenshot.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.screenshot = screenshot;
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const runner_js_1 = require("../runner.js");
+const output_js_1 = require("../output.js");
+async function screenshot(outputPath, opts = {}, sessionName = 'default') {
+    const timestamp = Date.now();
+    const defaultName = `screenshot-${timestamp}.png`;
+    const resolvedPath = outputPath
+        ? path_1.default.resolve(outputPath)
+        : path_1.default.resolve(process.cwd(), defaultName);
+    const result = await (0, runner_js_1.runDirect)(async (driver) => {
+        const buf = await driver.screenshot();
+        await promises_1.default.writeFile(resolvedPath, buf);
+    }, sessionName);
+    if (result.success) {
+        (0, output_js_1.printSuccess)(`screenshot saved to ${resolvedPath}`, opts);
+        return 0;
+    }
+    else {
+        (0, output_js_1.printError)(`screenshot — failed\n${result.stderr}`, opts);
+        return 1;
+    }
+}