@houwert/conductor 0.5.0 → 0.6.0

package/dist/drivers/flow-runner.js

@@ -16,6 +16,7 @@ const node_vm_1 = __importDefault(require("node:vm"));
 const js_yaml_1 = __importDefault(require("js-yaml"));
 const ios_js_1 = require("./ios.js");
 const android_js_1 = require("./android.js");
+const web_js_1 = require("./web.js");
 const wait_js_1 = require("./wait.js");
 const perf_hooks_1 = require("perf_hooks");
 const js_engine_js_1 = require("./js-engine.js");
@@ -148,6 +149,9 @@ async function waitForElement(driver, sel, timeoutMs, appIds, opts) {
         const iosShouldAllow = opts?.output[OUTPUT_IOS_SHOULD_ALLOW];
         return (0, wait_js_1.waitForIOSElement)(() => iosGetHierarchy(driver, appIds ?? [], iosShouldAllow), elSel, timeoutMs);
     }
+    else if (driver instanceof web_js_1.WebDriver) {
+        return (0, wait_js_1.waitForWebElement)(() => driver.viewHierarchy(), elSel, timeoutMs);
+    }
     else {
         return (0, wait_js_1.waitForAndroidElement)(() => driver.viewHierarchy(), elSel, timeoutMs);
     }
@@ -244,6 +248,9 @@ async function waitForSettle(driver) {
     if (driver instanceof ios_js_1.IOSDriver) {
         await (0, wait_js_1.waitForIOSTransitionToSettle)(() => driver.isScreenStatic());
     }
+    else if (driver instanceof web_js_1.WebDriver) {
+        await (0, wait_js_1.waitForWebHierarchyToSettle)(() => driver.viewHierarchy());
+    }
     else {
         await (0, wait_js_1.waitForAndroidHierarchyToSettle)(() => driver.viewHierarchy());
     }
@@ -498,8 +505,9 @@ async function executeCommand(cmd, driver, opts) {
     }
 }
 function getConductorObj(driver, output) {
+    const platform = driver instanceof ios_js_1.IOSDriver ? 'ios' : driver instanceof web_js_1.WebDriver ? 'web' : 'android';
     return {
-        platform: driver instanceof ios_js_1.IOSDriver ? 'ios' : 'android',
+        platform,
         copiedText: output['__copiedText'] ?? '',
     };
 }
@@ -627,6 +635,9 @@ async function executeCommandBody(key, val, driver, opts) {
             if (driver instanceof android_js_1.AndroidDriver) {
                 await driver.eraseAllText(n);
             }
+            else if (driver instanceof web_js_1.WebDriver) {
+                await driver.eraseAllText(n);
+            }
             else {
                 for (let i = 0; i < n; i++)
                     await driver.pressKey('delete');
@@ -767,6 +778,8 @@ async function executeCommandBody(key, val, driver, opts) {
         case 'back': {
             if (driver instanceof android_js_1.AndroidDriver)
                 await driver.back();
+            else if (driver instanceof web_js_1.WebDriver)
+                await driver.goBack();
             // iOS has no hardware back button — noop
             break;
         }
@@ -782,17 +795,6 @@ async function executeCommandBody(key, val, driver, opts) {
             await waitForSettle(driver);
             break;
         }
-        case 'hide keyboard': {
-            if (driver instanceof ios_js_1.IOSDriver) {
-                await driver.pressKey('return').catch(() => {
-                    /* noop if no keyboard */
-                });
-            }
-            else {
-                await driver.pressKeyEvent(111); // KEYCODE_ESCAPE
-            }
-            break;
-        }
         // ── Assertions ─────────────────────────────────────────────────────────
         case 'assertVisible': {
             const optional = typeof val === 'object' &&
@@ -918,10 +920,17 @@ async function executeCommandBody(key, val, driver, opts) {
             if (stopAppFlag) {
                 if (driver instanceof ios_js_1.IOSDriver)
                     await driver.terminateApp(appId);
+                else if (driver instanceof web_js_1.WebDriver)
+                    await driver.terminateApp();
                 else if (driver instanceof android_js_1.AndroidDriver)
                     await driver.stopApp(appId);
             }
-            await driver.launchApp(appId, launchArgs);
+            if (driver instanceof web_js_1.WebDriver) {
+                await driver.launchApp(appId); // appId is URL for web
+            }
+            else {
+                await driver.launchApp(appId, launchArgs);
+            }
             if (driver instanceof ios_js_1.IOSDriver && permissions) {
                 // Determine allow vs deny from the permissions map.
                 // `all` is the canonical key; fall back to majority vote across explicit keys.
@@ -953,6 +962,9 @@ async function executeCommandBody(key, val, driver, opts) {
             if (driver instanceof ios_js_1.IOSDriver) {
                 await driver.terminateApp(appId);
             }
+            else if (driver instanceof web_js_1.WebDriver) {
+                await driver.terminateApp();
+            }
             else {
                 await driver.stopApp(appId);
             }
@@ -968,19 +980,27 @@ async function executeCommandBody(key, val, driver, opts) {
             if (driver instanceof ios_js_1.IOSDriver) {
                 await driver.terminateApp(appId);
             }
+            else if (driver instanceof web_js_1.WebDriver) {
+                await driver.terminateApp();
+            }
             else {
                 await driver.stopApp(appId);
             }
             break;
         }
         case 'clearState': {
-            const appId = val == null || val === ''
-                ? (opts.appId ??
-                    (() => {
-                        throw new Error('clearState: no appId in command or flow header');
-                    })())
-                : resolveAppId(val, 'clearState');
-            await driver.clearAppState(appId);
+            if (driver instanceof web_js_1.WebDriver) {
+                await driver.clearAppState();
+            }
+            else {
+                const appId = val == null || val === ''
+                    ? (opts.appId ??
+                        (() => {
+                            throw new Error('clearState: no appId in command or flow header');
+                        })())
+                    : resolveAppId(val, 'clearState');
+                await driver.clearAppState(appId);
+            }
             break;
         }
         case 'clearKeychain': {
@@ -994,7 +1014,10 @@ async function executeCommandBody(key, val, driver, opts) {
                         throw new Error('uninstallApp: no appId in command or flow header');
                     })())
                 : resolveAppId(val, 'uninstallApp');
-            if (driver instanceof ios_js_1.IOSDriver) {
+            if (driver instanceof web_js_1.WebDriver) {
+                throw new Error('uninstallApp is not supported on web');
+            }
+            else if (driver instanceof ios_js_1.IOSDriver) {
                 await driver.uninstallApp(appId);
             }
             else {
@@ -1017,6 +1040,19 @@ async function executeCommandBody(key, val, driver, opts) {
                     await driver.pressKey(mapIosKey(keyName));
                 }
             }
+            else if (driver instanceof web_js_1.WebDriver) {
+                // Map common key names to Playwright key names
+                const WEB_KEY_MAP = {
+                    ENTER: 'Enter',
+                    RETURN: 'Enter',
+                    TAB: 'Tab',
+                    DELETE: 'Backspace',
+                    BACKSPACE: 'Backspace',
+                    SPACE: 'Space',
+                    ESCAPE: 'Escape',
+                };
+                await driver.pressKey(WEB_KEY_MAP[keyName] ?? keyName);
+            }
             else {
                 const keycode = ANDROID_KEYCODES[keyName];
                 if (keycode === undefined)
@@ -1031,6 +1067,9 @@ async function executeCommandBody(key, val, driver, opts) {
                     /* noop if no keyboard */
                 });
             }
+            else if (driver instanceof web_js_1.WebDriver) {
+                // No virtual keyboard on web — noop
+            }
             else {
                 await driver.pressKeyEvent(111); // KEYCODE_ESCAPE
             }
@@ -1206,6 +1245,9 @@ async function executeCommandBody(key, val, driver, opts) {
             if (driver instanceof ios_js_1.IOSDriver) {
                 await (0, wait_js_1.waitForIOSHierarchyToSettle)(() => driver.viewHierarchy().then((h) => h.axElement), wfaTimeout);
             }
+            else if (driver instanceof web_js_1.WebDriver) {
+                await (0, wait_js_1.waitForWebHierarchyToSettle)(() => driver.viewHierarchy(), wfaTimeout);
+            }
             else {
                 await (0, wait_js_1.waitForAndroidHierarchyToSettle)(() => driver.viewHierarchy(), wfaTimeout);
             }

package/dist/drivers/log-sources/android.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AndroidLogSource = void 0;
+/**
+ * Android log source — streams logs from an Android device/emulator via `adb logcat`.
+ */
+const child_process_1 = require("child_process");
+function mapPriority(priority) {
+    // Android log priorities: 2=V, 3=D, 4=I, 5=W, 6=E, 7=F
+    const p = typeof priority === 'string' ? priority.toUpperCase() : String(priority);
+    switch (p) {
+        case '2':
+        case 'V':
+            return 'verbose';
+        case '3':
+        case 'D':
+            return 'debug';
+        case '4':
+        case 'I':
+            return 'info';
+        case '5':
+        case 'W':
+            return 'warning';
+        case '6':
+        case 'E':
+        case '7':
+        case 'F':
+            return 'error';
+        default:
+            return 'log';
+    }
+}
+class AndroidLogSource {
+    constructor(deviceId, appId) {
+        this.deviceId = deviceId;
+        this.appId = appId;
+        this.proc = null;
+        this.callback = null;
+        this.buffer = '';
+        this.useJson = true;
+    }
+    async connect() {
+        // Try to find the app's PID for filtering
+        let pid;
+        if (this.appId) {
+            try {
+                pid = (0, child_process_1.execSync)(`adb -s ${this.deviceId} shell pidof ${this.appId}`, {
+                    encoding: 'utf-8',
+                    timeout: 5000,
+                }).trim();
+            }
+            catch {
+                // App may not be running yet — proceed without PID filter
+            }
+        }
+        // Clear existing logcat buffer so we start fresh
+        try {
+            (0, child_process_1.execSync)(`adb -s ${this.deviceId} logcat -c`, { timeout: 5000 });
+        }
+        catch {
+            // Ignore clear failures
+        }
+        // Try JSON format first (available on API 26+)
+        const args = ['-s', this.deviceId, 'logcat'];
+        if (this.useJson) {
+            args.push('-v', 'json');
+        }
+        else {
+            args.push('-v', 'threadtime');
+        }
+        if (pid) {
+            args.push('--pid', pid);
+        }
+        this.proc = (0, child_process_1.spawn)('adb', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        let stderrChunks = '';
+        this.proc.stderr.on('data', (chunk) => {
+            stderrChunks += chunk.toString('utf-8');
+        });
+        this.proc.stdout.on('data', (chunk) => {
+            this.buffer += chunk.toString('utf-8');
+            const lines = this.buffer.split('\n');
+            this.buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                if (this.useJson) {
+                    this.parseJsonLine(line);
+                }
+                else {
+                    this.parseThreadtimeLine(line);
+                }
+            }
+        });
+        this.proc.on('error', () => {
+            // adb not available
+        });
+        // If JSON format isn't supported, the process will exit quickly with an error.
+        // Fall back to threadtime format.
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(resolve, 1000);
+            this.proc.on('close', (code) => {
+                clearTimeout(timer);
+                if (code !== 0 && code !== null && this.useJson) {
+                    // JSON format not supported — retry with threadtime
+                    this.useJson = false;
+                    this.connect().then(resolve, reject);
+                    return;
+                }
+                if (code !== 0 && code !== null) {
+                    reject(new Error(`adb logcat exited with code ${code}. ${stderrChunks.trim() || 'Is the device connected?'}`));
+                }
+            });
+        });
+    }
+    onEntry(callback) {
+        this.callback = callback;
+    }
+    disconnect() {
+        if (this.proc) {
+            this.proc.kill('SIGTERM');
+            this.proc = null;
+        }
+    }
+    parseJsonLine(line) {
+        try {
+            const data = JSON.parse(line);
+            const entry = {
+                timestamp: data.timestamp || new Date().toISOString(),
+                level: mapPriority(data.priority),
+                message: data.tag ? `[${data.tag}] ${data.message}` : data.message,
+                stackTrace: null,
+                source: 'device',
+            };
+            this.callback?.(entry);
+        }
+        catch {
+            // Non-JSON line — skip
+        }
+    }
+    /** Parse threadtime format: `MM-DD HH:MM:SS.mmm  PID  TID LEVEL TAG: message` */
+    parseThreadtimeLine(line) {
+        const match = line.match(/^(\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}\.\d+)\s+\d+\s+\d+\s+([VDIWEF])\s+(.+?):\s+(.*)$/);
+        if (!match)
+            return;
+        const [, ts, level, tag, message] = match;
+        const entry = {
+            timestamp: ts,
+            level: mapPriority(level),
+            message: `[${tag}] ${message}`,
+            stackTrace: null,
+            source: 'device',
+        };
+        this.callback?.(entry);
+    }
+}
+exports.AndroidLogSource = AndroidLogSource;

package/dist/drivers/log-sources/daemon.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaemonLogSource = void 0;
+/**
+ * Daemon log source — polls the daemon's /logs HTTP endpoint over Unix socket.
+ *
+ * Used by the `logs` command for streaming mode. For snapshot mode (--recent),
+ * the CLI calls fetchDaemonLogs() directly instead.
+ */
+const http_1 = __importDefault(require("http"));
+const protocol_js_1 = require("../../daemon/protocol.js");
+const POLL_INTERVAL_MS = 500;
+class DaemonLogSource {
+    constructor(sessionName, metroPort) {
+        this.sessionName = sessionName;
+        this.metroPort = metroPort;
+        this.callback = null;
+        this.pollTimer = null;
+        this.since = new Date().toISOString();
+        this.stopped = false;
+        this.metroSent = false;
+        this.sockPath = (0, protocol_js_1.socketPath)(sessionName);
+    }
+    async connect() {
+        // Verify daemon is reachable
+        const alive = await this.checkAlive();
+        if (!alive) {
+            throw new Error(`Daemon for session "${this.sessionName}" is not responding. Is it running?`);
+        }
+        this.startPolling();
+    }
+    onEntry(callback) {
+        this.callback = callback;
+    }
+    disconnect() {
+        this.stopped = true;
+        if (this.pollTimer) {
+            clearTimeout(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+    startPolling() {
+        const poll = async () => {
+            if (this.stopped)
+                return;
+            try {
+                const entries = await this.fetchLogs();
+                for (const entry of entries) {
+                    this.callback?.(entry);
+                }
+                if (entries.length > 0) {
+                    this.since = entries[entries.length - 1].timestamp;
+                }
+            }
+            catch {
+                // Daemon may have restarted — keep polling
+            }
+            if (!this.stopped) {
+                this.pollTimer = setTimeout(poll, POLL_INTERVAL_MS);
+            }
+        };
+        poll();
+    }
+    fetchLogs() {
+        // Include metro param on the first poll to trigger discovery in the daemon
+        let reqPath = `/logs?since=${encodeURIComponent(this.since)}`;
+        if (this.metroPort !== undefined && !this.metroSent) {
+            reqPath += this.metroPort === 'auto' ? '&metro' : `&metro=${this.metroPort}`;
+            this.metroSent = true;
+        }
+        return new Promise((resolve, reject) => {
+            const req = http_1.default.get({
+                socketPath: this.sockPath,
+                path: reqPath,
+            }, (res) => {
+                const chunks = [];
+                res.on('data', (chunk) => chunks.push(chunk));
+                res.on('end', () => {
+                    try {
+                        const data = JSON.parse(Buffer.concat(chunks).toString('utf-8'));
+                        resolve(data.entries ?? []);
+                    }
+                    catch {
+                        resolve([]);
+                    }
+                });
+            });
+            req.setTimeout(5000, () => {
+                req.destroy();
+                reject(new Error('Timeout polling daemon logs'));
+            });
+            req.on('error', reject);
+        });
+    }
+    checkAlive() {
+        return new Promise((resolve) => {
+            const req = http_1.default.get({ socketPath: this.sockPath, path: '/status' }, (res) => {
+                resolve(res.statusCode === 200);
+                res.resume();
+            });
+            req.setTimeout(2000, () => {
+                req.destroy();
+                resolve(false);
+            });
+            req.on('error', () => resolve(false));
+        });
+    }
+}
+exports.DaemonLogSource = DaemonLogSource;

package/dist/drivers/log-sources/ios.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IOSLogSource = void 0;
+/**
+ * iOS log source — streams logs from an iOS simulator via `xcrun simctl spawn ... log stream`.
+ */
+const child_process_1 = require("child_process");
+function mapMessageType(messageType) {
+    switch (messageType.toLowerCase()) {
+        case 'fault':
+            return 'error';
+        case 'error':
+            return 'error';
+        case 'default':
+            return 'log';
+        case 'info':
+            return 'info';
+        case 'debug':
+            return 'debug';
+        default:
+            return 'log';
+    }
+}
+class IOSLogSource {
+    constructor(deviceId, appId) {
+        this.deviceId = deviceId;
+        this.appId = appId;
+        this.proc = null;
+        this.callback = null;
+        this.buffer = '';
+    }
+    async connect() {
+        const args = [
+            'simctl',
+            'spawn',
+            this.deviceId,
+            'log',
+            'stream',
+            '--style',
+            'ndjson',
+            '--level',
+            'debug',
+        ];
+        if (this.appId) {
+            // Filter to just this app's process. The process name is typically the
+            // last component of the bundle ID (e.g. "MyApp" from "com.example.MyApp"),
+            // but simctl log stream matches on the full process image path, so use
+            // a CONTAINS predicate for robustness.
+            args.push('--predicate', `process CONTAINS "${this.appId.split('.').pop()}"`);
+        }
+        this.proc = (0, child_process_1.spawn)('xcrun', args, { stdio: ['ignore', 'pipe', 'ignore'] });
+        this.proc.stdout.on('data', (chunk) => {
+            this.buffer += chunk.toString('utf-8');
+            const lines = this.buffer.split('\n');
+            // Keep the last (potentially incomplete) line in the buffer
+            this.buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                this.parseLine(line);
+            }
+        });
+        this.proc.on('error', () => {
+            // xcrun not available or similar — ignore, the command will have errored on startup
+        });
+        // Give simctl a moment to start streaming — if it exits immediately,
+        // it likely means the device ID is invalid.
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(resolve, 500);
+            this.proc.on('close', (code) => {
+                clearTimeout(timer);
+                if (code !== 0 && code !== null) {
+                    reject(new Error(`simctl log stream exited with code ${code}. Is the simulator booted?`));
+                }
+            });
+        });
+    }
+    onEntry(callback) {
+        this.callback = callback;
+    }
+    disconnect() {
+        if (this.proc) {
+            this.proc.kill('SIGTERM');
+            this.proc = null;
+        }
+    }
+    parseLine(line) {
+        try {
+            const data = JSON.parse(line);
+            if (!data.eventMessage)
+                return;
+            const entry = {
+                timestamp: data.timestamp || new Date().toISOString(),
+                level: mapMessageType(data.messageType ?? 'Default'),
+                message: data.eventMessage,
+                stackTrace: null,
+                source: 'device',
+            };
+            this.callback?.(entry);
+        }
+        catch {
+            // Non-JSON lines (e.g. simctl header) — skip
+        }
+    }
+}
+exports.IOSLogSource = IOSLogSource;