@houwert/conductor 0.5.0 → 0.7.0

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

@@ -0,0 +1,252 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetroLogSource = void 0;
+exports.fetchTargets = fetchTargets;
+/**
+ * Metro CDP log source — connects to the React Native Metro dev server's
+ * Chrome DevTools Protocol endpoint to stream JS console output.
+ */
+const http_1 = __importDefault(require("http"));
+const ws_1 = __importDefault(require("ws"));
+/** Strip ANSI escape sequences from a string. */
+function stripAnsi(s) {
+    return s.replace(/\x1b\[[0-9;]*m/g, '');
+}
+function serializeRemoteObject(obj) {
+    if (obj.type === 'string')
+        return stripAnsi(String(obj.value ?? ''));
+    if (obj.type === 'number' || obj.type === 'boolean')
+        return String(obj.value);
+    if (obj.type === 'undefined')
+        return 'undefined';
+    if (obj.type === 'symbol')
+        return obj.description ?? 'Symbol()';
+    if (obj.subtype === 'null')
+        return 'null';
+    return obj.description ?? obj.preview?.description ?? `[${obj.type}]`;
+}
+function mapCDPLevel(type) {
+    switch (type) {
+        case 'warning':
+            return 'warning';
+        case 'error':
+            return 'error';
+        case 'info':
+            return 'info';
+        case 'debug':
+            return 'debug';
+        case 'trace':
+            return 'verbose';
+        default:
+            return 'log';
+    }
+}
+/** Strip Metro bundle URLs down to just the file path. */
+function cleanUrl(raw) {
+    // Metro URLs look like: http://localhost:8082/index.bundle//&platform=ios&dev=true&...
+    // Or relative paths from source maps. Keep just the filename if it's a bundle URL.
+    try {
+        const u = new URL(raw);
+        // It's a full URL — strip to pathname, remove /index.bundle prefix
+        let p = u.pathname;
+        if (p.startsWith('/index.bundle'))
+            p = '<bundle>';
+        return p;
+    }
+    catch {
+        // Already a plain path — return as-is
+        return raw;
+    }
+}
+/** Metro bundler-internal function names that repeat in require cycles. */
+const METRO_INTERNALS = new Set([
+    'metroRequire',
+    'loadModuleImplementation',
+    'guardedLoadModule',
+    'metroImportDefault',
+    'metroImportAll',
+]);
+const MAX_STACK_FRAMES = 10;
+function formatStackTrace(st) {
+    if (!st || st.callFrames.length === 0)
+        return null;
+    // Filter out repetitive Metro bundler internals
+    const meaningful = st.callFrames.filter((f) => !METRO_INTERNALS.has(f.functionName));
+    const frames = meaningful.slice(0, MAX_STACK_FRAMES);
+    const lines = frames.map((f) => {
+        const fn = f.functionName || '<anonymous>';
+        return `  at ${fn} (${cleanUrl(f.url)}:${f.lineNumber + 1}:${f.columnNumber + 1})`;
+    });
+    const omitted = meaningful.length - frames.length;
+    if (omitted > 0) {
+        lines.push(`  ... ${omitted} more frames`);
+    }
+    return lines.join('\n');
+}
+/** Fetch the list of debugger targets from Metro's /json endpoint. */
+async function fetchTargets(port, host) {
+    return new Promise((resolve, reject) => {
+        const req = http_1.default.get(`http://${host}:${port}/json`, (res) => {
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => {
+                try {
+                    resolve(JSON.parse(Buffer.concat(chunks).toString('utf-8')));
+                }
+                catch {
+                    reject(new Error('Failed to parse Metro /json response'));
+                }
+            });
+        });
+        req.setTimeout(2000, () => {
+            req.destroy();
+            reject(new Error(`Could not connect to Metro on port ${port}. Is Metro running?`));
+        });
+        req.on('error', (err) => {
+            if (err.code === 'ECONNREFUSED') {
+                reject(new Error(`Could not connect to Metro on port ${port}. Is Metro running?`));
+            }
+            else {
+                reject(err);
+            }
+        });
+    });
+}
+/**
+ * Discover the WebSocket debugger URL from Metro's /json endpoint.
+ *
+ * When `targetIndex` is provided, connects to that specific target (0-based).
+ * This lets agents running on multiple devices each pick their own debugger
+ * target explicitly, since Metro's internal target IDs don't map cleanly to
+ * simulator UDIDs or emulator serial numbers.
+ *
+ * When omitted, prefers the first Hermes target, then the first available.
+ * If there are multiple targets and no index was given, logs a hint about
+ * using `--target` to select one.
+ */
+async function discoverTarget(port, host, targetIndex) {
+    const data = await fetchTargets(port, host);
+    const withWs = data.filter((t) => t.webSocketDebuggerUrl);
+    if (withWs.length === 0) {
+        throw new Error('Metro returned no debugger targets. Is the app running on a device/simulator?');
+    }
+    if (targetIndex !== undefined) {
+        if (targetIndex < 0 || targetIndex >= withWs.length) {
+            const list = withWs
+                .map((t, i) => `  ${i}: ${t.title ?? t.description ?? t.deviceName ?? '(unnamed)'}`)
+                .join('\n');
+            throw new Error(`--target ${targetIndex} is out of range. Available Metro targets:\n${list}`);
+        }
+        return withWs[targetIndex].webSocketDebuggerUrl;
+    }
+    if (withWs.length > 1) {
+        const list = withWs
+            .map((t, i) => `  ${i}: ${t.title ?? t.description ?? t.deviceName ?? '(unnamed)'}`)
+            .join('\n');
+        console.error(`Multiple Metro targets found. Using target 0. Use --target <n> to select:\n${list}`);
+    }
+    const target = withWs.find((t) => t.title && /hermes|react/i.test(t.title)) ?? withWs[0];
+    return target.webSocketDebuggerUrl;
+}
+class MetroLogSource {
+    constructor(port = 8081, host = 'localhost', targetIndex) {
+        this.port = port;
+        this.host = host;
+        this.targetIndex = targetIndex;
+        this.ws = null;
+        this.callback = null;
+        this.nextId = 1;
+        this.reconnecting = false;
+        this.disconnected = false;
+    }
+    async connect() {
+        const wsUrl = await discoverTarget(this.port, this.host, this.targetIndex);
+        await this.openSocket(wsUrl);
+    }
+    onEntry(callback) {
+        this.callback = callback;
+    }
+    disconnect() {
+        this.disconnected = true;
+        if (this.ws) {
+            this.ws.removeAllListeners();
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+    async openSocket(wsUrl) {
+        return new Promise((resolve, reject) => {
+            const ws = new ws_1.default(wsUrl);
+            this.ws = ws;
+            ws.on('open', () => {
+                // Enable the Runtime domain to receive consoleAPICalled events
+                ws.send(JSON.stringify({ id: this.nextId++, method: 'Runtime.enable' }));
+                resolve();
+            });
+            ws.on('message', (data) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+                    if (msg.method === 'Runtime.consoleAPICalled') {
+                        const { type, args, timestamp, stackTrace } = msg.params;
+                        const entry = {
+                            timestamp: new Date(timestamp).toISOString(),
+                            level: mapCDPLevel(type),
+                            message: args.map(serializeRemoteObject).join(' '),
+                            stackTrace: formatStackTrace(stackTrace),
+                            source: 'metro',
+                        };
+                        this.callback?.(entry);
+                    }
+                }
+                catch {
+                    // Ignore non-matching messages
+                }
+            });
+            ws.on('close', () => {
+                if (!this.disconnected) {
+                    this.scheduleReconnect();
+                }
+            });
+            ws.on('error', (err) => {
+                if (!this.ws) {
+                    // Connection never opened
+                    reject(err);
+                }
+                // Errors while running will trigger 'close' → reconnect
+            });
+        });
+    }
+    scheduleReconnect(attempt = 0) {
+        if (this.disconnected || this.reconnecting)
+            return;
+        this.reconnecting = true;
+        const delay = Math.min(1000 * Math.pow(2, attempt), 10000);
+        setTimeout(async () => {
+            if (this.disconnected) {
+                this.reconnecting = false;
+                return;
+            }
+            try {
+                const wsUrl = await discoverTarget(this.port, this.host, this.targetIndex);
+                await this.openSocket(wsUrl);
+                this.reconnecting = false;
+                // Signal reconnection to the user via a synthetic log entry
+                this.callback?.({
+                    timestamp: new Date().toISOString(),
+                    level: 'info',
+                    message: '[conductor] Reconnected to Metro',
+                    stackTrace: null,
+                    source: 'metro',
+                });
+            }
+            catch {
+                this.reconnecting = false;
+                this.scheduleReconnect(attempt + 1);
+            }
+        }, delay);
+    }
+}
+exports.MetroLogSource = MetroLogSource;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEVEL_SEVERITY = void 0;
+/** Numeric severity for level filtering. Includes short aliases. */
+exports.LEVEL_SEVERITY = {
+    verbose: 0,
+    debug: 1,
+    log: 2,
+    info: 3,
+    warning: 4,
+    warn: 4,
+    error: 5,
+};

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

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebLogSource = void 0;
+/**
+ * Web log source — polls the Conductor daemon's web server for Playwright console events.
+ */
+const http_1 = __importDefault(require("http"));
+class WebLogSource {
+    constructor(port, host = '127.0.0.1') {
+        this.port = port;
+        this.host = host;
+        this.callback = null;
+        this.pollTimer = null;
+        this.since = new Date().toISOString();
+        this.stopped = false;
+    }
+    async connect() {
+        // Verify the web driver is reachable
+        const alive = await this.checkAlive();
+        if (!alive) {
+            throw new Error(`Web driver on port ${this.port} is not responding. Is the web session 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 {
+                // Web driver may have restarted — keep polling
+            }
+            if (!this.stopped) {
+                this.pollTimer = setTimeout(poll, 500);
+            }
+        };
+        poll();
+    }
+    fetchLogs() {
+        return new Promise((resolve, reject) => {
+            const req = http_1.default.get(`http://${this.host}:${this.port}/consoleLogs?since=${encodeURIComponent(this.since)}`, (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 console logs'));
+            });
+            req.on('error', reject);
+        });
+    }
+    checkAlive() {
+        return new Promise((resolve) => {
+            const req = http_1.default.get(`http://${this.host}:${this.port}/status`, (res) => {
+                resolve(res.statusCode === 200);
+                res.resume();
+            });
+            req.setTimeout(2000, () => {
+                req.destroy();
+                resolve(false);
+            });
+            req.on('error', () => resolve(false));
+        });
+    }
+}
+exports.WebLogSource = WebLogSource;

package/dist/drivers/wait.js

@@ -9,6 +9,9 @@ exports.waitForIOSScreenToSettle = waitForIOSScreenToSettle;
 exports.waitForIOSTransitionToSettle = waitForIOSTransitionToSettle;
 exports.waitForIOSHierarchyToSettle = waitForIOSHierarchyToSettle;
 exports.waitForAndroidHierarchyToSettle = waitForAndroidHierarchyToSettle;
+exports.waitForWebElement = waitForWebElement;
+exports.waitUntilWebElementGone = waitUntilWebElementGone;
+exports.waitForWebHierarchyToSettle = waitForWebHierarchyToSettle;
 const element_resolver_js_1 = require("./element-resolver.js");
 const utils_js_1 = require("../utils.js");
 const DEFAULT_TIMEOUT_MS = 17000;
@@ -181,6 +184,60 @@ async function waitForAndroidHierarchyToSettle(getHierarchy, timeoutMs = 3000, i
         await (0, utils_js_1.sleep)(intervalMs);
     }
 }
+// ── Web ──────────────────────────────────────────────────────────────────────
+async function waitForWebElement(getHierarchy, selector, timeoutMs = DEFAULT_TIMEOUT_MS, intervalMs = DEFAULT_INTERVAL_MS) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            const hierarchy = await getHierarchy();
+            const el = (0, element_resolver_js_1.findWebElement)(hierarchy, selector);
+            if (el)
+                return el;
+        }
+        catch {
+            // Hierarchy fetch failed; keep retrying
+        }
+        await (0, utils_js_1.sleep)(intervalMs);
+    }
+    const desc = selectorDesc(selector);
+    throw new Error(`Element not found after ${timeoutMs}ms: ${desc}`);
+}
+async function waitUntilWebElementGone(getHierarchy, selector, timeoutMs = exports.OPTIONAL_TIMEOUT_MS) {
+    const deadline = Date.now() + timeoutMs;
+    do {
+        try {
+            const hierarchy = await getHierarchy();
+            if (!(0, element_resolver_js_1.findWebElement)(hierarchy, selector))
+                return;
+        }
+        catch {
+            return; // hierarchy fetch failed — treat as gone
+        }
+        await (0, utils_js_1.sleep)(DEFAULT_INTERVAL_MS);
+    } while (Date.now() < deadline);
+    const desc = selectorDesc(selector);
+    throw new Error(`Element still visible after ${timeoutMs}ms: ${desc}`);
+}
+/**
+ * Wait until the web page ARIA snapshot stops changing between consecutive polls.
+ */
+async function waitForWebHierarchyToSettle(getHierarchy, timeoutMs = 3000, intervalMs = 200) {
+    const deadline = Date.now() + timeoutMs;
+    let prev = null;
+    while (Date.now() < deadline) {
+        try {
+            const hierarchy = await getHierarchy();
+            const curr = hierarchy.ariaSnapshot;
+            if (curr === prev)
+                return; // stable
+            prev = curr;
+        }
+        catch {
+            // ignore
+        }
+        await (0, utils_js_1.sleep)(intervalMs);
+    }
+}
 function selectorDesc(sel) {
     const parts = [];
     if (sel.query)

package/dist/drivers/web.js

@@ -0,0 +1,173 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebDriver = void 0;
+/**
+ * HTTP client for the Conductor web browser driver.
+ * The driver runs inside the daemon process at http://127.0.0.1:4075 (or custom port).
+ *
+ * Protocol: plain HTTP REST with JSON bodies — mirrors the iOS XCTest driver pattern.
+ * The daemon-side web-server.ts wraps Playwright and exposes these endpoints.
+ */
+const http_1 = __importDefault(require("http"));
+class WebDriver {
+    constructor(port = 4075, host = '127.0.0.1', deviceId) {
+        this.port = port;
+        this.host = host;
+        this.deviceId = deviceId;
+    }
+    request(method, path, body) {
+        return new Promise((resolve, reject) => {
+            const bodyBuf = body !== undefined ? Buffer.from(JSON.stringify(body), 'utf-8') : undefined;
+            const options = {
+                hostname: this.host,
+                port: this.port,
+                path,
+                method,
+                headers: {
+                    ...(bodyBuf
+                        ? { 'Content-Type': 'application/json', 'Content-Length': bodyBuf.length }
+                        : {}),
+                },
+            };
+            const req = http_1.default.request(options, (res) => {
+                const chunks = [];
+                res.on('data', (chunk) => chunks.push(chunk));
+                res.on('end', () => resolve({ status: res.statusCode ?? 0, data: Buffer.concat(chunks) }));
+                res.on('error', reject);
+            });
+            req.setTimeout(30000, () => {
+                req.destroy(new Error(`Web driver request timed out: ${method} ${path}`));
+            });
+            req.on('error', reject);
+            if (bodyBuf)
+                req.write(bodyBuf);
+            req.end();
+        });
+    }
+    async post(path, body) {
+        const { status, data } = await this.request('POST', `/${path}`, body);
+        if (status < 200 || status >= 300) {
+            throw new Error(`Web driver ${path} failed (HTTP ${status}): ${data.toString('utf-8').slice(0, 200)}`);
+        }
+    }
+    async get(path) {
+        const { status, data } = await this.request('GET', `/${path}`);
+        if (status < 200 || status >= 300) {
+            throw new Error(`Web driver GET ${path} failed (HTTP ${status}): ${data.toString('utf-8').slice(0, 200)}`);
+        }
+        return JSON.parse(data.toString('utf-8'));
+    }
+    async isAlive() {
+        try {
+            const { status } = await this.request('GET', '/status');
+            return status >= 200 && status < 300;
+        }
+        catch {
+            return false;
+        }
+    }
+    async deviceInfo() {
+        return this.get('deviceInfo');
+    }
+    async tap(x, y, duration) {
+        await this.post('tap', { x, y, ...(duration !== undefined ? { duration } : {}) });
+    }
+    async swipe(startX, startY, endX, endY, duration) {
+        await this.post('swipe', { startX, startY, endX, endY, duration });
+    }
+    async inputText(text) {
+        await this.post('inputText', { text });
+    }
+    async pressKey(key) {
+        await this.post('pressKey', { key });
+    }
+    async launchApp(url) {
+        await this.post('launchApp', { url });
+    }
+    async terminateApp() {
+        await this.post('terminateApp', {});
+    }
+    async clearAppState() {
+        await this.post('clearAppState', {});
+    }
+    async openLink(url) {
+        await this.post('navigate', { url });
+    }
+    async navigate(url) {
+        await this.post('navigate', { url });
+    }
+    async goBack() {
+        await this.post('goBack', {});
+    }
+    async goForward() {
+        await this.post('goForward', {});
+    }
+    async reload() {
+        await this.post('reload', {});
+    }
+    async clearCookies() {
+        await this.post('clearCookies', {});
+    }
+    async clearStorage() {
+        await this.post('clearStorage', {});
+    }
+    async clearKeychain() {
+        // Web equivalent: clear cookies
+        await this.clearCookies();
+    }
+    async viewHierarchy() {
+        return this.get('viewHierarchy');
+    }
+    async screenshot() {
+        const { status, data } = await this.request('GET', '/screenshot');
+        if (status < 200 || status >= 300) {
+            throw new Error(`Web driver screenshot failed (HTTP ${status})`);
+        }
+        return data;
+    }
+    async isScreenStatic() {
+        const result = await this.get('isScreenStatic');
+        return result.isScreenStatic;
+    }
+    async runningApp() {
+        const result = await this.get('runningApp');
+        return result.runningAppBundleId;
+    }
+    async eraseAllText(count = 50) {
+        await this.post('eraseText', { count });
+    }
+    // ── Stub methods for mobile-only features ──────────────────────────────────
+    // These throw clear errors rather than silently no-op so the user knows
+    // the command isn't applicable to web.
+    async setLocation(_latitude, _longitude) {
+        throw new Error('setLocation is not supported on web');
+    }
+    async setOrientation(_orientation) {
+        throw new Error('setOrientation is not supported on web');
+    }
+    async setPermissions(_appId, _permissions) {
+        throw new Error('setPermissions is not supported on web');
+    }
+    async addMedia(_filePath) {
+        throw new Error('addMedia is not supported on web');
+    }
+    async setAirplaneMode(_enabled) {
+        throw new Error('setAirplaneMode is not supported on web');
+    }
+    async getAirplaneMode() {
+        throw new Error('getAirplaneMode is not supported on web');
+    }
+    async startRecording(_outputPath) {
+        throw new Error('startRecording is not supported on web');
+    }
+    async stopRecording() {
+        throw new Error('stopRecording is not supported on web');
+    }
+    async uninstallApp(_appId) {
+        throw new Error('uninstallApp is not supported on web');
+    }
+}
+exports.WebDriver = WebDriver;