@houwert/conductor 0.7.1 → 0.9.0

package/dist/commands/delete-device.js

@@ -1,12 +1,19 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HELP = void 0;
 exports.deleteDevice = deleteDevice;
 exports.HELP = `  delete-device <name-or-id>
-    --platform <ios|tvos|android>  Scope to a single platform
-    --all                          Delete all shutdown simulators / non-running AVDs`;
+    --platform <ios|tvos|android|web> Scope to a single platform
+    --all                             Delete all shutdown simulators / non-running AVDs / web sessions`;
+const fs_1 = __importDefault(require("fs"));
 const runner_js_1 = require("../runner.js");
 const output_js_1 = require("../output.js");
+const client_js_1 = require("../daemon/client.js");
+const protocol_js_1 = require("../daemon/protocol.js");
+const bootstrap_js_1 = require("../drivers/bootstrap.js");
 async function listSimulators() {
     const result = await (0, runner_js_1.spawnCommand)('xcrun', ['simctl', 'list', 'devices', '--json']);
     if (!result.success)
@@ -89,6 +96,7 @@ async function deleteDevice(nameOrId, opts, flags) {
     const includeIOS = !platform || platform === 'ios';
     const includeTvOS = !platform || platform === 'tvos';
     const includeAndroid = !platform || platform === 'android';
+    const includeWeb = !platform || platform === 'web';
     const deleted = [];
     // ── --all mode ───────────────────────────────────────────────────────────
     if (flags.all) {
@@ -135,6 +143,26 @@ async function deleteDevice(nameOrId, opts, flags) {
                 }
             }
         }
+        // Web: stop all running web daemon sessions
+        if (includeWeb) {
+            const sessions = (0, client_js_1.listDaemonSessions)();
+            for (const session of sessions) {
+                if (!(session === 'web' || session.startsWith('web:')))
+                    continue;
+                const status = await (0, client_js_1.daemonStatus)(session);
+                if (!status.running)
+                    continue;
+                try {
+                    await (0, client_js_1.stopDaemon)(session);
+                    const browser = (0, bootstrap_js_1.webBrowserName)(session);
+                    const label = browser.charAt(0).toUpperCase() + browser.slice(1);
+                    deleted.push({ id: session, name: label, platform: 'web' });
+                }
+                catch (e) {
+                    (0, output_js_1.printError)(`Failed to stop web session ${session}: ${e instanceof Error ? e.message : String(e)}`, opts);
+                }
+            }
+        }
         if (deleted.length === 0) {
             (0, output_js_1.printError)('No devices to delete.', opts);
             return 1;
@@ -217,6 +245,40 @@ async function deleteDevice(nameOrId, opts, flags) {
             return 0;
         }
     }
+    // Try Web session (match by session ID or persisted name)
+    if (includeWeb && nameOrId) {
+        const sessions = (0, client_js_1.listDaemonSessions)();
+        const match = sessions.find((s) => {
+            if (!(s === 'web' || s.startsWith('web:')))
+                return false;
+            if (s === nameOrId)
+                return true;
+            try {
+                return fs_1.default.readFileSync((0, protocol_js_1.nameFile)(s), 'utf-8').trim() === nameOrId;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (match) {
+            try {
+                await (0, client_js_1.stopDaemon)(match);
+            }
+            catch (e) {
+                (0, output_js_1.printError)(e instanceof Error ? e.message : String(e), opts);
+                return 1;
+            }
+            const browser = (0, bootstrap_js_1.webBrowserName)(match);
+            const label = browser.charAt(0).toUpperCase() + browser.slice(1);
+            if (opts.json) {
+                (0, output_js_1.printData)({ status: 'ok', deleted: [{ id: match, name: label, platform: 'web' }] }, opts);
+            }
+            else {
+                (0, output_js_1.printSuccess)(`Stopped web session: ${label} (${match})`, opts);
+            }
+            return 0;
+        }
+    }
     (0, output_js_1.printError)(`Device "${nameOrId}" not found.`, opts);
     return 1;
 }

package/dist/commands/download-app.js

@@ -28,6 +28,10 @@ async function downloadApp(appId, output, opts = {}, sessionName = 'default') {
         return 1;
     }
     const platform = await (0, bootstrap_js_1.detectPlatform)(deviceId);
+    if (platform === 'web') {
+        (0, output_js_1.printError)('download-app is not supported on web.', opts);
+        return 1;
+    }
     if (platform === 'ios' || platform === 'tvos') {
         // Get the .app bundle path from the simulator
         const getPath = await (0, runner_js_1.spawnCommand)('xcrun', [

package/dist/commands/install-app.js

@@ -24,7 +24,11 @@ async function installApp(appPath, opts = {}, sessionName = 'default') {
         return 1;
     }
     const platform = await (0, bootstrap_js_1.detectPlatform)(deviceId);
-    if (platform === 'ios' || platform === 'tvos') {
+    if (platform === 'web') {
+        (0, output_js_1.printError)('install-app is not supported on web. Use launch-app with a URL instead.', opts);
+        return 1;
+    }
+    else if (platform === 'ios' || platform === 'tvos') {
         const result = await (0, runner_js_1.spawnCommand)('xcrun', ['simctl', 'install', deviceId, appPath]);
         if (!result.success) {
             (0, output_js_1.printError)(`install-app failed: ${result.stderr}`, opts);

package/dist/commands/list-apps.js

@@ -21,7 +21,11 @@ async function listApps(opts = {}, sessionName = 'default') {
     }
     const platform = await (0, bootstrap_js_1.detectPlatform)(deviceId);
     let appIds;
-    if (platform === 'ios' || platform === 'tvos') {
+    if (platform === 'web') {
+        (0, output_js_1.printError)('list-apps is not supported on web. Use foreground-app to get the current URL.', opts);
+        return 1;
+    }
+    else if (platform === 'ios' || platform === 'tvos') {
         const result = await (0, runner_js_1.spawnCommand)('bash', [
             '-c',
             `xcrun simctl listapps ${deviceId} | plutil -convert json - -o -`,

package/dist/commands/list-devices.js

@@ -1,14 +1,19 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HELP = void 0;
 exports.discoverBootedDevices = discoverBootedDevices;
 exports.discoverAvailableDevices = discoverAvailableDevices;
 exports.listDevices = listDevices;
 exports.HELP = `  list-devices                        List booted and available devices/simulators`;
+const fs_1 = __importDefault(require("fs"));
 const runner_js_1 = require("../runner.js");
 const output_js_1 = require("../output.js");
 const bootstrap_js_1 = require("../drivers/bootstrap.js");
 const client_js_1 = require("../daemon/client.js");
+const protocol_js_1 = require("../daemon/protocol.js");
 async function discoverBootedDevices() {
     const devices = [];
     // Try adb devices (Android)
@@ -58,9 +63,15 @@ async function discoverBootedDevices() {
             const status = await (0, client_js_1.daemonStatus)(session);
             if (status.running) {
                 const browser = (0, bootstrap_js_1.webBrowserName)(session);
-                const parts = session.split(':');
                 const label = browser.charAt(0).toUpperCase() + browser.slice(1);
-                const name = parts.length > 2 ? `${label} (${parts[2]})` : label;
+                let name;
+                try {
+                    const saved = fs_1.default.readFileSync((0, protocol_js_1.nameFile)(session), 'utf-8').trim();
+                    name = saved || label;
+                }
+                catch {
+                    name = label;
+                }
                 devices.push({
                     id: session,
                     name,
@@ -106,6 +117,19 @@ async function discoverAvailableDevices() {
             }
         }
     }
+    // Web: installed Playwright browsers that aren't currently running
+    const runningSessions = (0, client_js_1.listDaemonSessions)();
+    const runningBrowsers = new Set(runningSessions.filter((s) => s === 'web' || s.startsWith('web:')).map((s) => (0, bootstrap_js_1.webBrowserName)(s)));
+    for (const browser of ['chromium', 'firefox', 'webkit']) {
+        if ((0, bootstrap_js_1.isPlaywrightBrowserInstalled)(browser)) {
+            devices.push({
+                id: browser === 'chromium' ? 'web' : `web:${browser}`,
+                name: browser.charAt(0).toUpperCase() + browser.slice(1),
+                platform: 'web',
+                status: runningBrowsers.has(browser) ? 'installed' : 'available',
+            });
+        }
+    }
     return devices;
 }
 async function listDevices(opts) {
@@ -113,20 +137,12 @@ async function listDevices(opts) {
         discoverBootedDevices(),
         discoverAvailableDevices(),
     ]);
-    // Detect installed Playwright browsers for web support
-    const webBrowsers = ['chromium', 'firefox', 'webkit'].filter((b) => (0, bootstrap_js_1.isPlaywrightBrowserInstalled)(b));
-    if (devices.length === 0 && availableDevices.length === 0 && webBrowsers.length === 0) {
+    if (devices.length === 0 && availableDevices.length === 0) {
         (0, output_js_1.printError)('No devices found. Start an emulator or simulator first.', opts);
         return 1;
     }
     if (opts.json) {
-        const webDevices = webBrowsers.map((b) => ({
-            id: b === 'chromium' ? 'web' : `web:${b}`,
-            name: b.charAt(0).toUpperCase() + b.slice(1),
-            platform: 'web',
-            status: 'available',
-        }));
-        (0, output_js_1.printData)({ status: 'ok', devices, availableDevices: [...availableDevices, ...webDevices] }, opts);
+        (0, output_js_1.printData)({ status: 'ok', devices, availableDevices }, opts);
     }
     else {
         if (devices.length > 0) {
@@ -148,14 +164,6 @@ async function listDevices(opts) {
         else {
             console.log('No available devices.');
         }
-        if (webBrowsers.length > 0) {
-            console.log('');
-            console.log('Web browsers:');
-            for (const b of webBrowsers) {
-                const deviceId = b === 'chromium' ? 'web' : `web:${b}`;
-                console.log(`  web      available   ${deviceId.padEnd(16)} ${b.charAt(0).toUpperCase() + b.slice(1)}`);
-            }
-        }
     }
     return 0;
 }

package/dist/commands/start-device.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HELP = void 0;
 exports.startDevice = startDevice;
@@ -6,12 +9,15 @@ exports.HELP = `  start-device
     --platform <ios|android|tvos|web> Boot a simulator/emulator, or start the web driver (Playwright)
     --os-version <n>                  iOS/tvOS version (e.g. 18) or Android API level (e.g. 33)
     --avd <name>                      Android AVD name (default: first available)
-    --name <name>                     Set a custom name on the simulator after boot (iOS/tvOS only)
+    --name <name>                     Set a custom name on the device after creation (iOS/tvOS/web)
     --device-type <name>              iOS/tvOS device type (e.g. "iPhone 16 Pro", "Apple TV 4K"); creates if needed
     --browser <chromium|firefox|webkit> Web only: which Playwright browser to launch (default: chromium)`;
+const fs_1 = __importDefault(require("fs"));
 const child_process_1 = require("child_process");
 const runner_js_1 = require("../runner.js");
 const client_js_1 = require("../daemon/client.js");
+const protocol_js_1 = require("../daemon/protocol.js");
+const bootstrap_js_1 = require("../drivers/bootstrap.js");
 const output_js_1 = require("../output.js");
 const utils_js_1 = require("../utils.js");
 const IOS_BOOT_TIMEOUT_MS = 120000;
@@ -462,34 +468,50 @@ async function startAndroid(avdName, opts) {
     (0, output_js_1.printSuccess)(`Emulator ready: ${target} (${deviceId})`, opts);
     return 0;
 }
-function webSessionIdForBrowser(browserArg) {
+function resolveWebBrowser(browserArg) {
     const b = (browserArg ?? 'chromium').toLowerCase();
     switch (b) {
         case 'chromium':
-            return { session: 'web' };
         case 'firefox':
-            return { session: 'web:firefox' };
         case 'webkit':
-            return { session: 'web:webkit' };
+            return { browser: b };
         default:
             return {
                 error: `Unknown web browser "${browserArg}". Use chromium, firefox, or webkit.`,
             };
     }
 }
-async function startWebDriver(opts, browser) {
-    const resolved = webSessionIdForBrowser(browser);
+async function startWebDriver(opts, browser, name) {
+    const resolved = resolveWebBrowser(browser);
     if ('error' in resolved) {
         (0, output_js_1.printError)(resolved.error, opts);
         return 1;
     }
-    const ready = await (0, client_js_1.startDaemon)(resolved.session);
+    // Check for an existing running session of this browser type
+    const existing = await (0, client_js_1.findRunningWebSession)(resolved.browser);
+    if (existing && !name) {
+        (0, output_js_1.printSuccess)(`Web driver already running: ${existing}`, opts);
+        return 0;
+    }
+    // Generate a unique session ID for this instance
+    const session = (0, bootstrap_js_1.generateWebSessionId)(resolved.browser);
+    const ready = await (0, client_js_1.startDaemon)(session);
     if (!ready) {
-        (0, output_js_1.printError)(`Web driver did not become ready for session ${resolved.session}. ` +
+        (0, output_js_1.printError)(`Web driver did not become ready for session ${session}. ` +
             'Install a browser with `conductor install-web` if needed, then retry.', opts);
         return 1;
     }
-    (0, output_js_1.printSuccess)(`Web driver ready (${resolved.session})`, opts);
+    if (name) {
+        try {
+            fs_1.default.writeFileSync((0, protocol_js_1.nameFile)(session), name, 'utf-8');
+        }
+        catch {
+            /* best-effort — display name won't persist but the session works */
+        }
+    }
+    const label = resolved.browser.charAt(0).toUpperCase() + resolved.browser.slice(1);
+    const displayName = name ? `${name} (${label})` : label;
+    (0, output_js_1.printSuccess)(`Web driver ready: ${displayName} (${session})`, opts);
     return 0;
 }
 // ── Entry point ───────────────────────────────────────────────────────────────
@@ -506,7 +528,7 @@ async function startDevice(platform, opts, flags) {
         case 'android':
             return startAndroid(flags.avd, opts);
         case 'web':
-            return startWebDriver(opts, flags.browser);
+            return startWebDriver(opts, flags.browser, flags.name);
         default:
             (0, output_js_1.printError)(`Unknown platform "${platform}". Use ios, android, tvos, or web.`, opts);
             return 1;

package/dist/commands/stop-device.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HELP = void 0;
+exports.stopDevice = stopDevice;
+exports.HELP = `  stop-device [<name-or-id>]
+    --platform <ios|tvos|android|web> Scope to a single platform
+    --all                             Stop all booted simulators / running emulators / web sessions`;
+const runner_js_1 = require("../runner.js");
+const output_js_1 = require("../output.js");
+const client_js_1 = require("../daemon/client.js");
+const list_devices_js_1 = require("./list-devices.js");
+// ── iOS / tvOS ───────────────────────────────────────────────────────────────
+async function shutdownSimulator(udid) {
+    const result = await (0, runner_js_1.spawnCommand)('xcrun', ['simctl', 'shutdown', udid]);
+    if (!result.success && !result.stderr.includes('current state: Shutdown')) {
+        throw new Error(`Failed to shutdown simulator: ${result.stderr.trim()}`);
+    }
+}
+// ── Android ──────────────────────────────────────────────────────────────────
+async function killEmulator(serial) {
+    const result = await (0, runner_js_1.spawnCommand)('adb', ['-s', serial, 'emu', 'kill']);
+    if (!result.success) {
+        throw new Error(`Failed to kill emulator ${serial}: ${result.stderr.trim()}`);
+    }
+}
+// ── Entry point ──────────────────────────────────────────────────────────────
+async function stopDevice(nameOrId, opts, flags) {
+    if (!nameOrId && !flags.all) {
+        (0, output_js_1.printError)('stop-device requires a device name/ID, or --all', opts);
+        return 1;
+    }
+    const platform = flags.platform?.toLowerCase();
+    const includeIOS = !platform || platform === 'ios';
+    const includeTvOS = !platform || platform === 'tvos';
+    const includeAndroid = !platform || platform === 'android';
+    const includeWeb = !platform || platform === 'web';
+    const stopped = [];
+    // ── --all mode ───────────────────────────────────────────────────────────
+    if (flags.all) {
+        const devices = await (0, list_devices_js_1.discoverBootedDevices)();
+        for (const d of devices) {
+            if (d.platform === 'ios' && !includeIOS)
+                continue;
+            if (d.platform === 'tvos' && !includeTvOS)
+                continue;
+            if (d.platform === 'android' && !includeAndroid)
+                continue;
+            if (d.platform === 'web' && !includeWeb)
+                continue;
+            try {
+                if (d.platform === 'ios' || d.platform === 'tvos') {
+                    await shutdownSimulator(d.id);
+                }
+                else if (d.platform === 'android') {
+                    await killEmulator(d.id);
+                }
+                else if (d.platform === 'web') {
+                    await (0, client_js_1.stopDaemon)(d.id);
+                }
+                stopped.push({ id: d.id, name: d.name, platform: d.platform });
+            }
+            catch (e) {
+                (0, output_js_1.printError)(`Failed to stop ${d.name} (${d.id}): ${e instanceof Error ? e.message : String(e)}`, opts);
+            }
+        }
+        if (stopped.length === 0) {
+            (0, output_js_1.printError)('No running devices to stop.', opts);
+            return 1;
+        }
+        if (opts.json) {
+            (0, output_js_1.printData)({ status: 'ok', stopped }, opts);
+        }
+        else {
+            for (const d of stopped) {
+                (0, output_js_1.printSuccess)(`Stopped ${d.platform} device: ${d.name} (${d.id})`, opts);
+            }
+        }
+        return 0;
+    }
+    // ── Single device mode ─────────────────────────────────────────────────
+    const devices = await (0, list_devices_js_1.discoverBootedDevices)();
+    const match = devices.find((d) => {
+        if (platform && d.platform !== platform)
+            return false;
+        return d.id === nameOrId || d.name === nameOrId;
+    });
+    if (!match) {
+        (0, output_js_1.printError)(`No running device found matching "${nameOrId}".`, opts);
+        return 1;
+    }
+    try {
+        if (match.platform === 'ios' || match.platform === 'tvos') {
+            await shutdownSimulator(match.id);
+        }
+        else if (match.platform === 'android') {
+            await killEmulator(match.id);
+        }
+        else if (match.platform === 'web') {
+            await (0, client_js_1.stopDaemon)(match.id);
+        }
+    }
+    catch (e) {
+        (0, output_js_1.printError)(e instanceof Error ? e.message : String(e), opts);
+        return 1;
+    }
+    if (opts.json) {
+        (0, output_js_1.printData)({ status: 'ok', stopped: [{ id: match.id, name: match.name, platform: match.platform }] }, opts);
+    }
+    else {
+        (0, output_js_1.printSuccess)(`Stopped ${match.platform} device: ${match.name} (${match.id})`, opts);
+    }
+    return 0;
+}

package/dist/daemon/client.js

@@ -141,7 +141,12 @@ async function stopDaemon(sessionName = 'default') {
     }
     // Clean up the daemon directory regardless — removes stale dirs from crashed daemons
     const dir = path_1.default.join(os_1.default.homedir(), '.conductor', 'daemons', sessionName);
-    for (const file of [(0, protocol_js_1.socketPath)(sessionName), (0, protocol_js_1.pidFile)(sessionName), (0, protocol_js_1.logFile)(sessionName)]) {
+    for (const file of [
+        (0, protocol_js_1.socketPath)(sessionName),
+        (0, protocol_js_1.pidFile)(sessionName),
+        (0, protocol_js_1.logFile)(sessionName),
+        (0, protocol_js_1.nameFile)(sessionName),
+    ]) {
         try {
             fs_1.default.unlinkSync(file);
         }

package/dist/daemon/protocol.js

@@ -7,6 +7,7 @@ exports.IDLE_TIMEOUT_MS = void 0;
 exports.socketPath = socketPath;
 exports.pidFile = pidFile;
 exports.logFile = logFile;
+exports.nameFile = nameFile;
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const DIR = path_1.default.join(os_1.default.homedir(), '.conductor');
@@ -22,4 +23,7 @@ function pidFile(sessionName = 'default') {
 function logFile(sessionName = 'default') {
     return path_1.default.join(daemonDir(sessionName), 'daemon.log');
 }
+function nameFile(sessionName = 'default') {
+    return path_1.default.join(daemonDir(sessionName), 'name');
+}
 exports.IDLE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes

package/dist/daemon/server.js

@@ -41,6 +41,26 @@ const cdpUrl = process.env.CONDUCTOR_CDP_URL || undefined;
  * URL heuristics.
  */
 const cdpTargetId = process.env.CONDUCTOR_CDP_TARGET_ID || undefined;
+/**
+ * PID of the process that should be considered the daemon's "owner". When set,
+ * the daemon polls for this process's existence and shuts down cleanly when it
+ * disappears. This prevents orphaned daemons (and their Playwright browsers)
+ * from piling up after the host app crashes or quits without calling
+ * `daemon-stop`.
+ *
+ * The daemon runs detached, so `process.ppid` becomes 1 after the parent exits
+ * and is useless for this purpose. The owner must be passed explicitly by the
+ * host app via the env when it invokes `conductor daemon-start` (or whatever
+ * code path ultimately triggers the daemon spawn).
+ */
+const parentPid = (() => {
+    const raw = process.env.CONDUCTOR_PARENT_PID;
+    if (!raw)
+        return undefined;
+    const n = parseInt(raw, 10);
+    return Number.isFinite(n) && n > 0 ? n : undefined;
+})();
+const PARENT_POLL_INTERVAL_MS = 10000;
 const SOCKET_PATH = (0, protocol_js_1.socketPath)(sessionName);
 const PID_FILE = (0, protocol_js_1.pidFile)(sessionName);
 const LOG_FILE = (0, protocol_js_1.logFile)(sessionName);
@@ -60,6 +80,7 @@ let logCollector = null;
 const DRIVER_HEALTH_INTERVAL_MS = 10000; // Check driver health every 10s
 let _restartInProgress = false;
 let _driverStarted = false;
+let _driverStartError = null;
 async function ensureDriverRunning() {
     if (_restartInProgress || !_driverStarted)
         return;
@@ -122,6 +143,7 @@ async function main() {
     }
     let idleTimer;
     let healthTimer;
+    let parentWatchTimer;
     const idleTimeoutMs = Number(process.env.CONDUCTOR_IDLE_TIMEOUT_MS) || protocol_js_1.IDLE_TIMEOUT_MS;
     function resetIdleTimer() {
         if (idleTimer)
@@ -134,6 +156,10 @@ async function main() {
     async function cleanup() {
         if (healthTimer)
             clearInterval(healthTimer);
+        if (parentWatchTimer)
+            clearInterval(parentWatchTimer);
+        if (idleTimer)
+            clearTimeout(idleTimer);
         if (logCollector) {
             logCollector.stop();
             logCollector = null;
@@ -214,6 +240,30 @@ async function main() {
         }, DRIVER_HEALTH_INTERVAL_MS);
         healthTimer.unref(); // Don't keep the process alive just for health checks
     }
+    // If the host app told us who it is, shut down when it disappears. This is
+    // the primary defence against orphaned daemons + headless Chromiums when the
+    // host app crashes or force-quits without calling daemon-stop.
+    if (parentPid !== undefined) {
+        dlog(`Watching parent pid ${parentPid}`);
+        let shuttingDown = false;
+        parentWatchTimer = setInterval(() => {
+            if (shuttingDown)
+                return;
+            try {
+                process.kill(parentPid, 0);
+            }
+            catch (err) {
+                const code = err.code;
+                if (code === 'ESRCH') {
+                    shuttingDown = true;
+                    dlog(`Parent pid ${parentPid} exited — shutting down`);
+                    cleanup().then(() => process.exit(0));
+                }
+                // EPERM means the process exists but we can't signal it — still alive.
+            }
+        }, PARENT_POLL_INTERVAL_MS);
+        parentWatchTimer.unref();
+    }
     // ── 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).
@@ -235,6 +285,9 @@ async function main() {
                 driverPort,
                 cdpUrl: cdpUrl ?? null,
                 cdpTargetId: cdpTargetId ?? null,
+                chromiumCdpPort: driverPlatform === 'web' ? (0, web_server_js_1.getCdpPort)() : null,
+                pageTargetId: driverPlatform === 'web' ? (0, web_server_js_1.getPageTargetId)() : null,
+                driverStartError: _driverStartError,
             });
             return;
         }
@@ -325,7 +378,8 @@ async function main() {
                         dlog(`Driver started successfully`);
                     }
                     catch (err) {
-                        dlog(`Driver startup error: ${err instanceof Error ? err.message : String(err)}`);
+                        _driverStartError = err instanceof Error ? err.message : String(err);
+                        dlog(`Driver startup error: ${_driverStartError}`);
                     }
                 }
                 // Start collecting logs once the driver is (or was already) running.

package/dist/daemon/web-server.js

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseAriaSnapshot = parseAriaSnapshot;
 exports.startWebServer = startWebServer;
 exports.stopWebServer = stopWebServer;
+exports.getCdpPort = getCdpPort;
+exports.getPageTargetId = getPageTargetId;
 /**
  * Daemon-embedded HTTP server wrapping Playwright for web browser control.
  *
@@ -17,6 +19,7 @@ exports.stopWebServer = stopWebServer;
  * happen here so the CLI remains a thin HTTP client.
  */
 const http_1 = __importDefault(require("http"));
+const net_1 = require("net");
 const url_1 = __importDefault(require("url"));
 const playwright_core_1 = require("playwright-core");
 const MAX_CONSOLE_BUFFER = 1000;
@@ -432,6 +435,34 @@ let _server = null;
  * — we only disconnect.
  */
 let _cdpMode = false;
+let _cdpPort = 0;
+let _pageTargetId = null;
+/** Find a free TCP port by briefly binding to port 0. */
+function findFreePort() {
+    return new Promise((resolve, reject) => {
+        const srv = (0, net_1.createServer)();
+        srv.listen(0, '127.0.0.1', () => {
+            const addr = srv.address();
+            const port = typeof addr === 'object' ? (addr?.port ?? 0) : 0;
+            srv.close(() => resolve(port));
+        });
+        srv.on('error', reject);
+    });
+}
+/** Resolve the CDP target ID of the current page via a temporary CDP session. */
+async function resolvePageTargetId() {
+    if (!_context || !_page)
+        return null;
+    try {
+        const cdpSession = await _context.newCDPSession(_page);
+        const info = (await cdpSession.send('Target.getTargetInfo'));
+        await cdpSession.detach();
+        return info.targetInfo?.targetId ?? null;
+    }
+    catch {
+        return null;
+    }
+}
 async function startWebServer(port, browserName = 'chromium', dlog = () => { }, cdpUrl, cdpTargetId) {
     if (cdpUrl) {
         // ── CDP mode: attach to an existing browser (e.g. Electron webview) ───
@@ -514,17 +545,25 @@ async function startWebServer(port, browserName = 'chromium', dlog = () => { },
     else {
         // ── Standalone mode: launch a fresh browser ───────────────────────────
         const browserType = browserName === 'firefox' ? playwright_core_1.firefox : browserName === 'webkit' ? playwright_core_1.webkit : playwright_core_1.chromium;
-        dlog(`Launching ${browserName} browser...`);
+        if (browserName === 'chromium') {
+            _cdpPort = await findFreePort();
+            dlog(`Allocated CDP port ${_cdpPort} for remote debugging`);
+        }
+        const headless = process.env.CONDUCTOR_HEADLESS === '1' || process.env.CONDUCTOR_HEADLESS === 'true';
+        dlog(`Launching ${browserName} browser (headless=${headless})...`);
         _browser = await browserType.launch({
-            headless: false,
-            args: browserName === 'chromium' ? ['--disable-search-engine-choice-screen'] : undefined,
+            headless,
+            args: browserName === 'chromium'
+                ? [`--remote-debugging-port=${_cdpPort}`, '--disable-search-engine-choice-screen']
+                : undefined,
         });
         _context = await _browser.newContext({
             viewport: DEFAULT_VIEWPORT,
         });
         _page = await _context.newPage();
         attachConsoleListeners(_page);
-        dlog(`Browser ready, page created`);
+        _pageTargetId = await resolvePageTargetId();
+        dlog(`Browser ready, page created (targetId=${_pageTargetId ?? 'unknown'})`);
         _cdpMode = false;
     }
     _server = http_1.default.createServer(async (req, res) => {
@@ -582,6 +621,32 @@ async function stopWebServer() {
         }
     }
     _cdpMode = false;
+    _cdpPort = 0;
+    _pageTargetId = null;
+}
+/** Get the CDP remote debugging port (0 if not running or non-Chromium). */
+function getCdpPort() {
+    return _cdpPort;
+}
+/** Get the CDP target ID for the current page (null if unavailable). */
+function getPageTargetId() {
+    return _pageTargetId;
+}
+/** Query the page's navigation history via CDP to determine back/forward state. */
+async function getNavState(page) {
+    try {
+        const session = await page.context().newCDPSession(page);
+        const { currentIndex, entries } = await session.send('Page.getNavigationHistory');
+        await session.detach().catch(() => { });
+        return {
+            url: page.url(),
+            canGoBack: currentIndex > 0,
+            canGoForward: currentIndex < entries.length - 1,
+        };
+    }
+    catch {
+        return { url: page.url(), canGoBack: false, canGoForward: false };
+    }
 }
 /** Playwright / CDP errors when the tab, context, or session died but our JS refs still exist. */
 function isClosedLikeError(err) {
@@ -858,26 +923,29 @@ async function handleRequest(req, res, dlog) {
                     return;
                 }
                 await gotoWithRecovery(targetUrl, dlog);
-                jsonResponse(res, { ok: true });
+                const navState = await getNavState(await getPage(dlog));
+                jsonResponse(res, { ok: true, ...navState });
                 return;
             }
             case '/goBack': {
-                await (await getPage(dlog))
-                    .goBack({ waitUntil: 'domcontentloaded', timeout: 10000 })
-                    .catch(() => { });
-                jsonResponse(res, { ok: true });
+                const p = await getPage(dlog);
+                await p.goBack({ waitUntil: 'domcontentloaded', timeout: 10000 }).catch(() => { });
+                const navState = await getNavState(p);
+                jsonResponse(res, { ok: true, ...navState });
                 return;
             }
             case '/goForward': {
-                await (await getPage(dlog))
-                    .goForward({ waitUntil: 'domcontentloaded', timeout: 10000 })
-                    .catch(() => { });
-                jsonResponse(res, { ok: true });
+                const p = await getPage(dlog);
+                await p.goForward({ waitUntil: 'domcontentloaded', timeout: 10000 }).catch(() => { });
+                const navState = await getNavState(p);
+                jsonResponse(res, { ok: true, ...navState });
                 return;
             }
             case '/reload': {
-                await (await getPage(dlog)).reload({ waitUntil: 'domcontentloaded', timeout: 10000 });
-                jsonResponse(res, { ok: true });
+                const p = await getPage(dlog);
+                await p.reload({ waitUntil: 'domcontentloaded', timeout: 10000 });
+                const navState = await getNavState(p);
+                jsonResponse(res, { ok: true, ...navState });
                 return;
             }
             case '/clearCookies': {
@@ -920,6 +988,53 @@ async function handleRequest(req, res, dlog) {
                 jsonResponse(res, { ok: true });
                 return;
             }
+            case '/setViewport': {
+                if (_cdpMode) {
+                    jsonResponse(res, { error: 'setViewport not supported in CDP mode' }, 400);
+                    return;
+                }
+                if (!_browser) {
+                    jsonResponse(res, { error: 'No browser running' }, 400);
+                    return;
+                }
+                const vpWidth = body['width'] ?? DEFAULT_VIEWPORT.width;
+                const vpHeight = body['height'] ?? DEFAULT_VIEWPORT.height;
+                const vpUserAgent = body['userAgent'];
+                const vpIsMobile = body['isMobile'] ?? false;
+                const vpScaleFactor = body['deviceScaleFactor'] ?? (vpIsMobile ? 2 : 1);
+                const vpColorScheme = body['colorScheme'];
+                const savedUrl = _page ? _page.url() : '';
+                if (_page)
+                    await _page.close().catch(() => { });
+                if (_context)
+                    await _context.close().catch(() => { });
+                _context = await _browser.newContext({
+                    viewport: { width: vpWidth, height: vpHeight },
+                    userAgent: vpUserAgent,
+                    deviceScaleFactor: vpScaleFactor,
+                    isMobile: vpIsMobile,
+                    hasTouch: vpIsMobile,
+                    colorScheme: vpColorScheme,
+                });
+                _page = await _context.newPage();
+                attachConsoleListeners(_page);
+                _pageTargetId = await resolvePageTargetId();
+                if (savedUrl && savedUrl !== 'about:blank') {
+                    await gotoWithRecovery(savedUrl, dlog);
+                }
+                jsonResponse(res, { ok: true, cdpTargetId: _pageTargetId });
+                return;
+            }
+            case '/setColorScheme': {
+                const scheme = body['colorScheme'];
+                if (scheme !== 'dark' && scheme !== 'light') {
+                    jsonResponse(res, { error: 'colorScheme must be "dark" or "light"' }, 400);
+                    return;
+                }
+                await (await getPage(dlog)).emulateMedia({ colorScheme: scheme });
+                jsonResponse(res, { ok: true });
+                return;
+            }
             case '/shutdown': {
                 jsonResponse(res, { ok: true });
                 // Graceful shutdown after response is sent

package/dist/drivers/bootstrap.js

@@ -608,7 +608,12 @@ async function stopWebDriver(port) {
  */
 async function uninstallDriver(deviceId, platform) {
     (0, verbose_js_1.log)(`uninstallDriver: removing ${platform} driver from ${deviceId}`);
-    if (platform === 'ios') {
+    if (platform === 'web') {
+        // Web has no persistent driver to uninstall — the browser is managed by the daemon.
+        // Stopping the web server is handled by the daemon cleanup.
+        return;
+    }
+    else if (platform === 'ios') {
         await spawnAndWait('xcrun', [
             'simctl',
             'uninstall',

package/dist/index.js

@@ -42,6 +42,7 @@ const scroll_until_visible_js_1 = require("./commands/scroll-until-visible.js");
 const set_location_js_1 = require("./commands/set-location.js");
 const set_orientation_js_1 = require("./commands/set-orientation.js");
 const start_device_js_1 = require("./commands/start-device.js");
+const stop_device_js_1 = require("./commands/stop-device.js");
 const delete_device_js_1 = require("./commands/delete-device.js");
 const logs_js_1 = require("./commands/logs.js");
 const device_picker_js_1 = require("./device-picker.js");
@@ -51,6 +52,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const COMMAND_HELP = {
     'start-device': start_device_js_1.HELP,
+    'stop-device': stop_device_js_1.HELP,
     'delete-device': delete_device_js_1.HELP,
     'list-devices': list_devices_js_1.HELP,
     'foreground-app': foreground_app_js_1.HELP,
@@ -187,6 +189,7 @@ async function main() {
     const NO_DEVICE_COMMANDS = new Set([
         'list-devices',
         'start-device',
+        'stop-device',
         'delete-device',
         'cheat-sheet',
         'install-plugin',
@@ -244,6 +247,12 @@ async function main() {
         case 'list-devices':
             exitCode = await (0, list_devices_js_1.listDevices)(opts);
             break;
+        case 'stop-device':
+            exitCode = await (0, stop_device_js_1.stopDevice)(rest[0], opts, {
+                platform: argv['platform'],
+                all: argv['all'],
+            });
+            break;
         case 'delete-device':
             exitCode = await (0, delete_device_js_1.deleteDevice)(rest[0], opts, {
                 platform: argv['platform'],

package/dist/runner.js

@@ -60,6 +60,17 @@ async function detectFirstDevice() {
             /* ignore */
         }
     }
+    // Web: check for running daemon web sessions
+    for (const session of (0, client_js_1.listDaemonSessions)()) {
+        if (!(session === 'web' || session.startsWith('web:')))
+            continue;
+        const status = await (0, client_js_1.daemonStatus)(session);
+        if (status.running) {
+            (0, verbose_js_1.log)(`detectFirstDevice: found running web session "${session}"`);
+            _cachedDeviceId = session;
+            return session;
+        }
+    }
     _cachedDeviceId = null;
     return undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@houwert/conductor",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "description": "CLI tool for mobile app interactions — optimized for AI agents",
   "license": "MIT",
   "repository": {

package/skills/conductor/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: conductor
-version: 0.7.1
+version: 0.9.0
 description: "Token-efficient CLI for mobile UI testing (iOS simulator + Android emulator), designed for AI agents"
 metadata.openclaw:
   category: service

package/skills/skills.yaml

@@ -3,6 +3,6 @@ skills:
     path: conductor/SKILL.md
     description: "Token-efficient CLI for mobile UI testing, designed for AI agents"
     category: service
-    version: 0.7.1
+    version: 0.9.0
     requires:
       bins: [conductor]