@houwert/conductor 0.7.0 → 0.7.1

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], {

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);
@@ -83,7 +91,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 +112,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 +229,13 @@ 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,
+            });
             return;
         }
         if (req.method === 'GET' && parsed.pathname === '/logs') {
@@ -301,7 +316,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);

package/dist/daemon/web-server.js

@@ -432,33 +432,81 @@ let _server = null;
  * — we only disconnect.
  */
 let _cdpMode = false;
-async function startWebServer(port, browserName = 'chromium', dlog = () => { }, cdpUrl) {
+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()}`);
@@ -709,6 +757,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;
@@ -859,10 +911,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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@houwert/conductor",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "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.7.1
 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.7.1
     requires:
       bins: [conductor]