@houwert/conductor 0.12.2 → 0.13.0

package/README.md

@@ -38,34 +38,9 @@ One agent writes the feature. Another taps through the app. They talk. It works.
 npm install -g @houwert/conductor
 ```
 
-That's it. The postinstall script registers Conductor as a Claude Code plugin automatically — Claude gains full mobile UI control without any extra steps.
+That's it. Conductor is a pure CLI — no Claude Code plugin or skill is registered. Wire it into your agent however you like (a custom `CLAUDE.md`, a project skill, a slash command — it's up to you). Run `conductor --help` for the full command reference, or `conductor <command> --help` for per-command flags.
 
-## 🧠 Claude Skills
-
-The plugin registers itself globally in `~/.claude/plugins/` and ships two skill files:
-
-```
-skills/conductor/
-├── SKILL.md               # Full command reference and agent workflow guide
-└── references/
-    └── flow-syntax.md     # Maestro YAML flow syntax reference
-```
-
-Claude learns every available command, how to coordinate across devices, and how to write and run Maestro YAML flows. See [`skills/conductor/SKILL.md`](./skills/conductor/SKILL.md) for the full reference.
-
-### Install modes
-
-| Command | What it does |
-|---|---|
-| `npm install -g @houwert/conductor` | Registers or updates the global Claude Code plugin (via package postinstall) |
-| `conductor install-plugin` | Re-register or update the global Claude Code plugin (same as postinstall) |
-| `conductor install-plugin --check` | Print whether the global plugin is registered (no changes) |
-| `conductor install-skills` | Copy skills into `.claude/skills/conductor/` in the current project |
-| `conductor install-skills --check` | Print whether local skills are installed (no changes) |
-| `conductor install-web` | Install a Playwright browser for web automation (default: chromium) |
-| `conductor install-web --check` | Print which Playwright browsers are installed (no changes) |
-
-### 📱 What Claude can do
+### 📱 What the CLI can do
 
 | Capability | Commands |
 |---|---|
@@ -76,6 +51,7 @@ Claude learns every available command, how to coordinate across devices, and how
 | Navigation | `open-link`, `back` |
 | Flows | `run-flow`, `run-flow-inline`, `run-parallel` |
 | Devices | `start-device`, `list-devices`, `set-location`, `set-orientation` |
+| Web setup | `install-web [browser]` (installs a Playwright browser; `--check` prints status) |
 
 ## 🔨 Building locally
 
@@ -113,7 +89,6 @@ make build-cli          # CLI TypeScript only
 make build-ios-driver   # iOS XCTest driver
 make build-android-driver # Android instrumentation driver
 make package-cli        # Bundle drivers into CLI package
-make copy-skills        # Copy skills/ into packages/cli/skills/ (build artifact)
 ```
 
 ## 🗂️ Repository structure

package/dist/commands/install.js

@@ -1,78 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HELP_INSTALL_WEB = exports.HELP_INSTALL_SKILLS = exports.HELP_INSTALL_PLUGIN = void 0;
-exports.installPluginCli = installPluginCli;
-exports.installSkillsCli = installSkillsCli;
+exports.HELP_INSTALL_WEB = void 0;
 exports.installWebCli = installWebCli;
-exports.installLocalSkills = installLocalSkills;
-exports.installPlugin = installPlugin;
-exports.HELP_INSTALL_PLUGIN = `  install-plugin [--check]            Register/update the global Claude Code plugin (status only with --check)`;
-exports.HELP_INSTALL_SKILLS = `  install-skills [--check]            Copy skills into local .claude/skills/ (status only with --check)`;
 exports.HELP_INSTALL_WEB = `  install-web [--check] [browser]     Install Playwright browser (chromium, firefox, webkit) (status only with --check)`;
-const fs_1 = __importDefault(require("fs"));
-const os_1 = __importDefault(require("os"));
-const path_1 = __importDefault(require("path"));
 const output_js_1 = require("../output.js");
-const pkg_root_js_1 = require("../pkg-root.js");
 const bootstrap_js_1 = require("../drivers/bootstrap.js");
-async function installPluginCli(opts, check) {
-    try {
-        if (check) {
-            return checkPluginInstallStatus(opts);
-        }
-        const version = installPlugin();
-        const pluginCacheDir = path_1.default.join(os_1.default.homedir(), '.claude', 'plugins', 'cache', 'conductor', 'conductor', version);
-        (0, output_js_1.printSuccess)(`Conductor plugin installed (v${version}) → ${pluginCacheDir}`, opts);
-        return 0;
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        (0, output_js_1.printError)(`Install failed: ${message}`, opts);
-        return 1;
-    }
-}
-function checkPluginInstallStatus(opts) {
-    const installedPluginsPath = path_1.default.join(os_1.default.homedir(), '.claude', 'plugins', 'installed_plugins.json');
-    let pluginVersion = null;
-    if (fs_1.default.existsSync(installedPluginsPath)) {
-        const installed = JSON.parse(fs_1.default.readFileSync(installedPluginsPath, 'utf8'));
-        const plugins = Array.isArray(installed.plugins) ? installed.plugins : [];
-        const entry = plugins.find((p) => p.name === 'conductor');
-        if (entry)
-            pluginVersion = entry.version;
-    }
-    if (opts.json) {
-        (0, output_js_1.printData)({ globalPlugin: { installed: pluginVersion !== null, version: pluginVersion } }, opts);
-    }
-    else {
-        if (pluginVersion) {
-            console.log(`Global plugin: installed (v${pluginVersion})`);
-        }
-        else {
-            console.log('Global plugin: not installed');
-            console.log('Run `npm install -g @houwert/conductor` or `conductor install-plugin` to register it.');
-        }
-    }
-    return 0;
-}
-async function installSkillsCli(opts, check) {
-    try {
-        if (check) {
-            return checkSkillsInstallStatus(opts);
-        }
-        installLocalSkills();
-        (0, output_js_1.printSuccess)('Conductor skills installed → .claude/skills/conductor/', opts);
-        return 0;
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        (0, output_js_1.printError)(`Install failed: ${message}`, opts);
-        return 1;
-    }
-}
 async function installWebCli(opts, check, browserArg) {
     try {
         if (check) {
@@ -86,23 +18,6 @@ async function installWebCli(opts, check, browserArg) {
         return 1;
     }
 }
-function checkSkillsInstallStatus(opts) {
-    const localSkillsPath = path_1.default.join(process.cwd(), '.claude', 'skills', 'conductor', 'SKILL.md');
-    const hasLocalSkills = fs_1.default.existsSync(localSkillsPath);
-    if (opts.json) {
-        (0, output_js_1.printData)({ localSkills: { installed: hasLocalSkills } }, opts);
-    }
-    else {
-        if (hasLocalSkills) {
-            console.log('Local skills: installed → .claude/skills/conductor/');
-        }
-        else {
-            console.log('Local skills: not installed');
-            console.log('Run `conductor install-skills` to copy skills into this project.');
-        }
-    }
-    return 0;
-}
 function checkWebInstallStatus(opts) {
     const webBrowsers = {
         chromium: (0, bootstrap_js_1.isPlaywrightBrowserInstalled)('chromium'),
@@ -126,46 +41,6 @@ function checkWebInstallStatus(opts) {
     }
     return 0;
 }
-function installLocalSkills() {
-    const pkgRoot = (0, pkg_root_js_1.findPkgRoot)(__dirname);
-    const skillsSrc = path_1.default.join(pkgRoot, 'skills', 'conductor');
-    if (!fs_1.default.existsSync(skillsSrc)) {
-        throw new Error(`No skills found at ${skillsSrc}`);
-    }
-    const skillsDest = path_1.default.join(process.cwd(), '.claude', 'skills', 'conductor');
-    copyDir(skillsSrc, skillsDest);
-}
-function installPlugin() {
-    const pkgRoot = (0, pkg_root_js_1.findPkgRoot)(__dirname);
-    const pkgJsonPath = path_1.default.join(pkgRoot, 'package.json');
-    const pkg = JSON.parse(fs_1.default.readFileSync(pkgJsonPath, 'utf8'));
-    const version = pkg.version;
-    const pluginCacheDir = path_1.default.join(os_1.default.homedir(), '.claude', 'plugins', 'cache', 'conductor', 'conductor', version);
-    fs_1.default.mkdirSync(pluginCacheDir, { recursive: true });
-    const skillsSrc = path_1.default.join(pkgRoot, 'skills', 'conductor');
-    if (fs_1.default.existsSync(skillsSrc)) {
-        copyDir(skillsSrc, path_1.default.join(pluginCacheDir, 'skills', 'conductor'));
-    }
-    const pluginJsonSrc = path_1.default.join(pkgRoot, '.claude-plugin', 'plugin.json');
-    if (fs_1.default.existsSync(pluginJsonSrc)) {
-        const pluginMetaDir = path_1.default.join(pluginCacheDir, '.claude-plugin');
-        fs_1.default.mkdirSync(pluginMetaDir, { recursive: true });
-        fs_1.default.copyFileSync(pluginJsonSrc, path_1.default.join(pluginMetaDir, 'plugin.json'));
-    }
-    const installedPluginsPath = path_1.default.join(os_1.default.homedir(), '.claude', 'plugins', 'installed_plugins.json');
-    let installed = { plugins: [] };
-    if (fs_1.default.existsSync(installedPluginsPath)) {
-        installed = JSON.parse(fs_1.default.readFileSync(installedPluginsPath, 'utf8'));
-        if (!Array.isArray(installed.plugins)) {
-            installed.plugins = [];
-        }
-    }
-    installed.plugins = installed.plugins.filter((p) => p.name !== 'conductor');
-    installed.plugins.push({ name: 'conductor', version, path: pluginCacheDir });
-    fs_1.default.mkdirSync(path_1.default.dirname(installedPluginsPath), { recursive: true });
-    fs_1.default.writeFileSync(installedPluginsPath, JSON.stringify(installed, null, 2));
-    return version;
-}
 async function installWebBrowser(browserArg, opts) {
     const validBrowsers = ['chromium', 'firefox', 'webkit'];
     let browserName = 'chromium';
@@ -190,16 +65,3 @@ async function installWebBrowser(browserArg, opts) {
         return 1;
     }
 }
-function copyDir(src, dest) {
-    fs_1.default.mkdirSync(dest, { recursive: true });
-    for (const entry of fs_1.default.readdirSync(src, { withFileTypes: true })) {
-        const srcPath = path_1.default.join(src, entry.name);
-        const destPath = path_1.default.join(dest, entry.name);
-        if (entry.isDirectory()) {
-            copyDir(srcPath, destPath);
-        }
-        else {
-            fs_1.default.copyFileSync(srcPath, destPath);
-        }
-    }
-}

package/dist/commands/logs.js

@@ -3,12 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HELP = void 0;
 exports.logs = logs;
 exports.HELP = `  logs [--source <source>] [--level <level>]  Stream app logs (console, Metro, or device)
-    --source <source>               Log source: metro, device, or auto (default: auto)
+    --source <source>               Filter by source: metro, device (default: both)
     --level <level>                 Minimum level: verbose, debug, log, info, warn, error
-    --metro                         Enable Metro logs for React Native apps (auto-discovers port)
-    --metro-port <port>             Override Metro dev server port (skips auto-discovery)
-    --target <n>                    Metro debugger target index (when multiple devices share one Metro)
-    --list                          List available Metro debugger targets and exit
+    --list                          List Metro debugger targets for this device and exit
     --recent <n>                    Return the last N buffered log entries and exit (agent-friendly)
     --duration <seconds>            Stream logs for N seconds, then exit
     --json                          Output as NDJSON (one JSON object per line)`;
@@ -18,6 +15,7 @@ const android_js_1 = require("../drivers/android.js");
 const web_js_1 = require("../drivers/web.js");
 const types_js_1 = require("../drivers/log-sources/types.js");
 const metro_js_1 = require("../drivers/log-sources/metro.js");
+const metro_discovery_js_1 = require("../drivers/log-sources/metro-discovery.js");
 const daemon_js_1 = require("../drivers/log-sources/daemon.js");
 const client_js_1 = require("../daemon/client.js");
 const bootstrap_js_1 = require("../drivers/bootstrap.js");
@@ -44,71 +42,100 @@ function formatEntry(entry, opts) {
     }
     return line;
 }
-async function logs(opts = {}, sessionName = 'default', { source = 'auto', level, metro, metroPort, target, list, recent, duration } = {}) {
-    // --list: query Metro targets and print them without starting a log stream
+async function resolvePlatformAndDevice(sessionName) {
+    try {
+        const driver = await (0, runner_js_1.getDriver)(sessionName);
+        let platform = 'unknown';
+        if (driver instanceof ios_js_1.IOSDriver)
+            platform = driver.platform;
+        else if (driver instanceof android_js_1.AndroidDriver)
+            platform = 'android';
+        else if (driver instanceof web_js_1.WebDriver)
+            platform = 'web';
+        else
+            platform = await (0, bootstrap_js_1.detectPlatform)(sessionName);
+        return { platform, deviceId: sessionName };
+    }
+    catch {
+        return null;
+    }
+}
+async function logs(opts = {}, sessionName = 'default', { source, level, list, recent, duration } = {}) {
+    const sourceFilter = source === 'metro' || source === 'device' ? source : undefined;
+    // --list: resolve the device's Metro port deterministically, then print its targets.
     if (list) {
         try {
-            const targets = await (0, metro_js_1.fetchTargets)(metroPort ?? 8081, 'localhost');
-            const withWs = targets.filter((t) => t.webSocketDebuggerUrl);
-            if (withWs.length === 0) {
-                if (opts.json) {
-                    console.log(JSON.stringify({ status: 'ok', targets: [] }));
-                }
+            const ctx = await resolvePlatformAndDevice(sessionName);
+            if (!ctx) {
+                const msg = 'Could not resolve device session for --list';
+                if (opts.json)
+                    console.log(JSON.stringify({ status: 'error', message: msg }));
+                else
+                    console.error(`✗ logs --list — ${msg}`);
+                return 1;
+            }
+            const port = await (0, metro_discovery_js_1.discoverMetroPortForDevice)(ctx.platform, ctx.deviceId);
+            if (port === null) {
+                if (opts.json)
+                    console.log(JSON.stringify({ status: 'ok', port: null, targets: [] }));
                 else {
-                    console.log('No Metro debugger targets found. Is the app running?');
+                    console.log('No Metro connection detected for this device. The daemon will keep trying — ' +
+                        'launch the React Native app on this device and retry, or confirm the app is not RN.');
                 }
                 return 0;
             }
+            const allTargets = await (0, metro_js_1.fetchTargets)(port, 'localhost');
+            const displayName = await (0, metro_discovery_js_1.getDeviceDisplayName)(ctx.platform, ctx.deviceId);
+            const deviceTargets = displayName ? (0, metro_discovery_js_1.targetsForDevice)(allTargets, displayName) : [];
             if (opts.json) {
-                const items = withWs.map((t, i) => ({
-                    index: i,
-                    title: t.title ?? null,
-                    description: t.description ?? null,
-                    deviceName: t.deviceName ?? null,
-                    deviceId: t.deviceId ?? null,
-                    appId: t.appId ?? null,
-                    logicalDeviceId: t.reactNative?.logicalDeviceId ?? null,
+                console.log(JSON.stringify({
+                    status: 'ok',
+                    port,
+                    deviceName: displayName,
+                    targets: deviceTargets.map((t, i) => ({
+                        index: i,
+                        title: t.title ?? null,
+                        description: t.description ?? null,
+                        deviceName: t.deviceName ?? null,
+                        appId: t.appId ?? null,
+                        logicalDeviceId: t.reactNative?.logicalDeviceId ?? null,
+                        webSocketDebuggerUrl: t.webSocketDebuggerUrl ?? null,
+                    })),
                 }));
-                console.log(JSON.stringify({ status: 'ok', targets: items }));
             }
             else {
-                console.log('Metro debugger targets:');
-                for (let i = 0; i < withWs.length; i++) {
-                    const t = withWs[i];
-                    const label = t.title ?? t.deviceName ?? '(unnamed)';
-                    const desc = t.description ? `  — ${t.description}` : '';
-                    console.log(`  ${i}: ${label}${desc}`);
+                console.log(`Metro on port ${port} (device: ${displayName ?? 'unknown'})`);
+                if (deviceTargets.length === 0) {
+                    console.log('  No targets for this device.');
+                }
+                else {
+                    for (let i = 0; i < deviceTargets.length; i++) {
+                        const t = deviceTargets[i];
+                        const desc = t.description ? `  — ${t.description}` : '';
+                        console.log(`  ${i}: ${t.title ?? '(unnamed)'}${desc}`);
+                    }
                 }
             }
             return 0;
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            if (opts.json) {
+            if (opts.json)
                 console.log(JSON.stringify({ status: 'error', message: msg }));
-            }
-            else {
-                console.error(`\u2717 logs --list \u2014 ${msg}`);
-            }
+            else
+                console.error(`✗ logs --list — ${msg}`);
             return 1;
         }
     }
     try {
         // ── Snapshot mode (--recent N) ──────────────────────────────────────────
-        // Single fetch from the daemon's log buffer, print, and exit immediately.
-        // This is the primary agent-friendly mode.
         if (recent !== undefined) {
-            // Ensure daemon is running (starts it if needed)
             await (0, runner_js_1.getDriver)(sessionName);
             const minSeverity = level ? (types_js_1.LEVEL_SEVERITY[level] ?? 0) : 0;
-            // --metro with explicit port → use that port; --metro without port → auto-discover
-            const metroOpt = metro ? (metroPort ?? 'auto') : undefined;
-            const entries = await (0, client_js_1.fetchDaemonLogs)(sessionName, {
-                limit: recent,
-                level,
-                metro: metroOpt,
-            });
+            const entries = await (0, client_js_1.fetchDaemonLogs)(sessionName, { limit: recent, level });
             for (const entry of entries) {
+                if (sourceFilter && entry.source !== sourceFilter)
+                    continue;
                 const entrySeverity = types_js_1.LEVEL_SEVERITY[entry.level] ?? 0;
                 if (entrySeverity < minSeverity)
                     continue;
@@ -116,41 +143,12 @@ async function logs(opts = {}, sessionName = 'default', { source = 'auto', level
             }
             return 0;
         }
-        // ── Determine platform for streaming modes ─────────────────────────────
-        // When source is explicitly 'metro', skip device resolution entirely —
-        // Metro runs on the host, so we don't need a running driver or session.
-        let _platform = 'unknown';
-        if (source !== 'metro') {
-            const driver = await (0, runner_js_1.getDriver)(sessionName);
-            if (driver instanceof ios_js_1.IOSDriver) {
-                _platform = driver.platform;
-            }
-            else if (driver instanceof android_js_1.AndroidDriver) {
-                _platform = 'android';
-            }
-            else if (driver instanceof web_js_1.WebDriver) {
-                _platform = 'web';
-            }
-            else {
-                _platform = await (0, bootstrap_js_1.detectPlatform)(sessionName);
-            }
-        }
+        // ── Streaming modes ─────────────────────────────────────────────────────
+        // Ensure daemon is running; its log collector auto-discovers Metro.
+        await (0, runner_js_1.getDriver)(sessionName);
         const minSeverity = level ? (types_js_1.LEVEL_SEVERITY[level] ?? 0) : 0;
-        // ── Create log source ──────────────────────────────────────────────────
-        let logSource;
-        if (source === 'metro') {
-            // Explicit --source metro: connect directly to Metro via CLI
-            logSource = new metro_js_1.MetroLogSource(metroPort ?? 8081, 'localhost', target);
-            await logSource.connect();
-        }
-        else {
-            // Device logs via daemon. When --metro is set, pass the metro port
-            // (or 'auto' for auto-discovery) so the daemon finds Metro for this device.
-            const metroOpt = metro ? (metroPort ?? 'auto') : undefined;
-            logSource = new daemon_js_1.DaemonLogSource(sessionName, metroOpt);
-            await logSource.connect();
-        }
-        // Set up graceful shutdown
+        const logSource = new daemon_js_1.DaemonLogSource(sessionName);
+        await logSource.connect();
         const cleanup = () => {
             logSource.disconnect();
             process.exit(0);
@@ -158,12 +156,13 @@ async function logs(opts = {}, sessionName = 'default', { source = 'auto', level
         process.on('SIGINT', cleanup);
         process.on('SIGTERM', cleanup);
         logSource.onEntry((entry) => {
+            if (sourceFilter && entry.source !== sourceFilter)
+                return;
             const entrySeverity = types_js_1.LEVEL_SEVERITY[entry.level] ?? 0;
             if (entrySeverity < minSeverity)
                 return;
             console.log(formatEntry(entry, opts));
         });
-        // ── Duration mode (--duration N) ───────────────────────────────────────
         if (duration !== undefined) {
             await new Promise((resolve) => {
                 setTimeout(() => {
@@ -173,11 +172,8 @@ async function logs(opts = {}, sessionName = 'default', { source = 'auto', level
             });
             return 0;
         }
-        // ── Streaming mode (default) ───────────────────────────────────────────
-        // Keep the process alive — the log source streams entries via callbacks
-        await new Promise(() => {
-            // Never resolves — exits via SIGINT/SIGTERM
-        });
+        // Streaming — never resolves; exits via SIGINT/SIGTERM
+        await new Promise(() => { });
         return 0;
     }
     catch (err) {
@@ -186,7 +182,7 @@ async function logs(opts = {}, sessionName = 'default', { source = 'auto', level
             console.log(JSON.stringify({ status: 'error', message: msg }));
         }
         else {
-            console.error(`\u2717 logs \u2014 ${msg}`);
+            console.error(`✗ logs — ${msg}`);
         }
         return 1;
     }

package/dist/daemon/client.js

@@ -205,9 +205,8 @@ async function findRunningWebSession(browserName) {
  * Fetch buffered log entries from the daemon's /logs HTTP endpoint.
  * Used by `conductor logs --recent` for snapshot access.
  *
- * Pass `metro` port to opt in to Metro auto-discovery for React Native apps.
- * The daemon will start polling Metro's /json endpoint for a debugger target
- * matching this device and merge JS console entries into the log buffer.
+ * The daemon always auto-discovers Metro for the device in this session and
+ * merges JS console entries (source='metro') alongside platform logs.
  */
 async function fetchDaemonLogs(sessionName, opts = {}) {
     const params = new URLSearchParams();
@@ -217,12 +216,6 @@ async function fetchDaemonLogs(sessionName, opts = {}) {
         params.set('level', opts.level);
     if (opts.limit)
         params.set('limit', String(opts.limit));
-    if (opts.metro === 'auto') {
-        params.set('metro', '');
-    }
-    else if (opts.metro) {
-        params.set('metro', String(opts.metro));
-    }
     const qs = params.toString();
     const reqPath = qs ? `/logs?${qs}` : '/logs';
     return new Promise((resolve, reject) => {