@houwert/conductor 0.2.0

package/dist/daemon/client.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startDaemon = startDaemon;
+exports.stopDaemon = stopDaemon;
+exports.listDaemonSessions = listDaemonSessions;
+exports.daemonStatus = daemonStatus;
+const net_1 = __importDefault(require("net"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const protocol_js_1 = require("./protocol.js");
+const verbose_js_1 = require("../verbose.js");
+const STARTUP_POLL_MS = 200;
+const STARTUP_MAX_WAIT_MS = 10000;
+async function socketExists(sessionName) {
+    return new Promise((resolve) => {
+        const sock = net_1.default.createConnection((0, protocol_js_1.socketPath)(sessionName));
+        sock.on('connect', () => {
+            sock.destroy();
+            resolve(true);
+        });
+        sock.on('error', () => resolve(false));
+        sock.setTimeout(500);
+        sock.on('timeout', () => {
+            sock.destroy();
+            resolve(false);
+        });
+    });
+}
+async function waitForDaemon(sessionName) {
+    const deadline = Date.now() + STARTUP_MAX_WAIT_MS;
+    while (Date.now() < deadline) {
+        if (await socketExists(sessionName))
+            return true;
+        await new Promise((r) => setTimeout(r, STARTUP_POLL_MS));
+    }
+    return false;
+}
+async function startDaemon(sessionName = 'default') {
+    if (await socketExists(sessionName))
+        return true;
+    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], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+    (0, verbose_js_1.log)(`waiting for daemon [${sessionName}] to be ready...`);
+    const ready = await waitForDaemon(sessionName);
+    (0, verbose_js_1.log)(ready
+        ? `daemon [${sessionName}] ready`
+        : `daemon [${sessionName}] failed to start within timeout`);
+    return ready;
+}
+async function stopDaemon(sessionName = 'default') {
+    let killed = false;
+    try {
+        const pid = parseInt(fs_1.default.readFileSync((0, protocol_js_1.pidFile)(sessionName), 'utf-8').trim(), 10);
+        if (!isNaN(pid)) {
+            process.kill(pid, 'SIGTERM');
+            killed = true;
+        }
+    }
+    catch {
+        /* pid file missing or process already gone */
+    }
+    // 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)]) {
+        try {
+            fs_1.default.unlinkSync(file);
+        }
+        catch {
+            /* ok */
+        }
+    }
+    try {
+        fs_1.default.rmdirSync(dir);
+    }
+    catch {
+        /* ok if non-empty or already gone */
+    }
+    return killed;
+}
+function listDaemonSessions() {
+    const daemonsDir = path_1.default.join(os_1.default.homedir(), '.conductor', 'daemons');
+    try {
+        return fs_1.default.readdirSync(daemonsDir).filter((name) => {
+            return fs_1.default.statSync(path_1.default.join(daemonsDir, name)).isDirectory();
+        });
+    }
+    catch {
+        return [];
+    }
+}
+async function daemonStatus(sessionName = 'default') {
+    const running = await socketExists(sessionName);
+    if (!running)
+        return { running: false };
+    try {
+        const pid = parseInt(fs_1.default.readFileSync((0, protocol_js_1.pidFile)(sessionName), 'utf-8').trim(), 10);
+        return { running: true, pid: isNaN(pid) ? undefined : pid };
+    }
+    catch {
+        return { running: true };
+    }
+}

package/dist/daemon/protocol.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDLE_TIMEOUT_MS = void 0;
+exports.socketPath = socketPath;
+exports.pidFile = pidFile;
+exports.logFile = logFile;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const DIR = path_1.default.join(os_1.default.homedir(), '.conductor');
+function daemonDir(sessionName = 'default') {
+    return path_1.default.join(DIR, 'daemons', sessionName);
+}
+function socketPath(sessionName = 'default') {
+    return path_1.default.join(daemonDir(sessionName), 'daemon.sock');
+}
+function pidFile(sessionName = 'default') {
+    return path_1.default.join(daemonDir(sessionName), 'daemon.pid');
+}
+function logFile(sessionName = 'default') {
+    return path_1.default.join(daemonDir(sessionName), 'daemon.log');
+}
+exports.IDLE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes

package/dist/daemon/server.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Daemon process — run as a detached background process.
+ *
+ * Repurposed from the MCP proxy: now manages the underlying device driver process
+ * (iOS XCTest HTTP server or Android gRPC instrumentation).
+ *
+ * The Unix socket is kept alive purely for status checks (daemonStatus() tests
+ * if the socket is connectable). No tool-call proxying happens here.
+ *
+ * Spawned by: node dist/daemon/server.js [sessionName]
+ */
+const net_1 = __importDefault(require("net"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const protocol_js_1 = require("./protocol.js");
+const bootstrap_js_1 = require("../drivers/bootstrap.js");
+const sessionName = process.argv[2] ?? 'default';
+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);
+function dlog(msg) {
+    const line = `[${new Date().toISOString()}] ${msg}\n`;
+    try {
+        fs_1.default.appendFileSync(LOG_FILE, line);
+    }
+    catch {
+        /* ignore */
+    }
+}
+// ── Driver lifecycle ──────────────────────────────────────────────────────────
+let driverPort = 1075;
+let driverPlatform = 'ios';
+const DRIVER_HEALTH_INTERVAL_MS = 10000; // Check driver health every 10s
+let _restartInProgress = false;
+async function ensureDriverRunning() {
+    if (_restartInProgress)
+        return;
+    const alive = await (0, bootstrap_js_1.isPortOpen)(driverPort);
+    if (!alive) {
+        if (driverPlatform === 'ios' && !(await (0, bootstrap_js_1.isSimulatorBooted)(sessionName))) {
+            dlog(`Simulator ${sessionName} is not booted — skipping driver restart`);
+            return;
+        }
+        _restartInProgress = true;
+        dlog(`Driver on port ${driverPort} not responding — restarting`);
+        try {
+            if (driverPlatform === 'ios') {
+                await (0, bootstrap_js_1.startIOSDriver)(sessionName, driverPort);
+            }
+            else {
+                await (0, bootstrap_js_1.startAndroidDriver)(sessionName, driverPort);
+            }
+            dlog(`Driver restarted on port ${driverPort}`);
+        }
+        catch (err) {
+            dlog(`Failed to restart driver: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            _restartInProgress = false;
+        }
+    }
+}
+// ── Daemon main ──────────────────────────────────────────────────────────────
+async function main() {
+    // Ensure per-session daemon directory exists
+    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}`);
+    // Remove stale socket
+    try {
+        fs_1.default.unlinkSync(SOCKET_PATH);
+    }
+    catch {
+        /* ok */
+    }
+    let idleTimer;
+    let healthTimer;
+    const idleTimeoutMs = Number(process.env.CONDUCTOR_IDLE_TIMEOUT_MS) || protocol_js_1.IDLE_TIMEOUT_MS;
+    function resetIdleTimer() {
+        if (idleTimer)
+            clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => {
+            dlog('Idle timeout reached — shutting down');
+            cleanup().then(() => process.exit(0));
+        }, idleTimeoutMs);
+    }
+    async function cleanup() {
+        if (healthTimer)
+            clearInterval(healthTimer);
+        try {
+            fs_1.default.unlinkSync(SOCKET_PATH);
+        }
+        catch {
+            /* ok */
+        }
+        try {
+            fs_1.default.unlinkSync(PID_FILE);
+        }
+        catch {
+            /* ok */
+        }
+        try {
+            fs_1.default.unlinkSync(LOG_FILE);
+        }
+        catch {
+            /* ok if non-empty or already gone */
+        }
+        try {
+            fs_1.default.rmdirSync(path_1.default.dirname(PID_FILE));
+        }
+        catch {
+            /* ok */
+        }
+        if (sessionName !== 'default') {
+            dlog(`Stopping driver on port ${driverPort}`);
+            try {
+                if (driverPlatform === 'ios') {
+                    await (0, bootstrap_js_1.stopIOSDriver)(sessionName);
+                }
+                else {
+                    await (0, bootstrap_js_1.stopAndroidDriver)(sessionName);
+                }
+            }
+            catch (err) {
+                dlog(`Stop driver error: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            dlog(`Uninstalling driver from ${sessionName}`);
+            try {
+                await (0, bootstrap_js_1.uninstallDriver)(sessionName, driverPlatform);
+            }
+            catch (err) {
+                dlog(`Uninstall driver error: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    process.on('SIGTERM', () => {
+        cleanup().then(() => process.exit(0));
+    });
+    process.on('SIGINT', () => {
+        cleanup().then(() => process.exit(0));
+    });
+    // Periodically check driver health and restart if needed
+    if (sessionName !== 'default') {
+        healthTimer = setInterval(() => {
+            ensureDriverRunning().catch((err) => dlog(`Health check error: ${err.message}`));
+        }, DRIVER_HEALTH_INTERVAL_MS);
+        healthTimer.unref(); // Don't keep the process alive just for health checks
+    }
+    // Create socket — accept connections as aliveness pings (no message exchange needed)
+    const server = net_1.default.createServer({ allowHalfOpen: true }, (socket) => {
+        resetIdleTimer();
+        // Close immediately — the connect/accept is enough for daemonStatus()
+        socket.end();
+        socket.on('error', () => {
+            /* ignore */
+        });
+    });
+    server.listen(SOCKET_PATH, () => {
+        dlog(`socket ready at ${SOCKET_PATH}`);
+        resetIdleTimer();
+        // Start driver in the background after the socket is ready (so the client
+        // doesn't time out waiting for the socket while the driver is starting).
+        if (sessionName !== 'default') {
+            (0, bootstrap_js_1.detectPlatform)(sessionName)
+                .then(async (platform) => {
+                driverPlatform = platform;
+                driverPort = await (0, bootstrap_js_1.getDriverPort)(platform, sessionName);
+                dlog(`Platform: ${platform}, port: ${driverPort}`);
+                if (await (0, bootstrap_js_1.isPortOpen)(driverPort)) {
+                    dlog(`Driver already running on port ${driverPort}`);
+                    return;
+                }
+                // Android: install APKs before starting the driver.
+                // iOS: startIOSDriver uses xcodebuild which installs silently via DependentProductPaths.
+                if (platform === 'android') {
+                    dlog(`Installing Android driver on ${sessionName}`);
+                    await (0, bootstrap_js_1.installDriver)(sessionName);
+                    dlog(`Driver installation complete`);
+                }
+                dlog(`Starting ${platform} driver on port ${driverPort}`);
+                try {
+                    if (platform === 'ios') {
+                        await (0, bootstrap_js_1.startIOSDriver)(sessionName, driverPort);
+                    }
+                    else {
+                        await (0, bootstrap_js_1.startAndroidDriver)(sessionName, driverPort);
+                    }
+                    dlog(`Driver started successfully`);
+                }
+                catch (err) {
+                    dlog(`Driver startup error: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            })
+                .catch((err) => {
+                dlog(`Platform detection error: ${err instanceof Error ? err.message : String(err)}`);
+            });
+        }
+    });
+}
+main().catch((err) => {
+    console.error('Daemon error:', err);
+    process.exit(1);
+});

package/dist/drivers/android.js

@@ -0,0 +1,343 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AndroidDriver = void 0;
+/**
+ * Direct gRPC + ADB client for the Conductor Android driver.
+ *
+ * Protocol:
+ *   - gRPC plaintext on localhost:3763 (ADB-forwarded) for: tap, inputText, eraseAllText,
+ *     screenshot, viewHierarchy, launchApp, deviceInfo
+ *   - ADB shell for: back, swipe/scroll, pressKey, stopApp (not in gRPC proto)
+ */
+const grpc = __importStar(require("@grpc/grpc-js"));
+const protoLoader = __importStar(require("@grpc/proto-loader"));
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// __dirname is available in CommonJS — points to dist/drivers/
+const PROTO_PATH = path_1.default.join(__dirname, '../../proto/conductor_android.proto');
+let _packageDef = null;
+function loadPackageDef() {
+    if (!_packageDef) {
+        _packageDef = protoLoader.loadSync(PROTO_PATH, {
+            keepCase: true,
+            longs: String,
+            enums: String,
+            defaults: true,
+            oneofs: true,
+        });
+    }
+    return _packageDef;
+}
+class AndroidDriver {
+    constructor(deviceId, port = 3763) {
+        this.deviceId = deviceId;
+        this.port = port;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.client = null;
+        this._recordingProcess = null;
+        this._recordingOutputPath = '';
+    }
+    async connect() {
+        const packageDef = loadPackageDef();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const proto = grpc.loadPackageDefinition(packageDef);
+        const ConductorDriver = proto.conductor_android.ConductorDriver;
+        this.client = new ConductorDriver(`localhost:${this.port}`, grpc.credentials.createInsecure(), {
+            'grpc.keepalive_time_ms': 120000,
+            'grpc.keepalive_timeout_ms': 20000,
+        });
+    }
+    async close() {
+        if (this.client) {
+            await new Promise((resolve) => this.client.close(() => resolve()));
+            this.client = null;
+        }
+    }
+    async isAlive() {
+        try {
+            await this.deviceInfo();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    call(method, req) {
+        return new Promise((resolve, reject) => {
+            if (!this.client) {
+                reject(new Error('AndroidDriver: not connected'));
+                return;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.client[method](req, (err, resp) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(resp);
+            });
+        });
+    }
+    async deviceInfo() {
+        const resp = await this.call('deviceInfo', {});
+        return { widthPixels: resp.widthPixels, heightPixels: resp.heightPixels };
+    }
+    async tap(x, y) {
+        await this.call('tap', { x: Math.round(x), y: Math.round(y) });
+    }
+    async inputText(text) {
+        await this.call('inputText', { text });
+    }
+    async eraseAllText(charactersToErase = 50) {
+        await this.call('eraseAllText', { charactersToErase });
+    }
+    async launchApp(packageName, args) {
+        const arguments_ = [];
+        if (args) {
+            for (const [key, value] of Object.entries(args)) {
+                arguments_.push({ key, value, type: 'string' });
+            }
+        }
+        await this.call('launchApp', { packageName, arguments: arguments_ });
+    }
+    async viewHierarchy() {
+        const resp = await this.call('viewHierarchy', {});
+        return resp.hierarchy;
+    }
+    async screenshot() {
+        const resp = await this.call('screenshot', {});
+        return Buffer.from(resp.bytes);
+    }
+    // ── ADB-shell operations (not in gRPC proto) ─────────────────────────────
+    adb(args) {
+        return new Promise((resolve, reject) => {
+            const proc = (0, child_process_1.spawn)('adb', ['-s', this.deviceId, ...args], { stdio: 'ignore' });
+            proc.on('close', (code) => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`adb ${args.join(' ')} failed with exit code ${code}`));
+            });
+            proc.on('error', reject);
+        });
+    }
+    async back() {
+        await this.adb(['shell', 'input', 'keyevent', '4']);
+    }
+    async stopApp(packageName) {
+        await this.adb(['shell', 'am', 'force-stop', packageName]);
+    }
+    async swipe(startX, startY, endX, endY, durationMs) {
+        await this.adb([
+            'shell',
+            'input',
+            'swipe',
+            String(Math.round(startX)),
+            String(Math.round(startY)),
+            String(Math.round(endX)),
+            String(Math.round(endY)),
+            String(Math.round(durationMs)),
+        ]);
+    }
+    /** Press a key by Android keyevent code. */
+    async pressKeyEvent(keycode) {
+        await this.adb(['shell', 'input', 'keyevent', String(keycode)]);
+    }
+    adbOutput(args) {
+        return new Promise((resolve, reject) => {
+            const proc = (0, child_process_1.spawn)('adb', ['-s', this.deviceId, ...args], {
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            let stdout = '';
+            proc.stdout.on('data', (chunk) => {
+                stdout += chunk.toString();
+            });
+            proc.on('close', (code) => {
+                if (code === 0)
+                    resolve(stdout);
+                else
+                    reject(new Error(`adb ${args.join(' ')} failed with exit code ${code}`));
+            });
+            proc.on('error', reject);
+        });
+    }
+    async getForegroundApp() {
+        const output = await this.adbOutput(['shell', 'dumpsys', 'activity', 'activities']);
+        const match = output.match(/mResumedActivity.*?([a-zA-Z][a-zA-Z0-9_]*(?:\.[a-zA-Z][a-zA-Z0-9_]*)+)\//);
+        if (!match)
+            throw new Error('Could not determine foreground app');
+        return match[1];
+    }
+    async clearAppState(packageName) {
+        await this.adb(['shell', 'pm', 'clear', packageName]);
+    }
+    async clearKeychain() {
+        // No-op on Android — keychain is an iOS concept
+    }
+    async openLink(url) {
+        await this.adb(['shell', 'am', 'start', '-a', 'android.intent.action.VIEW', '-d', url]);
+    }
+    async setLocation(latitude, longitude) {
+        await this.call('setLocation', { latitude, longitude });
+    }
+    async setOrientation(orientation) {
+        const rotationMap = {
+            PORTRAIT: '0',
+            LANDSCAPE: '1',
+            PORTRAIT_REVERSE: '2',
+            LANDSCAPE_REVERSE: '3',
+        };
+        const rotation = rotationMap[orientation.toUpperCase()] ?? '0';
+        // Disable auto-rotation first, then set the rotation value
+        await this.adb(['shell', 'settings', 'put', 'system', 'accelerometer_rotation', '0']);
+        await this.adb(['shell', 'settings', 'put', 'system', 'user_rotation', rotation]);
+    }
+    async setPermissions(appId, permissions) {
+        const PERMISSION_MAP = {
+            camera: ['android.permission.CAMERA'],
+            microphone: ['android.permission.RECORD_AUDIO'],
+            location: [
+                'android.permission.ACCESS_FINE_LOCATION',
+                'android.permission.ACCESS_COARSE_LOCATION',
+            ],
+            storage: [
+                'android.permission.READ_EXTERNAL_STORAGE',
+                'android.permission.WRITE_EXTERNAL_STORAGE',
+            ],
+            contacts: ['android.permission.READ_CONTACTS', 'android.permission.WRITE_CONTACTS'],
+            calendar: ['android.permission.READ_CALENDAR', 'android.permission.WRITE_CALENDAR'],
+            phone: ['android.permission.CALL_PHONE', 'android.permission.READ_PHONE_STATE'],
+            sms: ['android.permission.SEND_SMS', 'android.permission.RECEIVE_SMS'],
+            notifications: [], // Not manageable via pm grant on Android
+        };
+        const toProcess = [];
+        if ('all' in permissions) {
+            const value = permissions['all'];
+            if (value !== 'unset') {
+                for (const perms of Object.values(PERMISSION_MAP)) {
+                    for (const perm of perms)
+                        toProcess.push({ perm, value });
+                }
+            }
+        }
+        else {
+            for (const [name, value] of Object.entries(permissions)) {
+                for (const perm of PERMISSION_MAP[name.toLowerCase()] ?? []) {
+                    toProcess.push({ perm, value });
+                }
+            }
+        }
+        for (const { perm, value } of toProcess) {
+            const action = value === 'allow' || value === 'always' || value === 'whenInUse' ? 'grant' : 'revoke';
+            await this.adb(['shell', 'pm', action, appId, perm]).catch(() => {
+                /* ignore if permission not declared */
+            });
+        }
+    }
+    async addMedia(filePath) {
+        if (!this.client)
+            throw new Error('AndroidDriver: not connected');
+        const data = fs_1.default.readFileSync(filePath);
+        const ext = path_1.default.extname(filePath).slice(1);
+        const name = path_1.default.basename(filePath, path_1.default.extname(filePath));
+        const CHUNK_SIZE = 256 * 1024;
+        await new Promise((resolve, reject) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const call = this.client.addMedia((err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+            let offset = 0;
+            const writeNext = () => {
+                if (offset >= data.length) {
+                    call.end();
+                    return;
+                }
+                const chunk = data.slice(offset, offset + CHUNK_SIZE);
+                offset += chunk.length;
+                call.write({ payload: { data: chunk }, media_name: name, media_ext: ext });
+                writeNext();
+            };
+            writeNext();
+        });
+    }
+    async setAirplaneMode(enabled) {
+        const state = enabled ? '1' : '0';
+        await this.adb(['shell', 'settings', 'put', 'global', 'airplane_mode_on', state]);
+        await this.adb([
+            'shell',
+            'am',
+            'broadcast',
+            '-a',
+            'android.intent.action.AIRPLANE_MODE',
+            '--ez',
+            'state',
+            enabled ? 'true' : 'false',
+        ]);
+    }
+    async getAirplaneMode() {
+        const output = await this.adbOutput(['shell', 'settings', 'get', 'global', 'airplane_mode_on']);
+        return output.trim() === '1';
+    }
+    async startRecording(outputPath) {
+        if (this._recordingProcess)
+            await this.stopRecording();
+        this._recordingOutputPath = outputPath;
+        this._recordingProcess = (0, child_process_1.spawn)('adb', ['-s', this.deviceId, 'shell', 'screenrecord', '/sdcard/conductor_recording.mp4'], { stdio: 'ignore' });
+    }
+    async stopRecording() {
+        if (this._recordingProcess) {
+            this._recordingProcess.kill('SIGINT');
+            await new Promise((r) => setTimeout(r, 1500)); // wait for file to flush
+            this._recordingProcess = null;
+            if (this._recordingOutputPath) {
+                await this.adb([
+                    'pull',
+                    '/sdcard/conductor_recording.mp4',
+                    this._recordingOutputPath,
+                ]).catch(() => { });
+                await this.adb(['shell', 'rm', '-f', '/sdcard/conductor_recording.mp4']).catch(() => { });
+                this._recordingOutputPath = '';
+            }
+        }
+    }
+}
+exports.AndroidDriver = AndroidDriver;