@houwert/conductor 0.2.0

package/dist/commands/scroll-until-visible.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scrollUntilVisible = scrollUntilVisible;
+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");
+const utils_js_1 = require("../utils.js");
+async function scrollUntilVisible(element, opts = {}, sessionName = 'default', flags = {}) {
+    if (!element && !flags.id && !flags.text) {
+        (0, output_js_1.printError)('scroll-until-visible requires <element> or --id <id>', opts);
+        return 1;
+    }
+    const sel = {
+        ...(flags.text ? { text: flags.text } : flags.id ? { id: flags.id } : { query: element }),
+        ...(flags.index !== undefined && { index: flags.index }),
+        ...(flags.focused !== undefined && { focused: flags.focused }),
+        ...(flags.enabled !== undefined && { enabled: flags.enabled }),
+        ...(flags.checked !== undefined && { checked: flags.checked }),
+        ...(flags.selected !== undefined && { selected: flags.selected }),
+    };
+    const label = flags.text
+        ? `text="${flags.text}"`
+        : flags.id
+            ? `id="${flags.id}"`
+            : `"${element}"`;
+    const direction = flags.direction ?? 'down';
+    const timeoutMs = flags.timeout ?? 30000;
+    const coords = (0, utils_js_1.swipeCoords)(direction);
+    try {
+        const driver = await (0, runner_js_1.getDriver)(sessionName);
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            try {
+                if (driver instanceof ios_js_1.IOSDriver) {
+                    const root = await driver.viewHierarchy().then((h) => h.axElement);
+                    if ((0, element_resolver_js_1.findIOSElement)(root, sel)) {
+                        (0, output_js_1.printSuccess)(`scroll-until-visible ${label} — found`, opts);
+                        return 0;
+                    }
+                    const info = await driver.deviceInfo();
+                    const { widthPoints: w, heightPoints: h } = info;
+                    await driver.swipe(coords.startX * w, coords.startY * h, coords.endX * w, coords.endY * h, 0.5);
+                }
+                else if (driver instanceof android_js_1.AndroidDriver) {
+                    const xml = await driver.viewHierarchy();
+                    if ((0, element_resolver_js_1.findAndroidElement)(xml, sel)) {
+                        (0, output_js_1.printSuccess)(`scroll-until-visible ${label} — found`, opts);
+                        return 0;
+                    }
+                    const info = await driver.deviceInfo();
+                    const { widthPixels: w, heightPixels: h } = info;
+                    await driver.swipe(coords.startX * w, coords.startY * h, coords.endX * w, coords.endY * h, 500);
+                }
+            }
+            catch {
+                // hierarchy fetch failed — keep trying
+            }
+        }
+        (0, output_js_1.printError)(`scroll-until-visible ${label} — element not found after ${timeoutMs}ms`, opts);
+        return 1;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        (0, output_js_1.printError)(`scroll-until-visible ${label} — ${msg}`, opts);
+        return 1;
+    }
+}

package/dist/commands/scroll.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scroll = scroll;
+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 utils_js_1 = require("../utils.js");
+async function scroll(direction = 'down', opts = {}, sessionName = 'default') {
+    const valid = ['down', 'up', 'left', 'right'];
+    if (!valid.includes(direction)) {
+        (0, output_js_1.printError)(`scroll --direction must be one of: ${valid.join(', ')}`, opts);
+        return 1;
+    }
+    const result = await (0, runner_js_1.runDirect)(async (driver) => {
+        const coords = (0, utils_js_1.swipeCoords)(direction);
+        if (driver instanceof ios_js_1.IOSDriver) {
+            const info = await driver.deviceInfo();
+            const { widthPoints: w, heightPoints: h } = info;
+            await driver.swipe(coords.startX * w, coords.startY * h, coords.endX * w, coords.endY * h, 0.5);
+        }
+        else if (driver instanceof android_js_1.AndroidDriver) {
+            const info = await driver.deviceInfo();
+            const { widthPixels: w, heightPixels: h } = info;
+            await driver.swipe(coords.startX * w, coords.startY * h, coords.endX * w, coords.endY * h, 500);
+        }
+    }, sessionName);
+    if (result.success) {
+        (0, output_js_1.printSuccess)(`scroll ${direction} — done`, opts);
+        return 0;
+    }
+    else {
+        (0, output_js_1.printError)(`scroll ${direction} — failed\n${result.stderr}`, opts);
+        return 1;
+    }
+}

package/dist/commands/session.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionCmd = sessionCmd;
+const session_js_1 = require("../session.js");
+const output_js_1 = require("../output.js");
+async function sessionCmd(clear, list, opts = {}, sessionName = 'default') {
+    if (list) {
+        const sessions = await (0, session_js_1.listSessions)();
+        if (opts.json) {
+            (0, output_js_1.printData)({ status: 'ok', sessions }, opts);
+        }
+        else if (sessions.length === 0) {
+            console.log('No sessions found.');
+        }
+        else {
+            console.log('Sessions:');
+            for (const name of sessions) {
+                const s = await (0, session_js_1.getSession)(name);
+                const marker = name === sessionName ? ' (current)' : '';
+                console.log(`  ${name}${marker}  appId=${s.appId ?? '—'}  deviceId=${s.deviceId ?? '—'}`);
+            }
+        }
+        return 0;
+    }
+    if (clear) {
+        await (0, session_js_1.clearSession)(sessionName);
+        (0, output_js_1.printSuccess)(`session "${sessionName}" cleared`, opts);
+        return 0;
+    }
+    const session = await (0, session_js_1.getSession)(sessionName);
+    const filePath = (0, session_js_1.sessionFilePath)(sessionName);
+    if (opts.json) {
+        (0, output_js_1.printData)({ status: 'ok', sessionName, session, file: filePath }, opts);
+    }
+    else {
+        console.log(`Session:  ${sessionName}`);
+        console.log(`File:     ${filePath}`);
+        if (Object.keys(session).length === 0) {
+            console.log('No active session.');
+        }
+        else {
+            if (session.appId)
+                console.log(`  appId:    ${session.appId}`);
+            if (session.deviceId)
+                console.log(`  deviceId: ${session.deviceId}`);
+        }
+    }
+    return 0;
+}

package/dist/commands/set-location.js

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

package/dist/commands/set-orientation.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setOrientation = setOrientation;
+const runner_js_1 = require("../runner.js");
+const output_js_1 = require("../output.js");
+const VALID = ['portrait', 'landscape'];
+async function setOrientation(orientation, opts = {}, sessionName = 'default') {
+    if (!VALID.includes(orientation.toLowerCase())) {
+        (0, output_js_1.printError)(`set-orientation must be one of: ${VALID.join(', ')}`, opts);
+        return 1;
+    }
+    const result = await (0, runner_js_1.runDirect)(async (driver) => {
+        await driver.setOrientation(orientation.toLowerCase());
+    }, sessionName);
+    if (result.success) {
+        (0, output_js_1.printSuccess)(`set-orientation ${orientation} — done`, opts);
+        return 0;
+    }
+    else {
+        (0, output_js_1.printError)(`set-orientation ${orientation} — failed\n${result.stderr}`, opts);
+        return 1;
+    }
+}

package/dist/commands/start-device.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startDevice = startDevice;
+const child_process_1 = require("child_process");
+const runner_js_1 = require("../runner.js");
+const output_js_1 = require("../output.js");
+const utils_js_1 = require("../utils.js");
+const IOS_BOOT_TIMEOUT_MS = 120000;
+const ANDROID_BOOT_TIMEOUT_MS = 120000;
+const POLL_MS = 1000;
+async function listIOSSimulators() {
+    const result = await (0, runner_js_1.spawnCommand)('xcrun', ['simctl', 'list', 'devices', '--json']);
+    if (!result.success)
+        throw new Error(`xcrun simctl list failed: ${result.stderr}`);
+    const parsed = JSON.parse(result.stdout);
+    return parsed.devices;
+}
+async function bootIOSSimulator(udid) {
+    const result = await (0, runner_js_1.spawnCommand)('xcrun', ['simctl', 'boot', udid]);
+    // exit 149 = already booted, that's fine
+    if (!result.success && !result.stderr.includes('already booted')) {
+        throw new Error(`xcrun simctl boot failed: ${result.stderr.trim()}`);
+    }
+}
+async function waitForIOSBoot(udid) {
+    const deadline = Date.now() + IOS_BOOT_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        const result = await (0, runner_js_1.spawnCommand)('xcrun', ['simctl', 'list', 'devices', 'booted', '--json']);
+        if (result.success) {
+            const parsed = JSON.parse(result.stdout);
+            const booted = Object.values(parsed.devices).flat().some((d) => d.udid === udid);
+            if (booted)
+                return;
+        }
+        await (0, utils_js_1.sleep)(POLL_MS);
+    }
+    throw new Error(`Simulator ${udid} did not boot within ${IOS_BOOT_TIMEOUT_MS / 1000}s`);
+}
+async function startIOS(osVersion, opts) {
+    let devices;
+    try {
+        devices = await listIOSSimulators();
+    }
+    catch (e) {
+        (0, output_js_1.printError)(`Failed to list simulators: ${e instanceof Error ? e.message : String(e)}`, opts);
+        return 1;
+    }
+    // Filter to available (installable) simulators, optionally by OS version
+    const candidates = [];
+    for (const [runtime, sims] of Object.entries(devices)) {
+        if (osVersion && !runtime.includes(osVersion))
+            continue;
+        for (const sim of sims) {
+            if (sim.isAvailable && sim.state !== 'Booted') {
+                candidates.push({ runtime, device: sim });
+            }
+            // If already booted, just report it
+            if (sim.isAvailable && sim.state === 'Booted') {
+                if (!osVersion || runtime.includes(osVersion)) {
+                    (0, output_js_1.printSuccess)(`Simulator already booted: ${sim.name} (${sim.udid})`, opts);
+                    return 0;
+                }
+            }
+        }
+    }
+    if (candidates.length === 0) {
+        const hint = osVersion ? ` for iOS ${osVersion}` : '';
+        (0, output_js_1.printError)(`No available iOS simulator found${hint}. Install one via Xcode → Settings → Platforms.`, opts);
+        return 1;
+    }
+    // Prefer iPhone models over iPad
+    const sorted = candidates.sort((a, b) => {
+        const ai = a.device.name.toLowerCase().includes('iphone') ? 0 : 1;
+        const bi = b.device.name.toLowerCase().includes('iphone') ? 0 : 1;
+        return ai - bi;
+    });
+    const { device } = sorted[0];
+    console.log(`Booting simulator: ${device.name} (${device.udid})...`);
+    try {
+        await bootIOSSimulator(device.udid);
+        await waitForIOSBoot(device.udid);
+    }
+    catch (e) {
+        (0, output_js_1.printError)(e instanceof Error ? e.message : String(e), opts);
+        return 1;
+    }
+    // Open the Simulator.app so the window appears
+    (0, child_process_1.spawn)('open', ['-a', 'Simulator'], { detached: true, stdio: 'ignore' }).unref();
+    (0, output_js_1.printSuccess)(`Booted: ${device.name} (${device.udid})`, opts);
+    return 0;
+}
+// ── Android ───────────────────────────────────────────────────────────────────
+async function listAVDs() {
+    const result = await (0, runner_js_1.spawnCommand)('emulator', ['-list-avds']);
+    if (!result.success)
+        throw new Error(`emulator -list-avds failed: ${result.stderr}`);
+    return result.stdout.split('\n').map((l) => l.trim()).filter(Boolean);
+}
+async function waitForAndroidBoot(avdName) {
+    const deadline = Date.now() + ANDROID_BOOT_TIMEOUT_MS;
+    const connectedBefore = new Set();
+    // Snapshot currently connected devices so we can identify the new one
+    const before = await (0, runner_js_1.spawnCommand)('adb', ['devices']);
+    for (const line of before.stdout.split('\n').slice(1)) {
+        const id = line.trim().split(/\s+/)[0];
+        if (id)
+            connectedBefore.add(id);
+    }
+    while (Date.now() < deadline) {
+        await (0, utils_js_1.sleep)(POLL_MS);
+        const result = await (0, runner_js_1.spawnCommand)('adb', ['devices']);
+        if (!result.success)
+            continue;
+        for (const line of result.stdout.split('\n').slice(1)) {
+            const parts = line.trim().split(/\s+/);
+            const id = parts[0];
+            const status = parts[1];
+            if (id && status === 'device' && !connectedBefore.has(id)) {
+                // Check boot completed
+                const boot = await (0, runner_js_1.spawnCommand)('adb', ['-s', id, 'shell', 'getprop', 'sys.boot_completed']);
+                if (boot.stdout.trim() === '1')
+                    return id;
+            }
+        }
+    }
+    throw new Error(`Android emulator (${avdName}) did not appear within ${ANDROID_BOOT_TIMEOUT_MS / 1000}s`);
+}
+async function startAndroid(avdName, opts) {
+    let avds;
+    try {
+        avds = await listAVDs();
+    }
+    catch (e) {
+        (0, output_js_1.printError)(`Failed to list AVDs: ${e instanceof Error ? e.message : String(e)}`, opts);
+        return 1;
+    }
+    if (avds.length === 0) {
+        (0, output_js_1.printError)('No Android AVDs found. Create one in Android Studio → Device Manager.', opts);
+        return 1;
+    }
+    const target = avdName ?? avds[0];
+    if (!avds.includes(target)) {
+        (0, output_js_1.printError)(`AVD "${target}" not found. Available: ${avds.join(', ')}`, opts);
+        return 1;
+    }
+    console.log(`Launching emulator: ${target}...`);
+    const proc = (0, child_process_1.spawn)('emulator', ['-avd', target, '-netdelay', 'none', '-netspeed', 'full'], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    proc.unref();
+    let deviceId;
+    try {
+        deviceId = await waitForAndroidBoot(target);
+    }
+    catch (e) {
+        (0, output_js_1.printError)(e instanceof Error ? e.message : String(e), opts);
+        return 1;
+    }
+    (0, output_js_1.printSuccess)(`Emulator ready: ${target} (${deviceId})`, opts);
+    return 0;
+}
+// ── Entry point ───────────────────────────────────────────────────────────────
+async function startDevice(platform, opts, flags) {
+    if (!platform) {
+        (0, output_js_1.printError)('start-device requires --platform ios|android', opts);
+        return 1;
+    }
+    switch (platform.toLowerCase()) {
+        case 'ios':
+            return startIOS(flags.osVersion, opts);
+        case 'android':
+            return startAndroid(flags.avd, opts);
+        default:
+            (0, output_js_1.printError)(`Unknown platform "${platform}". Use ios or android.`, opts);
+            return 1;
+    }
+}

package/dist/commands/stop-app.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopApp = stopApp;
+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 stopApp(appId, opts = {}, sessionName = 'default') {
+    const session = await (0, session_js_1.getSession)(sessionName);
+    const resolvedAppId = appId ?? session.appId;
+    if (!resolvedAppId) {
+        (0, output_js_1.printError)('stop-app: no appId provided and no active session. Run launch-app first.', opts);
+        return 1;
+    }
+    const result = await (0, runner_js_1.runDirect)(async (driver) => {
+        if (driver instanceof ios_js_1.IOSDriver) {
+            await driver.terminateApp(resolvedAppId);
+        }
+        else if (driver instanceof android_js_1.AndroidDriver) {
+            await driver.stopApp(resolvedAppId);
+        }
+    }, sessionName);
+    if (result.success) {
+        (0, output_js_1.printSuccess)(`stop-app "${resolvedAppId}" — done`, opts);
+        return 0;
+    }
+    else {
+        (0, output_js_1.printError)(`stop-app "${resolvedAppId}" — failed\n${result.stderr}`, opts);
+        return 1;
+    }
+}

package/dist/commands/swipe.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swipe = swipe;
+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 utils_js_1 = require("../utils.js");
+function parseCoordPair(s) {
+    const [xs, ys] = s.split(',').map((p) => p.trim());
+    return { x: parseFloat(xs), y: parseFloat(ys) };
+}
+async function swipe(direction, opts = {}, sessionName = 'default', flags = {}) {
+    if (!direction && !(flags.start && flags.end)) {
+        (0, output_js_1.printError)('swipe requires --direction <up|down|left|right> or --start <x,y> --end <x,y>', opts);
+        return 1;
+    }
+    const result = await (0, runner_js_1.runDirect)(async (driver) => {
+        let startX, startY, endX, endY;
+        if (driver instanceof ios_js_1.IOSDriver) {
+            const { widthPoints: w, heightPoints: h } = await driver.deviceInfo();
+            const durationSec = (flags.duration ?? 500) / 1000;
+            if (flags.start && flags.end) {
+                const s = parseCoordPair(flags.start);
+                const e = parseCoordPair(flags.end);
+                startX = s.x <= 1 ? s.x * w : s.x;
+                startY = s.y <= 1 ? s.y * h : s.y;
+                endX = e.x <= 1 ? e.x * w : e.x;
+                endY = e.y <= 1 ? e.y * h : e.y;
+            }
+            else {
+                const normalized = direction.toLowerCase();
+                const coords = (0, utils_js_1.swipeCoords)(normalized);
+                startX = coords.startX * w;
+                startY = coords.startY * h;
+                endX = coords.endX * w;
+                endY = coords.endY * h;
+            }
+            await driver.swipe(startX, startY, endX, endY, durationSec);
+        }
+        else if (driver instanceof android_js_1.AndroidDriver) {
+            const { widthPixels: w, heightPixels: h } = await driver.deviceInfo();
+            const durationMs = flags.duration ?? 500;
+            if (flags.start && flags.end) {
+                const s = parseCoordPair(flags.start);
+                const e = parseCoordPair(flags.end);
+                startX = s.x <= 1 ? s.x * w : s.x;
+                startY = s.y <= 1 ? s.y * h : s.y;
+                endX = e.x <= 1 ? e.x * w : e.x;
+                endY = e.y <= 1 ? e.y * h : e.y;
+            }
+            else {
+                const normalized = direction.toLowerCase();
+                const coords = (0, utils_js_1.swipeCoords)(normalized);
+                startX = coords.startX * w;
+                startY = coords.startY * h;
+                endX = coords.endX * w;
+                endY = coords.endY * h;
+            }
+            await driver.swipe(startX, startY, endX, endY, durationMs);
+        }
+    }, sessionName);
+    const label = flags.start && flags.end ? `from ${flags.start} to ${flags.end}` : direction.toLowerCase();
+    if (result.success) {
+        (0, output_js_1.printSuccess)(`swipe ${label} — done`, opts);
+        return 0;
+    }
+    else {
+        (0, output_js_1.printError)(`swipe ${label} — failed\n${result.stderr}`, opts);
+        return 1;
+    }
+}

package/dist/commands/tap.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tap = tap;
+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 wait_js_1 = require("../drivers/wait.js");
+const utils_js_1 = require("../utils.js");
+async function tap(query, opts = {}, sessionName = 'default', flags = {}) {
+    if (!query && !flags.id && !flags.text) {
+        (0, output_js_1.printError)('tap requires <element> or --id <id>', opts);
+        return 1;
+    }
+    const sel = {
+        ...(flags.text ? { text: flags.text } : flags.id ? { id: flags.id } : { query }),
+        ...(flags.index !== undefined && { index: flags.index }),
+        ...(flags.focused !== undefined && { focused: flags.focused }),
+        ...(flags.enabled !== undefined && { enabled: flags.enabled }),
+        ...(flags.checked !== undefined && { checked: flags.checked }),
+        ...(flags.selected !== undefined && { selected: flags.selected }),
+        ...(flags.below && { below: { query: flags.below } }),
+        ...(flags.above && { above: { query: flags.above } }),
+        ...(flags.leftOf && { leftOf: { query: flags.leftOf } }),
+        ...(flags.rightOf && { rightOf: { query: flags.rightOf } }),
+    };
+    const label = flags.text ? `text="${flags.text}"` : flags.id ? `id="${flags.id}"` : `"${query}"`;
+    const result = await (0, runner_js_1.runDirect)(async (driver) => {
+        let el;
+        if (driver instanceof ios_js_1.IOSDriver) {
+            el = await (0, wait_js_1.waitForIOSElement)(() => driver.viewHierarchy().then((h) => h.axElement), sel);
+        }
+        else if (driver instanceof android_js_1.AndroidDriver) {
+            el = await (0, wait_js_1.waitForAndroidElement)(() => driver.viewHierarchy(), sel);
+        }
+        else {
+            return;
+        }
+        if (flags.longPress) {
+            if (driver instanceof ios_js_1.IOSDriver) {
+                await driver.tap(el.centerX, el.centerY, 1.5);
+            }
+            else {
+                await driver.swipe(el.centerX, el.centerY, el.centerX, el.centerY, 1500);
+            }
+        }
+        else if (flags.doubleTap) {
+            await driver.tap(el.centerX, el.centerY);
+            await (0, utils_js_1.sleep)(100);
+            await driver.tap(el.centerX, el.centerY);
+        }
+        else {
+            await driver.tap(el.centerX, el.centerY);
+        }
+    }, sessionName);
+    const verb = flags.longPress ? 'long-press' : flags.doubleTap ? 'double-tap' : 'tap';
+    if (result.success) {
+        (0, output_js_1.printSuccess)(`${verb} ${label} — done`, opts);
+        return 0;
+    }
+    else if (flags.optional) {
+        (0, output_js_1.printSuccess)(`${verb} ${label} — not found (optional)`, opts);
+        return 0;
+    }
+    else {
+        (0, output_js_1.printError)(`${verb} ${label} — failed\n${result.stderr}`, opts);
+        return 1;
+    }
+}

package/dist/commands/type.js

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