@houwert/conductor 0.7.0 → 0.8.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

@@ -19,20 +19,36 @@ const verbose_js_1 = require("../verbose.js");
 const bootstrap_js_1 = require("../drivers/bootstrap.js");
 const STARTUP_POLL_MS = 200;
 const STARTUP_MAX_WAIT_MS = 10000;
-async function socketExists(sessionName) {
+async function fetchStatus(sessionName) {
     return new Promise((resolve) => {
         const req = http_1.default.get({ socketPath: (0, protocol_js_1.socketPath)(sessionName), path: '/status' }, (res) => {
-            res.resume();
-            resolve(res.statusCode === 200);
+            if (res.statusCode !== 200) {
+                res.resume();
+                resolve(null);
+                return;
+            }
+            const chunks = [];
+            res.on('data', (c) => chunks.push(c));
+            res.on('end', () => {
+                try {
+                    resolve(JSON.parse(Buffer.concat(chunks).toString('utf-8')));
+                }
+                catch {
+                    resolve(null);
+                }
+            });
         });
         req.setTimeout(500);
         req.on('timeout', () => {
             req.destroy();
-            resolve(false);
+            resolve(null);
         });
-        req.on('error', () => resolve(false));
+        req.on('error', () => resolve(null));
     });
 }
+async function socketExists(sessionName) {
+    return (await fetchStatus(sessionName)) !== null;
+}
 async function waitForDaemon(sessionName) {
     const deadline = Date.now() + STARTUP_MAX_WAIT_MS;
     while (Date.now() < deadline) {
@@ -42,9 +58,61 @@ async function waitForDaemon(sessionName) {
     }
     return false;
 }
+/**
+ * Wait until a process with the given PID is no longer running.
+ * Uses `process.kill(pid, 0)` which throws if the process is gone.
+ */
+async function waitForProcessExit(pid, timeoutMs = 5000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            process.kill(pid, 0);
+        }
+        catch {
+            return;
+        }
+        await new Promise((r) => setTimeout(r, 50));
+    }
+}
+/**
+ * True when the running daemon's CDP attachment matches the current process's
+ * `CONDUCTOR_CDP_URL` / `CONDUCTOR_CDP_TARGET_ID` env. A mismatch means the
+ * daemon would control the wrong browser (e.g. a standalone Playwright
+ * instance when the caller expects to drive an embedded webview), so the
+ * daemon must be restarted with the correct env.
+ */
+function daemonMatchesCdpEnv(status) {
+    const expectedCdpUrl = process.env.CONDUCTOR_CDP_URL ?? '';
+    const expectedCdpTargetId = process.env.CONDUCTOR_CDP_TARGET_ID ?? '';
+    const actualCdpUrl = status.cdpUrl ?? '';
+    const actualCdpTargetId = status.cdpTargetId ?? '';
+    return actualCdpUrl === expectedCdpUrl && actualCdpTargetId === expectedCdpTargetId;
+}
 async function startDaemon(sessionName = 'default') {
-    if (await socketExists(sessionName))
-        return true;
+    const existing = await fetchStatus(sessionName);
+    if (existing) {
+        if (daemonMatchesCdpEnv(existing))
+            return true;
+        (0, verbose_js_1.log)(`daemon [${sessionName}] CDP env mismatch ` +
+            `(daemon cdpUrl="${existing.cdpUrl ?? ''}" targetId="${existing.cdpTargetId ?? ''}", ` +
+            `env cdpUrl="${process.env.CONDUCTOR_CDP_URL ?? ''}" targetId="${process.env.CONDUCTOR_CDP_TARGET_ID ?? ''}") — restarting`);
+        // Capture the PID before stopDaemon removes the pidfile so we can wait
+        // for the old process to actually exit before respawning. Otherwise the
+        // old daemon's cleanup handler may unlink the new daemon's socket.
+        let oldPid;
+        try {
+            const raw = fs_1.default.readFileSync((0, protocol_js_1.pidFile)(sessionName), 'utf-8').trim();
+            const n = parseInt(raw, 10);
+            if (!isNaN(n))
+                oldPid = n;
+        }
+        catch {
+            /* no pid — continue */
+        }
+        await stopDaemon(sessionName);
+        if (oldPid !== undefined)
+            await waitForProcessExit(oldPid);
+    }
     const serverScript = path_1.default.join(__dirname, 'server.js');
     (0, verbose_js_1.log)(`daemon [${sessionName}] not running — spawning ${serverScript}`);
     const child = (0, child_process_1.spawn)(process.execPath, [serverScript, sessionName], {
@@ -73,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

@@ -33,6 +33,14 @@ const sessionName = process.argv[2] ?? 'default';
  * Set by the host IDE (Stagehand) via the agent subprocess environment.
  */
 const cdpUrl = process.env.CONDUCTOR_CDP_URL || undefined;
+/**
+ * Optional CDP target ID to pick a specific page when the host app exposes
+ * multiple webviews over one CDP endpoint (e.g. one per workspace in
+ * Stagehand). When set, the web driver finds the page whose underlying
+ * `Target.targetId` matches and attaches to it, instead of falling back to
+ * URL heuristics.
+ */
+const cdpTargetId = process.env.CONDUCTOR_CDP_TARGET_ID || undefined;
 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);
@@ -52,6 +60,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;
@@ -83,7 +92,7 @@ async function ensureDriverRunning() {
                 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, cdpUrl);
+                await (0, web_server_js_1.startWebServer)(driverPort, (0, bootstrap_js_1.webBrowserName)(sessionName), dlog, cdpUrl, cdpTargetId);
             }
             else {
                 await (0, bootstrap_js_1.startAndroidDriver)(sessionName, driverPort);
@@ -104,6 +113,7 @@ async function main() {
     fs_1.default.mkdirSync(path_1.default.dirname(PID_FILE), { recursive: true });
     fs_1.default.writeFileSync(PID_FILE, String(process.pid));
     dlog(`daemon started pid=${process.pid} session=${sessionName}`);
+    dlog(`env CONDUCTOR_CDP_URL=${cdpUrl ?? '<unset>'} CONDUCTOR_CDP_TARGET_ID=${cdpTargetId ?? '<unset>'}`); // kept intentionally — useful for future diagnosis of CDP attachment issues
     // Remove stale socket
     try {
         fs_1.default.unlinkSync(SOCKET_PATH);
@@ -220,7 +230,16 @@ async function main() {
         resetIdleTimer();
         const parsed = url_1.default.parse(req.url ?? '/', true);
         if (req.method === 'GET' && parsed.pathname === '/status') {
-            jsonResponse(res, { ok: true, platform: driverPlatform, driverPort });
+            jsonResponse(res, {
+                ok: true,
+                platform: driverPlatform,
+                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;
         }
         if (req.method === 'GET' && parsed.pathname === '/logs') {
@@ -301,7 +320,7 @@ async function main() {
                             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, cdpUrl);
+                            await (0, web_server_js_1.startWebServer)(driverPort, (0, bootstrap_js_1.webBrowserName)(sessionName), dlog, cdpUrl, cdpTargetId);
                         }
                         else {
                             await (0, bootstrap_js_1.startAndroidDriver)(sessionName, driverPort);
@@ -310,7 +329,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,33 +435,109 @@ let _server = null;
  * — we only disconnect.
  */
 let _cdpMode = false;
-async function startWebServer(port, browserName = 'chromium', dlog = () => { }, cdpUrl) {
+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) ───
         dlog(`Connecting to existing browser via CDP: ${cdpUrl}`);
         _browser = await playwright_core_1.chromium.connectOverCDP(cdpUrl);
         _cdpMode = true;
-        // Use the first existing context and page. The host app (e.g. Stagehand)
-        // already created them — we just take a handle.
+        // Use an existing context and page. The host app (e.g. Stagehand) already
+        // created them — we just take a handle.
         const contexts = _browser.contexts();
         if (contexts.length === 0) {
             throw new Error('No browser contexts found via CDP — is the webview loaded?');
         }
-        // Find the context with a real page (not about:blank, not the host app).
-        for (const ctx of contexts) {
-            const pages = ctx.pages();
-            const candidate = pages.find((p) => p.url() !== 'about:blank' && !p.url().startsWith('file://'));
-            if (candidate) {
-                _context = ctx;
-                _page = candidate;
-                break;
+        // Match the specific CDP target ID provided by the host app. Required —
+        // with multiple pages sharing one CDP port (Electron host window, webviews,
+        // DevTools), "guess the right one" is a foot-gun that ends in navigating
+        // the wrong window. If no targetId is supplied, or the supplied one can't
+        // be resolved to a Playwright Page, we throw rather than attaching to an
+        // arbitrary target.
+        if (!cdpTargetId) {
+            throw new Error('CDP mode requires CONDUCTOR_CDP_TARGET_ID — set it to the specific page target to control.');
+        }
+        dlog(`Selecting CDP target by ID: ${cdpTargetId}`);
+        const pageDiag = [];
+        outer: for (const ctx of contexts) {
+            for (const page of ctx.pages()) {
+                try {
+                    const session = await ctx.newCDPSession(page);
+                    const info = (await session.send('Target.getTargetInfo'));
+                    await session.detach().catch(() => { });
+                    const t = info.targetInfo;
+                    pageDiag.push(`page targetId=${t?.targetId ?? '?'} type=${t?.type ?? '?'} url=${t?.url ?? page.url()}`);
+                    if (t?.targetId === cdpTargetId) {
+                        _context = ctx;
+                        _page = page;
+                        break outer;
+                    }
+                }
+                catch (err) {
+                    pageDiag.push(`page url=${page.url()} getTargetInfo failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
             }
         }
-        // Fallback: just use the first context's first page.
         if (!_page) {
-            _context = contexts[0];
-            const pages = _context.pages();
-            _page = pages[0] ?? (await _context.newPage());
+            // Enumerate all CDP targets to produce an actionable error — in
+            // particular so we can distinguish "wrong targetId" from "target exists
+            // but Playwright can't see it as a Page" (the latter happens when the
+            // host embeds content as a <webview> guest — type="webview" in CDP —
+            // rather than as a top-level page).
+            let diagExtra = '';
+            let expectedType;
+            try {
+                const browserSession = await _browser.newBrowserCDPSession();
+                const all = (await browserSession.send('Target.getTargets'));
+                await browserSession.detach().catch(() => { });
+                const enumerated = all.targetInfos
+                    ?.map((t) => `  - ${t.type.padEnd(10)} ${t.targetId.slice(0, 8)} ${t.url}`)
+                    .join('\n') ?? '(none)';
+                const expected = all.targetInfos?.find((t) => t.targetId === cdpTargetId);
+                expectedType = expected?.type;
+                diagExtra =
+                    `\nPages visible to Playwright (${pageDiag.length}):\n` +
+                        pageDiag.map((l) => `  - ${l}`).join('\n') +
+                        `\nAll CDP targets (${all.targetInfos?.length ?? 0}):\n${enumerated}\n` +
+                        (expected
+                            ? `Requested target exists but type="${expected.type}" — Playwright only surfaces type="page".`
+                            : `Requested target not present in Target.getTargets — stale or wrong ID.`);
+            }
+            catch (err) {
+                diagExtra = `\nTarget enumeration failed: ${err instanceof Error ? err.message : String(err)}`;
+            }
+            dlog(`CDP target id ${cdpTargetId} not matched by any Playwright Page.${diagExtra}`);
+            throw new Error(`CDP target ${cdpTargetId} not reachable as a Playwright Page` +
+                (expectedType
+                    ? ` (exists as type="${expectedType}" — Playwright only surfaces type="page")`
+                    : ` (not in target list)`));
         }
         attachConsoleListeners(_page);
         dlog(`CDP connected — page: ${_page.url()}`);
@@ -466,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) => {
@@ -534,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) {
@@ -709,6 +822,10 @@ async function handleRequest(req, res, dlog) {
                 jsonResponse(res, { url: (await getPage(dlog)).url() });
                 return;
             }
+            case '/runningApp': {
+                jsonResponse(res, { runningAppBundleId: (await getPage(dlog)).url() });
+                return;
+            }
             case '/title': {
                 jsonResponse(res, { title: await (await getPage(dlog)).title() });
                 return;
@@ -806,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': {
@@ -859,10 +979,6 @@ async function handleRequest(req, res, dlog) {
                 jsonResponse(res, { ok: true });
                 return;
             }
-            case '/runningApp': {
-                jsonResponse(res, { runningAppBundleId: (await getPage(dlog)).url() });
-                return;
-            }
             case '/eraseText': {
                 const count = body['count'] ?? 50;
                 const p = await getPage(dlog);
@@ -872,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.0",
+  "version": "0.8.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.0
+version: 0.8.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.0
+    version: 0.8.0
     requires:
       bins: [conductor]