@houwert/conductor 0.23.0 → 0.24.0

package/dist/commands/list-devices.js

@@ -16,6 +16,7 @@ const bootstrap_js_1 = require("../drivers/bootstrap.js");
 const client_js_1 = require("../daemon/client.js");
 const protocol_js_1 = require("../daemon/protocol.js");
 const cli_js_1 = require("../drivers/vega/cli.js");
+const cdp_discovery_js_1 = require("../drivers/cdp-discovery.js");
 // Captured during discoverAvailableDevices so listDevices() can report it.
 // Module-scoped because the discover function returns Device[]; bolting an
 // extra return field onto the public type would ripple beyond this fix.
@@ -104,6 +105,9 @@ async function discoverBootedDevices() {
     catch {
         /* vega CLI not installed */
     }
+    // External CDP endpoints (e.g. an Electron app started with
+    // --remote-debugging-port): one device per discovered webview/tile.
+    devices.push(...(await (0, cdp_discovery_js_1.discoverCdpDevices)()));
     return devices;
 }
 async function discoverAvailableDevices() {

package/dist/commands/web-targets.js

@@ -1,7 +1,4 @@
 "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.webTargets = webTargets;
@@ -14,37 +11,8 @@ exports.webTargets = webTargets;
  * Playwright browser and works before any daemon session exists. Use the printed
  * target IDs with `--cdp-url` / `--cdp-target` to bind a session to a tile.
  */
-const http_1 = __importDefault(require("http"));
 const output_js_1 = require("../output.js");
-/** Derive the `http://host:port` base from a CDP URL (which may be ws:// or include a path). */
-function httpBase(cdpUrl) {
-    const u = new URL(cdpUrl);
-    const proto = u.protocol === 'https:' || u.protocol === 'wss:' ? 'https:' : 'http:';
-    return `${proto}//${u.host}`;
-}
-function fetchTargets(cdpUrl) {
-    const url = `${httpBase(cdpUrl)}/json/list`;
-    return new Promise((resolve, reject) => {
-        const req = http_1.default.get(url, (res) => {
-            const chunks = [];
-            res.on('data', (c) => chunks.push(c));
-            res.on('end', () => {
-                if ((res.statusCode ?? 0) >= 300) {
-                    reject(new Error(`HTTP ${res.statusCode} from ${url}`));
-                    return;
-                }
-                try {
-                    resolve(JSON.parse(Buffer.concat(chunks).toString('utf-8')));
-                }
-                catch (err) {
-                    reject(err);
-                }
-            });
-        });
-        req.setTimeout(5000, () => req.destroy(new Error(`Timed out fetching ${url}`)));
-        req.on('error', reject);
-    });
-}
+const cdp_discovery_js_1 = require("../drivers/cdp-discovery.js");
 async function webTargets(cdpUrl, opts) {
     if (!cdpUrl) {
         console.error('web-targets requires --cdp-url <url> (e.g. --cdp-url http://127.0.0.1:9222).\n' +
@@ -53,7 +21,7 @@ async function webTargets(cdpUrl, opts) {
     }
     let targets;
     try {
-        targets = await fetchTargets(cdpUrl);
+        targets = await (0, cdp_discovery_js_1.fetchCdpTargets)(cdpUrl);
     }
     catch (err) {
         console.error(`Could not reach CDP endpoint at ${cdpUrl}: ${err instanceof Error ? err.message : String(err)}`);

package/dist/drivers/cdp-discovery.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CDP_PORTS = void 0;
+exports.httpBase = httpBase;
+exports.fetchCdpTargets = fetchCdpTargets;
+exports.formatCdpDeviceId = formatCdpDeviceId;
+exports.parseCdpDeviceId = parseCdpDeviceId;
+exports.cdpTargetsToDevices = cdpTargetsToDevices;
+exports.discoverCdpDevices = discoverCdpDevices;
+/**
+ * Discovery of externally-launched CDP endpoints (e.g. an Electron app started
+ * with `--remote-debugging-port`, which exposes one page target per webview/tile).
+ *
+ * Unlike the Playwright web driver (which conductor launches itself) these
+ * browsers already exist — so "discovery" means finding the DevTools HTTP
+ * endpoint. CDP servers don't advertise themselves, so we probe a small range of
+ * localhost ports and enumerate each reachable endpoint's page targets via
+ * `/json/list`. The same target-fetch is reused by the `web-targets` command.
+ */
+const http_1 = __importDefault(require("http"));
+/** Default localhost ports scanned for CDP endpoints. Covers Chromium/Electron's
+ *  conventional `--remote-debugging-port` values without a wide scan. */
+exports.DEFAULT_CDP_PORTS = [9222, 9223, 9224, 9225, 9226, 9227, 9228, 9229];
+const PROBE_TIMEOUT_MS = 300;
+/** Derive the `http://host:port` base from a CDP URL (which may be ws:// or include a path). */
+function httpBase(cdpUrl) {
+    const u = new URL(cdpUrl);
+    const proto = u.protocol === 'https:' || u.protocol === 'wss:' ? 'https:' : 'http:';
+    return `${proto}//${u.host}`;
+}
+/** GET a CDP DevTools JSON endpoint, parsing the array response. */
+function getJson(url, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const req = http_1.default.get(url, (res) => {
+            const chunks = [];
+            res.on('data', (c) => chunks.push(c));
+            res.on('end', () => {
+                if ((res.statusCode ?? 0) >= 300) {
+                    reject(new Error(`HTTP ${res.statusCode} from ${url}`));
+                    return;
+                }
+                try {
+                    resolve(JSON.parse(Buffer.concat(chunks).toString('utf-8')));
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        });
+        req.setTimeout(timeoutMs, () => req.destroy(new Error(`Timed out fetching ${url}`)));
+        req.on('error', reject);
+    });
+}
+/** Fetch the CDP page targets exposed at `cdpUrl`'s `/json/list`. */
+function fetchCdpTargets(cdpUrl, timeoutMs = 5000) {
+    return getJson(`${httpBase(cdpUrl)}/json/list`, timeoutMs);
+}
+/**
+ * Device-id encoding for a discovered CDP webview: `web:cdp:<port>:<targetId>`.
+ * Self-describing so the id alone hydrates the CDP url + target at bind time —
+ * a discovered webview is drivable with no `--cdp-*` flags. Localhost is assumed
+ * (discovery only scans localhost).
+ */
+function formatCdpDeviceId(port, targetId) {
+    return `web:cdp:${port}:${targetId}`;
+}
+/** Parse a `web:cdp:<port>:<targetId>` device id, or undefined if it isn't one. */
+function parseCdpDeviceId(deviceId) {
+    const m = /^web:cdp:(\d+):(.+)$/.exec(deviceId);
+    if (!m)
+        return undefined;
+    const port = Number(m[1]);
+    if (!Number.isInteger(port) || port <= 0)
+        return undefined;
+    return { port, targetId: m[2], cdpUrl: `http://127.0.0.1:${port}` };
+}
+/** Map a reachable endpoint's page targets to discovered `web` devices. */
+function cdpTargetsToDevices(port, targets) {
+    return targets
+        .filter((t) => t.type === 'page')
+        .map((t) => ({
+        id: formatCdpDeviceId(port, t.id),
+        name: t.title || t.url || t.id,
+        platform: 'web',
+        status: 'running',
+    }));
+}
+/**
+ * Scan localhost CDP ports and return every discovered webview as a device.
+ * Probes run in parallel with a short timeout and swallow all errors — an
+ * unreachable port simply contributes nothing. Safe to call on the hot device-
+ * resolution path.
+ */
+async function discoverCdpDevices(ports = exports.DEFAULT_CDP_PORTS) {
+    const results = await Promise.all(ports.map(async (port) => {
+        try {
+            const targets = await fetchCdpTargets(`http://127.0.0.1:${port}`, PROBE_TIMEOUT_MS);
+            return cdpTargetsToDevices(port, targets);
+        }
+        catch {
+            return [];
+        }
+    }));
+    return results.flat();
+}

package/dist/index.js

@@ -64,6 +64,7 @@ const options_js_1 = require("./commands/options.js");
 const web_targets_js_1 = require("./commands/web-targets.js");
 const session_js_2 = require("./session.js");
 const device_picker_js_1 = require("./device-picker.js");
+const cdp_discovery_js_1 = require("./drivers/cdp-discovery.js");
 const update_check_js_1 = require("./update-check.js");
 const pkg_root_js_1 = require("./pkg-root.js");
 const fs_1 = __importDefault(require("fs"));
@@ -326,6 +327,9 @@ async function main() {
     if (isWebSession && !NO_DEVICE_COMMANDS.has(command)) {
         const cdpUrlFlag = argv['cdp-url'];
         const cdpTargetFlag = argv['cdp-target'];
+        // A discovered `web:cdp:<port>:<target>` device id is self-describing —
+        // derive the CDP url/target from it so it's drivable with no --cdp-* flags.
+        const fromDeviceId = (0, cdp_discovery_js_1.parseCdpDeviceId)(sessionName);
         if (cdpUrlFlag || cdpTargetFlag) {
             if (cdpUrlFlag)
                 process.env.CONDUCTOR_CDP_URL = cdpUrlFlag;
@@ -336,6 +340,13 @@ async function main() {
                 cdpTargetId: process.env.CONDUCTOR_CDP_TARGET_ID,
             }, sessionName);
         }
+        else if (fromDeviceId) {
+            if (!process.env.CONDUCTOR_CDP_URL)
+                process.env.CONDUCTOR_CDP_URL = fromDeviceId.cdpUrl;
+            if (!process.env.CONDUCTOR_CDP_TARGET_ID) {
+                process.env.CONDUCTOR_CDP_TARGET_ID = fromDeviceId.targetId;
+            }
+        }
         else {
             const saved = await (0, session_js_2.getSession)(sessionName);
             if (saved.cdpUrl && !process.env.CONDUCTOR_CDP_URL) {

package/package.json

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

package/skills/conductor-device-setup/SKILL.md

@@ -47,6 +47,13 @@ Use a distinct fully-qualified `--device web:chromium:<label>` per target (a bar
 several webviews can be driven concurrently. Only `type=page` targets are
 controllable. See [Web testing → Attaching to an existing browser](../../../docs/web.md).
 
+**Discovery:** endpoints on the conventional debugging ports (9222–9229 on
+localhost) are found automatically — `list-devices` shows each webview as a
+booted `web:cdp:<port>:<targetId>` device. That id is self-describing, so you can
+drive it directly (`conductor --device web:cdp:9222:<targetId> <cmd>`) without
+`--cdp-url`/`--cdp-target`. Use `web-targets --cdp-url <url>` for endpoints on a
+non-default port, or to list targets before binding.
+
 ### Vega (Amazon Fire TV)
 
 Vega is a React Native OS driven through Amazon's own `vega`/`kepler` CLI (not