@houwert/conductor 0.2.0

package/dist/runner.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFirstDevice = detectFirstDevice;
+exports.getDriver = getDriver;
+exports.runDirect = runDirect;
+exports.spawnCommand = spawnCommand;
+exports.runInlineFlow = runInlineFlow;
+const child_process_1 = require("child_process");
+const session_js_1 = require("./session.js");
+const flow_runner_js_1 = require("./drivers/flow-runner.js");
+const verbose_js_1 = require("./verbose.js");
+const ios_js_1 = require("./drivers/ios.js");
+const android_js_1 = require("./drivers/android.js");
+const bootstrap_js_1 = require("./drivers/bootstrap.js");
+const client_js_1 = require("./daemon/client.js");
+/**
+ * Detect the first booted device/emulator without requiring a session.
+ * Checks Android (adb) and iOS simulators (xcrun simctl).
+ * Result is cached for the process lifetime to avoid repeated subprocess calls.
+ */
+let _cachedDeviceId; // undefined = not yet queried, null = none found
+async function detectFirstDevice() {
+    if (_cachedDeviceId !== undefined)
+        return _cachedDeviceId ?? undefined;
+    // Android: adb devices
+    const adb = await spawnCommand('adb', ['devices', '-l']).catch(() => null);
+    if (adb) {
+        for (const line of adb.stdout.split('\n').slice(1)) {
+            const id = line.trim().split(/\s+/)[0];
+            if (id && !line.includes('offline')) {
+                (0, verbose_js_1.log)(`detectFirstDevice: found Android device "${id}"`);
+                _cachedDeviceId = id;
+                return id;
+            }
+        }
+    }
+    // iOS: xcrun simctl list booted
+    const xcrun = await spawnCommand('xcrun', [
+        'simctl',
+        'list',
+        'devices',
+        'booted',
+        '--json',
+    ]).catch(() => null);
+    if (xcrun?.success) {
+        try {
+            const parsed = JSON.parse(xcrun.stdout);
+            for (const sims of Object.values(parsed.devices)) {
+                for (const sim of sims) {
+                    if (sim.state === 'Booted') {
+                        (0, verbose_js_1.log)(`detectFirstDevice: found iOS simulator "${sim.udid}"`);
+                        _cachedDeviceId = sim.udid;
+                        return sim.udid;
+                    }
+                }
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    _cachedDeviceId = null;
+    return undefined;
+}
+/** Per-session driver cache (process lifetime). */
+const _driverCache = new Map();
+/**
+ * Resolve a session name to a device ID.
+ * If sessionName is not 'default', treat it as a device ID directly.
+ */
+async function resolveDeviceId(sessionName) {
+    if (sessionName !== 'default')
+        return sessionName;
+    const session = await (0, session_js_1.getSession)(sessionName);
+    return session.deviceId ?? (await detectFirstDevice());
+}
+/**
+ * Get or create a driver for the given session.
+ * Auto-starts the driver process if it's not already running.
+ */
+async function getDriver(sessionName = 'default') {
+    if (_driverCache.has(sessionName)) {
+        const cached = _driverCache.get(sessionName);
+        // Quick alive check — if still alive, reuse
+        const alive = await cached.isAlive().catch(() => false);
+        if (alive)
+            return cached;
+        _driverCache.delete(sessionName);
+    }
+    const deviceId = await resolveDeviceId(sessionName);
+    if (!deviceId) {
+        throw new Error('No device found. Connect a device or start a simulator, then run again.');
+    }
+    const platform = await (0, bootstrap_js_1.detectPlatform)(deviceId);
+    const port = await (0, bootstrap_js_1.getDriverPort)(platform, deviceId);
+    (0, verbose_js_1.log)(`getDriver: platform=${platform} deviceId=${deviceId} port=${port}`);
+    let driver;
+    if (!(await (0, bootstrap_js_1.isPortOpen)(port))) {
+        (0, verbose_js_1.log)(`Driver not running — starting daemon for ${deviceId}...`);
+        await (0, client_js_1.startDaemon)(deviceId);
+        await waitForPort(port);
+    }
+    if (platform === 'ios') {
+        const iosDriver = new ios_js_1.IOSDriver(port, '127.0.0.1', deviceId);
+        if (!(await iosDriver.isAlive())) {
+            throw new Error(`iOS XCTest driver on port ${port} is not responding.\n` +
+                `Run: conductor daemon-start --device ${deviceId}`);
+        }
+        driver = iosDriver;
+    }
+    else {
+        const androidDriver = new android_js_1.AndroidDriver(deviceId, port);
+        await androidDriver.connect();
+        driver = androidDriver;
+    }
+    _driverCache.set(sessionName, driver);
+    return driver;
+}
+/**
+ * Execute a function with the driver for the given session.
+ * Returns a RunResult for consistent error handling across commands.
+ */
+async function runDirect(fn, sessionName = 'default') {
+    try {
+        const driver = await getDriver(sessionName);
+        const output = await fn(driver);
+        return {
+            success: true,
+            stdout: output ?? '',
+            stderr: '',
+            exitCode: 0,
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            success: false,
+            stdout: '',
+            stderr: msg,
+            exitCode: 1,
+        };
+    }
+}
+// ── Spawn helpers ─────────────────────────────────────────────────────────────
+async function spawnCommand(cmd, args) {
+    return new Promise((resolve) => {
+        const proc = (0, child_process_1.spawn)(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout.on('data', (chunk) => {
+            stdout += chunk.toString();
+        });
+        proc.stderr.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        proc.on('close', (code) => {
+            const exitCode = code ?? 1;
+            resolve({ success: exitCode === 0, stdout, stderr, exitCode });
+        });
+        proc.on('error', (err) => {
+            resolve({ success: false, stdout: '', stderr: err.message, exitCode: 1 });
+        });
+    });
+}
+/** Poll until a TCP port is open, or throw after timeout. */
+async function waitForPort(port, timeoutMs = 180000, pollMs = 500) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (await (0, bootstrap_js_1.isPortOpen)(port))
+            return;
+        await new Promise((r) => setTimeout(r, pollMs));
+    }
+    throw new Error(`Driver port ${port} did not open within ${timeoutMs / 1000}s`);
+}
+async function runInlineFlow(commands, sessionName = 'default', benchmark = false) {
+    const session = await (0, session_js_1.getSession)(sessionName);
+    const appId = session.appId ?? 'com.placeholder';
+    const yamlContent = `appId: ${appId}\n---\n${commands}`;
+    (0, verbose_js_1.log)(`runInlineFlow: executing inline flow:\n${yamlContent}`);
+    try {
+        const driver = await getDriver(sessionName);
+        const flow = (0, flow_runner_js_1.parseFlowString)(yamlContent);
+        await (0, flow_runner_js_1.executeFlow)(flow, driver, { benchmark });
+        return { success: true, stdout: '', stderr: '', exitCode: 0 };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { success: false, stdout: '', stderr: msg, exitCode: 1 };
+    }
+}

package/dist/session.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionFilePath = sessionFilePath;
+exports.getSession = getSession;
+exports.saveSession = saveSession;
+exports.updateSession = updateSession;
+exports.clearSession = clearSession;
+exports.listSessions = listSessions;
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const CONDUCTOR_DIR = path_1.default.join(os_1.default.homedir(), '.conductor');
+const SESSIONS_DIR = path_1.default.join(CONDUCTOR_DIR, 'sessions');
+const LEGACY_SESSION_FILE = path_1.default.join(CONDUCTOR_DIR, 'session.json');
+function sessionFilePath(sessionName = 'default') {
+    return path_1.default.join(SESSIONS_DIR, `${sessionName}.json`);
+}
+async function getSession(sessionName = 'default') {
+    try {
+        const data = await promises_1.default.readFile(sessionFilePath(sessionName), 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        // For the default session, fall back to the legacy session.json
+        if (sessionName === 'default') {
+            try {
+                const data = await promises_1.default.readFile(LEGACY_SESSION_FILE, 'utf-8');
+                return JSON.parse(data);
+            }
+            catch {
+                return {};
+            }
+        }
+        return {};
+    }
+}
+async function saveSession(session, sessionName = 'default') {
+    await promises_1.default.mkdir(SESSIONS_DIR, { recursive: true });
+    await promises_1.default.writeFile(sessionFilePath(sessionName), JSON.stringify(session, null, 2));
+}
+async function updateSession(updates, sessionName = 'default') {
+    const current = await getSession(sessionName);
+    const updated = { ...current, ...updates };
+    await saveSession(updated, sessionName);
+    return updated;
+}
+async function clearSession(sessionName = 'default') {
+    try {
+        await promises_1.default.unlink(sessionFilePath(sessionName));
+    }
+    catch {
+        // File doesn't exist — nothing to clear
+    }
+}
+async function listSessions() {
+    try {
+        const files = await promises_1.default.readdir(SESSIONS_DIR);
+        return files.filter((f) => f.endsWith('.json')).map((f) => f.replace(/\.json$/, ''));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/update-check.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForUpdates = checkForUpdates;
+const fs_1 = __importDefault(require("fs"));
+const https_1 = __importDefault(require("https"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const pkg_root_js_1 = require("./pkg-root.js");
+const CACHE_FILE = path_1.default.join(os_1.default.homedir(), '.conductor', 'update-check.json');
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const REGISTRY_URL = 'https://registry.npmjs.org/@houwert/conductor/latest';
+function readCache() {
+    try {
+        const raw = fs_1.default.readFileSync(CACHE_FILE, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(data) {
+    try {
+        fs_1.default.mkdirSync(path_1.default.dirname(CACHE_FILE), { recursive: true });
+        fs_1.default.writeFileSync(CACHE_FILE, JSON.stringify(data));
+    }
+    catch {
+        // ignore write failures
+    }
+}
+function fetchLatestVersion() {
+    return new Promise((resolve, reject) => {
+        const req = https_1.default.get(REGISTRY_URL, { timeout: 3000 }, (res) => {
+            let body = '';
+            res.on('data', (chunk) => {
+                body += chunk.toString();
+            });
+            res.on('end', () => {
+                try {
+                    const data = JSON.parse(body);
+                    resolve(data.version);
+                }
+                catch {
+                    reject(new Error('Failed to parse registry response'));
+                }
+            });
+        });
+        req.on('error', reject);
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('Registry request timed out'));
+        });
+    });
+}
+function parseVersion(v) {
+    return v.split('.').map(Number);
+}
+function isNewer(latest, current) {
+    const l = parseVersion(latest);
+    const c = parseVersion(current);
+    for (let i = 0; i < 3; i++) {
+        const li = l[i] ?? 0;
+        const ci = c[i] ?? 0;
+        if (li > ci)
+            return true;
+        if (li < ci)
+            return false;
+    }
+    return false;
+}
+function getOwnVersion() {
+    try {
+        const pkgPath = path_1.default.join((0, pkg_root_js_1.findPkgRoot)(__dirname), 'package.json');
+        const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf8'));
+        return pkg.version;
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+function checkForUpdates() {
+    if (process.env['CONDUCTOR_NO_UPDATE_CHECK'] === '1')
+        return;
+    // Fire-and-forget: run async without blocking
+    void (async () => {
+        try {
+            const now = Date.now();
+            const cache = readCache();
+            let latestVersion;
+            if (cache && now - cache.checkedAt < CACHE_TTL_MS) {
+                latestVersion = cache.latestVersion;
+            }
+            else {
+                latestVersion = await fetchLatestVersion();
+                writeCache({ checkedAt: now, latestVersion });
+            }
+            const currentVersion = getOwnVersion();
+            if (isNewer(latestVersion, currentVersion)) {
+                process.stderr.write(`\nA new version of conductor is available: ${latestVersion} (you have ${currentVersion})\n` +
+                    `Run: npm install -g @houwert/conductor\n`);
+            }
+        }
+        catch {
+            // Never surface update-check errors to the user
+        }
+    })();
+}

package/dist/utils.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = sleep;
+exports.swipeCoords = swipeCoords;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function swipeCoords(dir) {
+    switch (dir) {
+        case 'down':
+            return { startX: 0.5, startY: 0.7, endX: 0.5, endY: 0.3 };
+        case 'up':
+            return { startX: 0.5, startY: 0.3, endX: 0.5, endY: 0.7 };
+        case 'left':
+            return { startX: 0.8, startY: 0.5, endX: 0.2, endY: 0.5 };
+        case 'right':
+            return { startX: 0.2, startY: 0.5, endX: 0.8, endY: 0.5 };
+    }
+}

package/dist/verbose.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setVerbose = setVerbose;
+exports.isVerbose = isVerbose;
+exports.log = log;
+let _verbose = false;
+function setVerbose(v) {
+    _verbose = v;
+}
+function isVerbose() {
+    return _verbose;
+}
+function log(...args) {
+    if (_verbose) {
+        console.error('[verbose]', ...args);
+    }
+}

package/drivers/ios/conductor-driver-ios-config.xctestrun

@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>__xctestrun_metadata__</key>
+	<dict>
+		<key>ContainerInfo</key>
+		<dict>
+			<key>ContainerName</key>
+			<string>conductor-driver-ios</string>
+			<key>SchemeName</key>
+			<string>conductor-driver-ios</string>
+		</dict>
+		<key>FormatVersion</key>
+		<integer>1</integer>
+	</dict>
+	<key>conductor-driver-iosUITests</key>
+	<dict>
+		<key>BlueprintName</key>
+		<string>conductor-driver-iosUITests</string>
+		<key>BlueprintProviderName</key>
+		<string>conductor-driver-ios</string>
+		<key>BlueprintProviderRelativePath</key>
+		<string>conductor-driver-ios.xcodeproj</string>
+		<key>BundleIdentifiersForCrashReportEmphasis</key>
+		<array>
+			<string>dev.houwert.ConductorDriverLib</string>
+			<string>dev.houwert.conductor-driver-ios</string>
+			<string>dev.houwert.conductor-driver-iosUITests</string>
+		</array>
+		<key>CommandLineArguments</key>
+		<array/>
+		<key>DefaultTestExecutionTimeAllowance</key>
+		<integer>600</integer>
+		<key>DependentProductPaths</key>
+		<array>
+			<string>__TESTROOT__/Debug-iphonesimulator/ConductorDriverLib.framework</string>
+			<string>__TESTROOT__/Debug-iphonesimulator/conductor-driver-ios.app</string>
+			<string>__TESTROOT__/Debug-iphonesimulator/conductor-driver-iosUITests-Runner.app</string>
+			<string>__TESTROOT__/Debug-iphonesimulator/conductor-driver-iosUITests-Runner.app/PlugIns/conductor-driver-iosUITests.xctest</string>
+		</array>
+		<key>DiagnosticCollectionPolicy</key>
+		<integer>1</integer>
+		<key>EnvironmentVariables</key>
+		<dict>
+			<key>APP_DISTRIBUTOR_ID_OVERRIDE</key>
+			<string>com.apple.AppStore</string>
+			<key>OS_ACTIVITY_DT_MODE</key>
+			<string>YES</string>
+			<key>SQLITE_ENABLE_THREAD_ASSERTIONS</key>
+			<string>1</string>
+			<key>TERM</key>
+			<string>dumb</string>
+		</dict>
+		<key>IsUITestBundle</key>
+		<true/>
+		<key>IsXCTRunnerHostedTestBundle</key>
+		<true/>
+		<key>PreferredScreenCaptureFormat</key>
+		<string>screenRecording</string>
+		<key>ProductModuleName</key>
+		<string>conductor_driver_iosUITests</string>
+		<key>RunOrder</key>
+		<integer>0</integer>
+		<key>SkipTestIdentifiers</key>
+		<array>
+			<string>ViewHierarchyHandlerTests</string>
+			<string>ViewHierarchyHandlerTests/testViewHierarchyHandlerReturnsNonEmptyHierarchy()</string>
+		</array>
+		<key>SystemAttachmentLifetime</key>
+		<string>deleteOnSuccess</string>
+		<key>TestBundlePath</key>
+		<string>__TESTHOST__/PlugIns/conductor-driver-iosUITests.xctest</string>
+		<key>TestHostBundleIdentifier</key>
+		<string>dev.houwert.conductor-driver-iosUITests.xctrunner</string>
+		<key>TestHostPath</key>
+		<string>__TESTROOT__/Debug-iphonesimulator/conductor-driver-iosUITests-Runner.app</string>
+		<key>TestLanguage</key>
+		<string></string>
+		<key>TestRegion</key>
+		<string></string>
+		<key>TestTimeoutsEnabled</key>
+		<false/>
+		<key>TestingEnvironmentVariables</key>
+		<dict>
+			<key>DYLD_FRAMEWORK_PATH</key>
+			<string>__TESTROOT__/Debug-iphonesimulator:__TESTROOT__/Debug-iphonesimulator/PackageFrameworks:__PLATFORMS__/iPhoneSimulator.platform/Developer/Library/Frameworks</string>
+			<key>DYLD_LIBRARY_PATH</key>
+			<string>__TESTROOT__/Debug-iphonesimulator:__PLATFORMS__/iPhoneSimulator.platform/Developer/usr/lib</string>
+			<key>XCODE_SCHEME_NAME</key>
+			<string>conductor-driver-ios</string>
+			<key>__XCODE_BUILT_PRODUCTS_DIR_PATHS</key>
+			<string>__TESTROOT__/Debug-iphonesimulator</string>
+			<key>__XPC_DYLD_FRAMEWORK_PATH</key>
+			<string>__TESTROOT__/Debug-iphonesimulator</string>
+			<key>__XPC_DYLD_LIBRARY_PATH</key>
+			<string>__TESTROOT__/Debug-iphonesimulator</string>
+		</dict>
+		<key>ToolchainsSettingValue</key>
+		<array/>
+		<key>UITargetAppCommandLineArguments</key>
+		<array/>
+		<key>UITargetAppEnvironmentVariables</key>
+		<dict>
+			<key>APP_DISTRIBUTOR_ID_OVERRIDE</key>
+			<string>com.apple.AppStore</string>
+			<key>DYLD_FRAMEWORK_PATH</key>
+			<string>__TESTROOT__/Debug-iphonesimulator:__TESTROOT__/Debug-iphonesimulator/PackageFrameworks</string>
+			<key>DYLD_LIBRARY_PATH</key>
+			<string>__TESTROOT__/Debug-iphonesimulator</string>
+			<key>XCODE_SCHEME_NAME</key>
+			<string>conductor-driver-ios</string>
+			<key>__XCODE_BUILT_PRODUCTS_DIR_PATHS</key>
+			<string>__TESTROOT__/Debug-iphonesimulator</string>
+			<key>__XPC_DYLD_FRAMEWORK_PATH</key>
+			<string>__TESTROOT__/Debug-iphonesimulator</string>
+			<key>__XPC_DYLD_LIBRARY_PATH</key>
+			<string>__TESTROOT__/Debug-iphonesimulator</string>
+		</dict>
+		<key>UITargetAppPath</key>
+		<string>__TESTROOT__/Debug-iphonesimulator/conductor-driver-ios.app</string>
+		<key>UserAttachmentLifetime</key>
+		<string>deleteOnSuccess</string>
+	</dict>
+</dict>
+</plist>

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@houwert/conductor",
+  "version": "0.2.0",
+  "description": "CLI tool for mobile app interactions — optimized for AI agents",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DouweBos/conductor"
+  },
+  "homepage": "https://github.com/DouweBos/conductor",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "conductor": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist/",
+    "drivers/",
+    "skills/",
+    "proto/",
+    ".claude-plugin/"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "tsc -p tests/tsconfig.json && node dist-tests/tests/all-tests.js",
+    "lint": "eslint src && prettier --check src",
+    "lint:fix": "eslint src --fix && prettier --write src",
+    "postinstall": "node dist/postinstall.js"
+  },
+  "packageManager": "pnpm@9.0.0",
+  "dependencies": {
+    "@grpc/grpc-js": "^1.12.0",
+    "@grpc/proto-loader": "^0.7.15",
+    "js-yaml": "^4.1.1",
+    "minimist": "^1.2.8"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/minimist": "^1.2.5",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.56.1",
+    "@typescript-eslint/parser": "^8.56.1",
+    "eslint": "^10.0.2",
+    "eslint-config-prettier": "^10.1.8",
+    "prettier": "^3.8.1",
+    "typescript": "^5.4.0",
+    "typescript-eslint": "^8.56.1"
+  }
+}