@houwert/conductor 0.4.0 → 0.6.0

package/dist/daemon/log-collector.js

@@ -0,0 +1,408 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogCollector = void 0;
+/**
+ * Daemon-side log collector — manages a platform-specific log source and
+ * buffers entries in a circular buffer for HTTP query access.
+ *
+ * Reuses the existing IOSLogSource / AndroidLogSource classes (which spawn
+ * simctl / adb logcat). For web, polls the co-located web-server's
+ * /consoleLogs endpoint.
+ *
+ * Optionally discovers and connects to a Metro dev server for React Native
+ * JS-level console logs. This is opt-in: call enableMetro(port) to start
+ * background discovery. Metro entries are merged into the same buffer with
+ * source='metro'.
+ */
+const http_1 = __importDefault(require("http"));
+const child_process_1 = require("child_process");
+const types_js_1 = require("../drivers/log-sources/types.js");
+const ios_js_1 = require("../drivers/log-sources/ios.js");
+const android_js_1 = require("../drivers/log-sources/android.js");
+const metro_js_1 = require("../drivers/log-sources/metro.js");
+const MAX_BUFFER = 5000;
+const RESTART_DELAY_MS = 2000;
+const WEB_POLL_INTERVAL_MS = 500;
+const METRO_DISCOVERY_INTERVAL_MS = 3000;
+const METRO_AUTO_DISCOVERY_MAX_ATTEMPTS = 10;
+/** Known Metro dev server port ranges. */
+const METRO_PORT_RANGES = [
+    [8080, 8099], // Metro default range
+    [19000, 19002], // Expo
+];
+function isMetroPort(port) {
+    return METRO_PORT_RANGES.some(([lo, hi]) => port >= lo && port <= hi);
+}
+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 (${code})`)));
+        proc.on('error', reject);
+    });
+}
+class LogCollector {
+    constructor(platform, deviceId, driverPort, appId, dlog) {
+        this.platform = platform;
+        this.deviceId = deviceId;
+        this.driverPort = driverPort;
+        this.appId = appId;
+        this.dlog = dlog;
+        this.buffer = [];
+        this.source = null;
+        this.stopped = false;
+        this.restartTimer = null;
+        // Web polling state
+        this.webPollTimer = null;
+        this.webSince = new Date().toISOString();
+        // Metro auto-discovery state
+        this.metroSource = null;
+        this.metroDiscoveryTimer = null;
+        this.metroPort = null;
+        this.metroConnected = false;
+        this.metroAutoDiscovery = false;
+        this.metroAutoDiscoveryAttempts = 0;
+    }
+    async start() {
+        this.stopped = false;
+        if (this.platform === 'web') {
+            this.startWebPolling();
+            return;
+        }
+        await this.startSource();
+    }
+    stop() {
+        this.stopped = true;
+        if (this.restartTimer) {
+            clearTimeout(this.restartTimer);
+            this.restartTimer = null;
+        }
+        if (this.webPollTimer) {
+            clearTimeout(this.webPollTimer);
+            this.webPollTimer = null;
+        }
+        if (this.metroDiscoveryTimer) {
+            clearTimeout(this.metroDiscoveryTimer);
+            this.metroDiscoveryTimer = null;
+        }
+        if (this.source) {
+            this.source.disconnect();
+            this.source = null;
+        }
+        if (this.metroSource) {
+            this.metroSource.disconnect();
+            this.metroSource = null;
+            this.metroConnected = false;
+        }
+    }
+    /**
+     * Enable Metro log collection for React Native apps.
+     *
+     * When `port` is given, connects directly to that Metro port.
+     * When omitted, auto-discovers the Metro port by probing the device:
+     *   - Android: parses `adb reverse --list` for forwarded Metro ports
+     *   - iOS/tvOS: scans `lsof` for node listeners in Metro port ranges,
+     *     then probes `/json` and matches by deviceId (strict — no appId fallback)
+     *
+     * This is opt-in — only call this for React Native apps.
+     */
+    enableMetro(port) {
+        if (this.platform === 'web')
+            return; // Web already has console logs
+        if (port !== undefined) {
+            // Explicit port — same as before
+            if (this.metroPort === port)
+                return;
+            this.teardownMetro();
+            this.metroAutoDiscovery = false;
+            this.metroPort = port;
+            this.startMetroDiscovery();
+        }
+        else {
+            // Auto-discover
+            if (this.metroAutoDiscovery || this.metroConnected)
+                return;
+            this.teardownMetro();
+            this.metroAutoDiscovery = true;
+            this.metroAutoDiscoveryAttempts = 0;
+            this.startAutoDiscovery();
+        }
+    }
+    teardownMetro() {
+        if (this.metroSource) {
+            this.metroSource.disconnect();
+            this.metroSource = null;
+            this.metroConnected = false;
+        }
+        if (this.metroDiscoveryTimer) {
+            clearTimeout(this.metroDiscoveryTimer);
+            this.metroDiscoveryTimer = null;
+        }
+    }
+    query(opts = {}) {
+        let entries = this.buffer;
+        if (opts.since) {
+            const since = opts.since;
+            entries = entries.filter((e) => e.timestamp > since);
+        }
+        if (opts.level) {
+            const minSeverity = types_js_1.LEVEL_SEVERITY[opts.level] ?? 0;
+            entries = entries.filter((e) => (types_js_1.LEVEL_SEVERITY[e.level] ?? 0) >= minSeverity);
+        }
+        if (opts.limit && opts.limit > 0) {
+            // Return the most recent N entries
+            entries = entries.slice(-opts.limit);
+        }
+        return entries;
+    }
+    pushEntry(entry) {
+        this.buffer.push(entry);
+        if (this.buffer.length > MAX_BUFFER) {
+            this.buffer.splice(0, this.buffer.length - MAX_BUFFER);
+        }
+    }
+    async startSource() {
+        if (this.stopped)
+            return;
+        try {
+            if (this.platform === 'ios' || this.platform === 'tvos') {
+                this.source = new ios_js_1.IOSLogSource(this.deviceId, this.appId);
+            }
+            else if (this.platform === 'android') {
+                this.source = new android_js_1.AndroidLogSource(this.deviceId, this.appId);
+            }
+            else {
+                return; // Unsupported platform for device log collection
+            }
+            this.source.onEntry((entry) => this.pushEntry(entry));
+            await this.source.connect();
+        }
+        catch {
+            // Source failed to start — schedule a retry
+            this.scheduleRestart();
+        }
+    }
+    scheduleRestart() {
+        if (this.stopped)
+            return;
+        this.restartTimer = setTimeout(() => {
+            this.restartTimer = null;
+            this.startSource().catch(() => this.scheduleRestart());
+        }, RESTART_DELAY_MS);
+    }
+    // ── Web polling ──────────────────────────────────────────────────────────
+    startWebPolling() {
+        const poll = async () => {
+            if (this.stopped)
+                return;
+            try {
+                const entries = await this.fetchWebLogs();
+                for (const entry of entries) {
+                    this.pushEntry(entry);
+                }
+                if (entries.length > 0) {
+                    this.webSince = entries[entries.length - 1].timestamp;
+                }
+            }
+            catch {
+                // Web driver may be restarting — keep polling
+            }
+            if (!this.stopped) {
+                this.webPollTimer = setTimeout(poll, WEB_POLL_INTERVAL_MS);
+            }
+        };
+        poll();
+    }
+    fetchWebLogs() {
+        return new Promise((resolve, reject) => {
+            const req = http_1.default.get(`http://127.0.0.1:${this.driverPort}/consoleLogs?since=${encodeURIComponent(this.webSince)}`, (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 web console logs'));
+            });
+            req.on('error', reject);
+        });
+    }
+    // ── Metro auto-discovery ─────────────────────────────────────────────────
+    async startAutoDiscovery() {
+        if (this.stopped || this.metroConnected)
+            return;
+        this.metroAutoDiscoveryAttempts++;
+        try {
+            const port = await this.discoverMetroPort();
+            if (port !== null) {
+                this.dlog?.(`Metro auto-discovered on port ${port} for device ${this.deviceId}`);
+                this.metroPort = port;
+                this.startMetroDiscovery();
+                return;
+            }
+        }
+        catch {
+            // Discovery failed — retry
+        }
+        if (this.metroAutoDiscoveryAttempts >= METRO_AUTO_DISCOVERY_MAX_ATTEMPTS) {
+            this.dlog?.(`Metro auto-discovery: no Metro instance found for device ${this.deviceId} after ${this.metroAutoDiscoveryAttempts} attempts. Use --metro-port to specify.`);
+            this.metroAutoDiscovery = false;
+            return;
+        }
+        // Retry — app may not have started yet
+        if (!this.stopped) {
+            this.metroDiscoveryTimer = setTimeout(() => {
+                this.metroDiscoveryTimer = null;
+                this.startAutoDiscovery();
+            }, METRO_DISCOVERY_INTERVAL_MS);
+        }
+    }
+    /**
+     * Discover the Metro dev server port by probing the device.
+     *
+     * Android: parse `adb reverse --list` for forwarded ports in Metro ranges.
+     * iOS/tvOS: scan `lsof` for node listeners in Metro ranges, probe `/json`,
+     * and strictly match by deviceId (no appId/single-target fallback).
+     */
+    async discoverMetroPort() {
+        if (this.platform === 'android') {
+            return this.discoverMetroPortAndroid();
+        }
+        if (this.platform === 'ios' || this.platform === 'tvos') {
+            return this.discoverMetroPortIOS();
+        }
+        return null;
+    }
+    async discoverMetroPortAndroid() {
+        try {
+            const output = await spawnCapture('adb', ['-s', this.deviceId, 'reverse', '--list']);
+            // Lines look like: host-13 tcp:8082 tcp:8082
+            for (const line of output.split('\n')) {
+                const match = line.match(/tcp:(\d+)\s+tcp:(\d+)/);
+                if (!match)
+                    continue;
+                const hostPort = parseInt(match[2], 10);
+                if (isMetroPort(hostPort))
+                    return hostPort;
+            }
+        }
+        catch {
+            // adb not available or device not connected
+        }
+        return null;
+    }
+    async discoverMetroPortIOS() {
+        try {
+            const output = await spawnCapture('lsof', ['-iTCP', '-sTCP:LISTEN', '-n', '-P']);
+            const ports = new Set();
+            for (const line of output.split('\n')) {
+                if (!line.startsWith('node'))
+                    continue;
+                // Column 9 is NAME, e.g. "*:8082" or "[::1]:8082" or "127.0.0.1:8082"
+                const match = line.match(/:(\d+)\s/);
+                if (!match)
+                    continue;
+                const port = parseInt(match[1], 10);
+                if (isMetroPort(port))
+                    ports.add(port);
+            }
+            if (ports.size === 0)
+                return null;
+            // Probe all candidate ports in parallel
+            const results = await Promise.all([...ports].map(async (port) => {
+                try {
+                    const targets = await (0, metro_js_1.fetchTargets)(port, 'localhost');
+                    const withWs = targets.filter((t) => t.webSocketDebuggerUrl);
+                    // Strict deviceId match only — no appId or single-target fallback
+                    const match = withWs.find((t) => t.deviceId === this.deviceId || t.reactNative?.logicalDeviceId === this.deviceId);
+                    return match ? port : null;
+                }
+                catch {
+                    return null;
+                }
+            }));
+            return results.find((p) => p !== null) ?? null;
+        }
+        catch {
+            // lsof not available
+        }
+        return null;
+    }
+    startMetroDiscovery() {
+        if (this.stopped || this.metroPort === null)
+            return;
+        this.tryConnectMetro();
+    }
+    async tryConnectMetro() {
+        if (this.stopped || this.metroPort === null || this.metroConnected)
+            return;
+        try {
+            const targets = await (0, metro_js_1.fetchTargets)(this.metroPort, 'localhost');
+            const target = this.findTargetForDevice(targets);
+            if (!target || !target.webSocketDebuggerUrl) {
+                // Target not found yet — app may still be starting. Retry later.
+                this.scheduleMetroDiscovery();
+                return;
+            }
+            // Found a matching target — connect
+            const targetIndex = targets.filter((t) => t.webSocketDebuggerUrl).indexOf(target);
+            this.metroSource = new metro_js_1.MetroLogSource(this.metroPort, 'localhost', targetIndex >= 0 ? targetIndex : undefined);
+            this.metroSource.onEntry((entry) => this.pushEntry(entry));
+            await this.metroSource.connect();
+            this.metroConnected = true;
+            this.dlog?.(`Metro connected for device ${this.deviceId} on port ${this.metroPort}`);
+        }
+        catch {
+            // Metro not running or connection failed — retry
+            this.scheduleMetroDiscovery();
+        }
+    }
+    /**
+     * Find a Metro debugger target that matches this daemon's device.
+     * Checks deviceId (simulator UDID / emulator serial) first,
+     * then falls back to matching by appId if available.
+     */
+    findTargetForDevice(targets) {
+        const withWs = targets.filter((t) => t.webSocketDebuggerUrl);
+        if (withWs.length === 0)
+            return undefined;
+        // Prefer exact deviceId match (simulator UDID / emulator serial)
+        const byDevice = withWs.find((t) => t.deviceId === this.deviceId || t.reactNative?.logicalDeviceId === this.deviceId);
+        if (byDevice)
+            return byDevice;
+        // Fall back to appId match if we know the app
+        if (this.appId) {
+            const byApp = withWs.find((t) => t.appId === this.appId);
+            if (byApp)
+                return byApp;
+        }
+        // Single target — safe to use without matching
+        if (withWs.length === 1)
+            return withWs[0];
+        // Multiple targets, no match — don't guess
+        return undefined;
+    }
+    scheduleMetroDiscovery() {
+        if (this.stopped || this.metroConnected)
+            return;
+        this.metroDiscoveryTimer = setTimeout(() => {
+            this.metroDiscoveryTimer = null;
+            this.tryConnectMetro();
+        }, METRO_DISCOVERY_INTERVAL_MS);
+    }
+}
+exports.LogCollector = LogCollector;

package/dist/daemon/server.js

@@ -14,12 +14,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
  *
  * Spawned by: node dist/daemon/server.js [sessionName]
  */
-const net_1 = __importDefault(require("net"));
+const http_1 = __importDefault(require("http"));
+const url_1 = __importDefault(require("url"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const protocol_js_1 = require("./protocol.js");
 const bootstrap_js_1 = require("../drivers/bootstrap.js");
 const android_js_1 = require("../drivers/android.js");
+const web_server_js_1 = require("./web-server.js");
+const log_collector_js_1 = require("./log-collector.js");
+const session_js_1 = require("../session.js");
 const sessionName = process.argv[2] ?? 'default';
 const SOCKET_PATH = (0, protocol_js_1.socketPath)(sessionName);
 const PID_FILE = (0, protocol_js_1.pidFile)(sessionName);
@@ -36,6 +40,7 @@ function dlog(msg) {
 // ── Driver lifecycle ──────────────────────────────────────────────────────────
 let driverPort = 1075;
 let driverPlatform = 'ios';
+let logCollector = null;
 const DRIVER_HEALTH_INTERVAL_MS = 10000; // Check driver health every 10s
 let _restartInProgress = false;
 let _driverStarted = false;
@@ -50,7 +55,7 @@ async function ensureDriverRunning() {
         probe.close();
     }
     else {
-        // Both 'ios' and 'tvos' use an HTTP server — port open = alive
+        // 'ios', 'tvos', and 'web' all use an HTTP server — port open = alive
         alive = await (0, bootstrap_js_1.isPortOpen)(driverPort);
     }
     if (!alive) {
@@ -69,6 +74,9 @@ async function ensureDriverRunning() {
                 // Health-check restart — don't dismiss, to avoid disrupting user's app
                 await (0, bootstrap_js_1.startTvOSDriver)(sessionName, driverPort, /* dismissAfterLaunch */ false);
             }
+            else if (driverPlatform === 'web') {
+                await (0, web_server_js_1.startWebServer)(driverPort, (0, bootstrap_js_1.webBrowserName)(sessionName), dlog);
+            }
             else {
                 await (0, bootstrap_js_1.startAndroidDriver)(sessionName, driverPort);
             }
@@ -109,6 +117,10 @@ async function main() {
     async function cleanup() {
         if (healthTimer)
             clearInterval(healthTimer);
+        if (logCollector) {
+            logCollector.stop();
+            logCollector = null;
+        }
         try {
             fs_1.default.unlinkSync(SOCKET_PATH);
         }
@@ -140,6 +152,15 @@ async function main() {
             if (driverPlatform === 'tvos') {
                 dlog('tvOS: leaving driver running to preserve app state');
             }
+            else if (driverPlatform === 'web') {
+                dlog('Stopping web driver');
+                try {
+                    await (0, web_server_js_1.stopWebServer)();
+                }
+                catch (err) {
+                    dlog(`Stop web driver error: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
             else {
                 dlog(`Stopping driver on port ${driverPort}`);
                 try {
@@ -176,17 +197,53 @@ async function main() {
         }, DRIVER_HEALTH_INTERVAL_MS);
         healthTimer.unref(); // Don't keep the process alive just for health checks
     }
-    // Create socket — accept connections as aliveness pings (no message exchange needed)
-    const server = net_1.default.createServer({ allowHalfOpen: true }, (socket) => {
-        resetIdleTimer();
-        // Close immediately — the connect/accept is enough for daemonStatus()
-        socket.end();
-        socket.on('error', () => {
-            /* ignore */
+    // ── HTTP server on Unix socket ─────────────────────────────────────────────
+    // Replaces the old raw-TCP accept-and-close with a proper HTTP server so we
+    // can serve /status (aliveness) and /logs (buffered log entries).
+    function jsonResponse(res, body, status = 200) {
+        const json = JSON.stringify(body);
+        res.writeHead(status, {
+            'Content-Type': 'application/json',
+            'Content-Length': Buffer.byteLength(json),
         });
+        res.end(json);
+    }
+    const server = http_1.default.createServer((req, res) => {
+        resetIdleTimer();
+        const parsed = url_1.default.parse(req.url ?? '/', true);
+        if (req.method === 'GET' && parsed.pathname === '/status') {
+            jsonResponse(res, { ok: true, platform: driverPlatform, driverPort });
+            return;
+        }
+        if (req.method === 'GET' && parsed.pathname === '/logs') {
+            if (!logCollector) {
+                jsonResponse(res, { entries: [] });
+                return;
+            }
+            const q = parsed.query;
+            // Opt-in Metro discovery: ?metro=8081 uses that port directly,
+            // ?metro (no value) or ?metro=auto triggers auto-discovery.
+            if (q.metro !== undefined) {
+                const metroPort = typeof q.metro === 'string' ? parseInt(q.metro, 10) : NaN;
+                if (metroPort > 0) {
+                    logCollector.enableMetro(metroPort);
+                }
+                else {
+                    logCollector.enableMetro(); // auto-discover
+                }
+            }
+            const entries = logCollector.query({
+                since: typeof q.since === 'string' ? q.since : undefined,
+                level: typeof q.level === 'string' ? q.level : undefined,
+                limit: typeof q.limit === 'string' ? parseInt(q.limit, 10) || undefined : undefined,
+            });
+            jsonResponse(res, { entries });
+            return;
+        }
+        jsonResponse(res, { error: 'not found' }, 404);
     });
     server.listen(SOCKET_PATH, () => {
-        dlog(`socket ready at ${SOCKET_PATH}`);
+        dlog(`HTTP socket ready at ${SOCKET_PATH}`);
         resetIdleTimer();
         // Start driver in the background after the socket is ready (so the client
         // doesn't time out waiting for the socket while the driver is starting).
@@ -204,38 +261,59 @@ async function main() {
                     probe.close();
                 }
                 else {
-                    // Both 'ios' and 'tvos' use an HTTP server — port open = alive
+                    // 'ios', 'tvos', and 'web' all use an HTTP server — port open = alive
                     driverAlive = await (0, bootstrap_js_1.isPortOpen)(driverPort);
                 }
                 if (driverAlive) {
                     _driverStarted = true;
                     dlog(`Driver already running on port ${driverPort}`);
-                    return;
-                }
-                // Android: install APKs before starting the driver.
-                // iOS/tvOS: xcodebuild installs silently via DependentProductPaths.
-                if (platform === 'android') {
-                    dlog(`Installing Android driver on ${sessionName}`);
-                    await (0, bootstrap_js_1.installDriver)(sessionName);
-                    dlog(`Driver installation complete`);
                 }
-                dlog(`Starting ${platform} driver on port ${driverPort}`);
-                try {
-                    if (platform === 'ios') {
-                        await (0, bootstrap_js_1.startIOSDriver)(sessionName, driverPort);
+                else {
+                    // Android: install APKs before starting the driver.
+                    // iOS/tvOS: xcodebuild installs silently via DependentProductPaths.
+                    // Web: ensure Playwright browser binary is installed.
+                    if (platform === 'android') {
+                        dlog(`Installing Android driver on ${sessionName}`);
+                        await (0, bootstrap_js_1.installDriver)(sessionName);
+                        dlog(`Driver installation complete`);
                     }
-                    else if (platform === 'tvos') {
-                        // First install — dismiss the runner app to return to homescreen
-                        await (0, bootstrap_js_1.startTvOSDriver)(sessionName, driverPort, /* dismissAfterLaunch */ true);
+                    else if (platform === 'web') {
+                        const browser = (0, bootstrap_js_1.webBrowserName)(sessionName);
+                        await (0, bootstrap_js_1.ensurePlaywrightBrowser)(browser, dlog);
                     }
-                    else {
-                        await (0, bootstrap_js_1.startAndroidDriver)(sessionName, driverPort);
+                    dlog(`Starting ${platform} driver on port ${driverPort}`);
+                    try {
+                        if (platform === 'ios') {
+                            await (0, bootstrap_js_1.startIOSDriver)(sessionName, driverPort);
+                        }
+                        else if (platform === 'tvos') {
+                            // First install — dismiss the runner app to return to homescreen
+                            await (0, bootstrap_js_1.startTvOSDriver)(sessionName, driverPort, /* dismissAfterLaunch */ true);
+                        }
+                        else if (platform === 'web') {
+                            await (0, web_server_js_1.startWebServer)(driverPort, (0, bootstrap_js_1.webBrowserName)(sessionName), dlog);
+                        }
+                        else {
+                            await (0, bootstrap_js_1.startAndroidDriver)(sessionName, driverPort);
+                        }
+                        _driverStarted = true;
+                        dlog(`Driver started successfully`);
+                    }
+                    catch (err) {
+                        dlog(`Driver startup error: ${err instanceof Error ? err.message : String(err)}`);
                     }
-                    _driverStarted = true;
-                    dlog(`Driver started successfully`);
                 }
-                catch (err) {
-                    dlog(`Driver startup error: ${err instanceof Error ? err.message : String(err)}`);
+                // Start collecting logs once the driver is (or was already) running.
+                if (_driverStarted) {
+                    try {
+                        const session = await (0, session_js_1.getSession)(sessionName);
+                        logCollector = new log_collector_js_1.LogCollector(platform, sessionName, driverPort, session.appId, dlog);
+                        await logCollector.start();
+                        dlog(`Log collector started${session.appId ? ` (appId=${session.appId})` : ''}`);
+                    }
+                    catch (err) {
+                        dlog(`Log collector startup error: ${err instanceof Error ? err.message : String(err)}`);
+                    }
                 }
             })
                 .catch((err) => {