visor-ai 0.2.5 → 0.2.6

package/dist/daemon.js

@@ -0,0 +1,517 @@
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { DEFAULT_SERVER_URL, getAdapter } from './adapters.js';
+import { DEFAULT_STARTUP_TIMEOUT_SECONDS, startManagedAppium, statusManagedAppium, stopManagedAppium } from './appiumLifecycle.js';
+import { runScenario } from './runner.js';
+import { ensureDir, errorMessage, resolveExecutable, sleep } from './utils.js';
+export class DaemonUnavailableError extends Error {
+    constructor(message = 'Visor daemon is not running. Run `visor start` before real-device commands.') {
+        super(message);
+        this.name = 'DaemonUnavailableError';
+    }
+}
+export class DaemonRequestTimeoutError extends Error {
+    constructor(requestType, timeoutMs) {
+        super(`Timed out after ${timeoutMs}ms waiting for the Visor daemon to finish '${requestType}'. Inspect .visor/daemon/daemon.log and .visor/appium/*.log for the underlying Appium operation.`);
+        this.name = 'DaemonRequestTimeoutError';
+    }
+}
+function daemonDir() {
+    return ensureDir(path.join(process.cwd(), '.visor', 'daemon'));
+}
+function socketPath() {
+    if (process.env.VISOR_DAEMON_SOCKET_PATH) {
+        return process.env.VISOR_DAEMON_SOCKET_PATH;
+    }
+    if (process.platform === 'win32') {
+        return '\\\\.\\pipe\\visor-daemon';
+    }
+    return path.join(daemonDir(), 'visor.sock');
+}
+function metadataPath() {
+    return path.join(daemonDir(), 'daemon.json');
+}
+function logPath() {
+    return path.join(daemonDir(), 'daemon.log');
+}
+function readMetadata() {
+    const filePath = metadataPath();
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeMetadata(meta) {
+    fs.writeFileSync(metadataPath(), JSON.stringify(meta, null, 2), 'utf8');
+}
+function cleanupMetadata() {
+    const filePath = metadataPath();
+    if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+    }
+}
+function pidExists(pid) {
+    if (pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (error && typeof error === 'object' && 'code' in error && error.code === 'EPERM') {
+            return true;
+        }
+        return false;
+    }
+}
+function runtimeKey(runtime) {
+    return JSON.stringify({
+        platform: runtime.platform,
+        server_url: runtime.server_url,
+        device: runtime.device ?? '',
+        app_id: runtime.app_id ?? '',
+        attach_to_running: runtime.attach_to_running
+    });
+}
+function parseBoolean(value) {
+    return ['1', 'true', 'yes', 'on'].includes(String(value ?? '').toLowerCase());
+}
+export function isRecoverableSessionCacheError(error) {
+    const message = errorMessage(error).toLowerCase();
+    return (message.includes('session is either terminated or not started') ||
+        message.includes('invalid session id') ||
+        message.includes('no such driver') ||
+        (message.includes('could not proxy command to the remote server') &&
+            message.includes('econnrefused')) ||
+        (message.includes('127.0.0.1:8100') && message.includes('econnrefused')));
+}
+async function requestDaemon(request, timeoutMs = 1000) {
+    const targetSocket = socketPath();
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(targetSocket);
+        let output = '';
+        let settled = false;
+        function settle(error, response) {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            client.destroy();
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(response ?? { ok: false, error: 'Empty daemon response' });
+            }
+        }
+        client.setTimeout(timeoutMs);
+        client.on('connect', () => {
+            client.write(`${JSON.stringify(request)}\n`);
+        });
+        client.on('data', (chunk) => {
+            output += chunk.toString('utf8');
+        });
+        client.on('end', () => {
+            try {
+                settle(undefined, JSON.parse(output));
+            }
+            catch (error) {
+                settle(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+        client.on('timeout', () => {
+            settle(new DaemonRequestTimeoutError(request.type, timeoutMs));
+        });
+        client.on('error', () => {
+            settle(new DaemonUnavailableError());
+        });
+    });
+}
+async function daemonRequestData(request, timeoutMs = 1000) {
+    const response = await requestDaemon(request, timeoutMs);
+    if (!response.ok) {
+        throw new Error(response.error);
+    }
+    return response.data;
+}
+async function isDaemonReachable() {
+    try {
+        await daemonRequestData({ type: 'status' }, 500);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function daemonEntryCommand() {
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const builtMain = path.join(moduleDir, 'main.js');
+    if (fs.existsSync(builtMain)) {
+        return { command: process.execPath, args: [builtMain] };
+    }
+    const sourceMain = path.resolve(process.cwd(), 'src', 'main.ts');
+    const localTsx = path.resolve(process.cwd(), 'node_modules', '.bin', process.platform === 'win32' ? 'tsx.cmd' : 'tsx');
+    if (fs.existsSync(sourceMain) && fs.existsSync(localTsx)) {
+        return { command: localTsx, args: [sourceMain] };
+    }
+    if (process.argv[1] && fs.existsSync(process.argv[1])) {
+        return { command: process.execPath, args: [process.argv[1]] };
+    }
+    const tsx = resolveExecutable('tsx');
+    if (tsx && fs.existsSync(sourceMain)) {
+        return { command: tsx, args: [sourceMain] };
+    }
+    throw new Error('Unable to resolve a Visor CLI entrypoint for the daemon.');
+}
+export async function startVisorDaemon(serverUrl = DEFAULT_SERVER_URL, appiumCmd) {
+    const existing = readMetadata();
+    if (existing && pidExists(existing.pid) && (await isDaemonReachable())) {
+        return {
+            serverUrl,
+            daemon: {
+                running: true,
+                alreadyRunning: true,
+                pid: existing.pid,
+                socketPath: existing.socketPath,
+                metadataPath: metadataPath(),
+                logPath: logPath()
+            },
+            appium: await statusManagedAppium(serverUrl)
+        };
+    }
+    if (process.platform !== 'win32' && fs.existsSync(socketPath())) {
+        fs.unlinkSync(socketPath());
+    }
+    cleanupMetadata();
+    const appiumStatus = await statusManagedAppium(serverUrl);
+    if (Boolean(appiumStatus.reachable) && !Boolean(appiumStatus.managed)) {
+        throw new Error(`Appium is already reachable at ${serverUrl}, but it is not managed by Visor. Stop the existing Appium process or choose a different --server-url, then run \`visor start\` again.`);
+    }
+    const appium = await startManagedAppium(serverUrl, appiumCmd, DEFAULT_STARTUP_TIMEOUT_SECONDS);
+    const entry = daemonEntryCommand();
+    const targetLogPath = logPath();
+    ensureDir(path.dirname(targetLogPath));
+    const logFd = fs.openSync(targetLogPath, 'a');
+    const child = spawn(entry.command, [...entry.args, '__daemon'], {
+        detached: process.platform !== 'win32',
+        stdio: ['ignore', logFd, logFd],
+        env: {
+            ...process.env,
+            VISOR_DAEMON_SERVER_URL: serverUrl,
+            VISOR_DAEMON_APPIUM_STARTED: String(Boolean(appium.started)),
+            VISOR_DAEMON_SOCKET_PATH: socketPath()
+        }
+    });
+    fs.closeSync(logFd);
+    const meta = {
+        pid: child.pid ?? -1,
+        serverUrl,
+        socketPath: socketPath(),
+        appiumStarted: Boolean(appium.started),
+        startedAt: Date.now()
+    };
+    writeMetadata(meta);
+    child.unref();
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline) {
+        if (await isDaemonReachable()) {
+            return {
+                serverUrl,
+                daemon: {
+                    running: true,
+                    alreadyRunning: false,
+                    pid: meta.pid,
+                    socketPath: meta.socketPath,
+                    metadataPath: metadataPath(),
+                    logPath: targetLogPath
+                },
+                appium
+            };
+        }
+        if (child.exitCode !== null) {
+            cleanupMetadata();
+            throw new Error(`Visor daemon exited before becoming ready. See log at ${targetLogPath}`);
+        }
+        await sleep(100);
+    }
+    cleanupMetadata();
+    throw new Error(`Visor daemon did not become ready within 5.0s. See log at ${targetLogPath}`);
+}
+export async function statusVisorDaemon(serverUrl = DEFAULT_SERVER_URL) {
+    const meta = readMetadata();
+    let daemonData = {};
+    let running = false;
+    let daemonError;
+    const pidPresent = meta ? pidExists(meta.pid) : false;
+    try {
+        daemonData = await daemonRequestData({ type: 'status' }, 2000);
+        running = true;
+    }
+    catch (error) {
+        running = false;
+        daemonError = errorMessage(error);
+    }
+    if (meta && !running && !pidPresent) {
+        cleanupMetadata();
+    }
+    return {
+        serverUrl,
+        daemon: {
+            running,
+            responsive: running,
+            unresponsive: Boolean(meta && pidPresent && !running),
+            pid: meta?.pid ?? null,
+            socketPath: socketPath(),
+            metadataPath: metadataPath(),
+            logPath: logPath(),
+            appiumStarted: running ? (meta?.appiumStarted ?? false) : false,
+            error: daemonError,
+            ...daemonData
+        },
+        appium: await statusManagedAppium(serverUrl)
+    };
+}
+export async function stopVisorDaemon(serverUrl = DEFAULT_SERVER_URL, force = false) {
+    const meta = readMetadata();
+    let daemonResponse = null;
+    try {
+        daemonResponse = await daemonRequestData({ type: 'stop', force }, 5000);
+    }
+    catch (error) {
+        if (!(error instanceof DaemonUnavailableError) && !(error instanceof DaemonRequestTimeoutError)) {
+            throw error;
+        }
+    }
+    if (meta && pidExists(meta.pid)) {
+        const deadline = Date.now() + 3000;
+        while (Date.now() < deadline && pidExists(meta.pid)) {
+            await sleep(100);
+        }
+        if (pidExists(meta.pid) && force) {
+            process.kill(meta.pid, 'SIGKILL');
+        }
+        if (pidExists(meta.pid)) {
+            return {
+                serverUrl,
+                stopped: false,
+                daemon: {
+                    running: false,
+                    unresponsive: true,
+                    reason: 'daemon_did_not_stop',
+                    pid: meta.pid,
+                    socketPath: socketPath(),
+                    metadataPath: metadataPath(),
+                    logPath: logPath()
+                },
+                appium: await statusManagedAppium(serverUrl)
+            };
+        }
+    }
+    if (meta?.appiumStarted) {
+        try {
+            await stopManagedAppium(meta.serverUrl, force);
+        }
+        catch {
+            if (!force) {
+                await stopManagedAppium(meta.serverUrl, true);
+            }
+        }
+    }
+    cleanupMetadata();
+    if (process.platform !== 'win32' && fs.existsSync(socketPath())) {
+        fs.unlinkSync(socketPath());
+    }
+    return {
+        serverUrl,
+        stopped: Boolean(daemonResponse),
+        daemon: daemonResponse ?? {
+            running: false,
+            reason: 'daemon_not_running',
+            socketPath: socketPath(),
+            metadataPath: metadataPath(),
+            logPath: logPath()
+        },
+        appium: await statusManagedAppium(serverUrl)
+    };
+}
+export async function runDaemonAction(runtime, command, args) {
+    return daemonRequestData({ type: 'action', runtime, command, args }, 300000);
+}
+export async function runDaemonScenario(runtime, scenario, device, timeout, outputDir) {
+    return daemonRequestData({ type: 'scenario', runtime, scenario, device, timeout, outputDir }, 600000);
+}
+export async function runDaemonFromEnv() {
+    const options = {
+        serverUrl: process.env.VISOR_DAEMON_SERVER_URL ?? DEFAULT_SERVER_URL,
+        appiumStarted: parseBoolean(process.env.VISOR_DAEMON_APPIUM_STARTED)
+    };
+    const sessions = new Map();
+    let queue = Promise.resolve();
+    let activeOperation = null;
+    let lastError = null;
+    async function closeSessions() {
+        const entries = Array.from(sessions.values());
+        sessions.clear();
+        for (const entry of entries) {
+            try {
+                await entry.adapter.close();
+            }
+            catch {
+                // Stopping the daemon should still succeed if Appium already dropped the session.
+            }
+        }
+    }
+    async function sessionFor(runtime) {
+        const key = runtimeKey(runtime);
+        const existing = sessions.get(key);
+        if (existing) {
+            return existing.adapter;
+        }
+        const adapter = await getAdapter(runtime.platform, runtime.server_url, runtime.device, runtime.app_id, runtime.attach_to_running);
+        sessions.set(key, {
+            adapter,
+            runtime,
+            createdAt: Date.now()
+        });
+        return adapter;
+    }
+    async function discardSession(runtime) {
+        const key = runtimeKey(runtime);
+        const existing = sessions.get(key);
+        if (!existing) {
+            return;
+        }
+        sessions.delete(key);
+        try {
+            await existing.adapter.close();
+        }
+        catch {
+            // The backing WebDriver session is already gone; removing it from the cache is enough.
+        }
+    }
+    async function runActionWithSessionRetry(runtime, command, args) {
+        const adapter = await sessionFor(runtime);
+        try {
+            return await adapter[command](args);
+        }
+        catch (error) {
+            if (!isRecoverableSessionCacheError(error)) {
+                throw error;
+            }
+            await discardSession(runtime);
+            const freshAdapter = await sessionFor(runtime);
+            return freshAdapter[command](args);
+        }
+    }
+    function enqueue(work) {
+        const run = queue.then(work, work).catch((error) => {
+            lastError = errorMessage(error);
+            throw error;
+        });
+        queue = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    const server = net.createServer((socket) => {
+        let input = '';
+        socket.on('data', (chunk) => {
+            input += chunk.toString('utf8');
+            if (!input.includes('\n')) {
+                return;
+            }
+            socket.pause();
+            void (async () => {
+                let response;
+                try {
+                    const request = JSON.parse(input);
+                    if (request.type === 'status') {
+                        response = {
+                            ok: true,
+                            data: {
+                                activeOperation,
+                                lastError,
+                                sessions: Array.from(sessions.entries()).map(([key, entry]) => ({
+                                    key,
+                                    runtime: entry.runtime,
+                                    createdAt: entry.createdAt
+                                }))
+                            }
+                        };
+                    }
+                    else if (request.type === 'stop') {
+                        await closeSessions();
+                        response = {
+                            ok: true,
+                            data: {
+                                running: false,
+                                sessionsClosed: true,
+                                appiumStarted: options.appiumStarted
+                            }
+                        };
+                        socket.end(`${JSON.stringify(response)}\n`, () => {
+                            server.close(() => {
+                                process.exit(0);
+                            });
+                        });
+                        return;
+                    }
+                    else if (request.type === 'action') {
+                        const data = await enqueue(async () => {
+                            activeOperation = `${request.command}:${runtimeKey(request.runtime)}`;
+                            try {
+                                return await runActionWithSessionRetry(request.runtime, request.command, request.args);
+                            }
+                            finally {
+                                activeOperation = null;
+                            }
+                        });
+                        response = { ok: true, data };
+                    }
+                    else {
+                        const data = await enqueue(async () => {
+                            activeOperation = `scenario:${runtimeKey(request.runtime)}`;
+                            try {
+                                const adapter = await sessionFor(request.runtime);
+                                return await runScenario(request.scenario, adapter, request.device, request.timeout, request.outputDir, false);
+                            }
+                            finally {
+                                activeOperation = null;
+                            }
+                        });
+                        response = { ok: true, data };
+                    }
+                }
+                catch (error) {
+                    response = { ok: false, error: errorMessage(error) };
+                }
+                socket.end(`${JSON.stringify(response)}\n`);
+            })();
+        });
+    });
+    process.on('SIGTERM', () => {
+        void closeSessions().finally(() => {
+            server.close();
+        });
+    });
+    if (process.platform !== 'win32' && fs.existsSync(socketPath())) {
+        fs.unlinkSync(socketPath());
+    }
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(socketPath(), () => {
+            server.off('error', reject);
+            resolve();
+        });
+    });
+    await new Promise((resolve) => {
+        server.once('close', resolve);
+    });
+}

package/dist/devices.js

@@ -0,0 +1,123 @@
+import { execFile } from 'node:child_process';
+import { createInterface } from 'node:readline/promises';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+export class DeviceSelectionError extends Error {
+    devices;
+    constructor(message, devices = []) {
+        super(message);
+        this.name = 'DeviceSelectionError';
+        this.devices = devices;
+    }
+}
+async function defaultDeviceCommandRunner(command, args) {
+    const { stdout } = await execFileAsync(command, args);
+    return stdout.toString();
+}
+let deviceCommandRunner = defaultDeviceCommandRunner;
+export function setDeviceCommandRunner(runner) {
+    deviceCommandRunner = runner;
+}
+export function resetDeviceCommandRunner() {
+    deviceCommandRunner = defaultDeviceCommandRunner;
+}
+export function deviceLabel(device) {
+    return `${device.name} (${device.id}, ${device.platform})`;
+}
+export function parseAndroidDevices(output) {
+    return output
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith('List of devices attached'))
+        .flatMap((line) => {
+        const [id, state] = line.split(/\s+/);
+        if (!id || state !== 'device') {
+            return [];
+        }
+        return [{ platform: 'android', id, name: id }];
+    });
+}
+export function parseIosBootedDevices(output) {
+    return output
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .flatMap((line) => {
+        const match = line.match(/^(.+?)\s+\(([0-9a-fA-F-]{8,})\)\s+\(Booted\)$/);
+        if (!match) {
+            return [];
+        }
+        return [{ platform: 'ios', id: match[2], name: match[1] }];
+    });
+}
+async function discoverAndroidDevices() {
+    try {
+        const stdout = await deviceCommandRunner('adb', ['devices']);
+        return parseAndroidDevices(stdout);
+    }
+    catch {
+        return [];
+    }
+}
+async function discoverIosDevices() {
+    try {
+        const stdout = await deviceCommandRunner('xcrun', ['simctl', 'list', 'devices', 'booted']);
+        return parseIosBootedDevices(stdout);
+    }
+    catch {
+        return [];
+    }
+}
+export async function discoverRunningDevices() {
+    const [android, ios] = await Promise.all([discoverAndroidDevices(), discoverIosDevices()]);
+    return [...android, ...ios];
+}
+function matchesDevice(device, requested) {
+    return device.id === requested || device.name === requested;
+}
+function deviceListForError(devices) {
+    if (devices.length === 0) {
+        return 'No running Android devices or booted iOS simulators were detected.';
+    }
+    return `Detected devices: ${devices.map(deviceLabel).join('; ')}`;
+}
+async function promptForDevice(devices, io) {
+    if (!io.input.isTTY || !io.output.isTTY) {
+        throw new DeviceSelectionError(`${deviceListForError(devices)} Specify one with --device.`, devices);
+    }
+    io.output.write('Multiple running devices detected:\n');
+    devices.forEach((device, index) => {
+        io.output.write(`  ${index + 1}. ${deviceLabel(device)}\n`);
+    });
+    const readline = createInterface({ input: io.input, output: io.output });
+    try {
+        const answer = (await readline.question('Select device number: ')).trim();
+        const selectedIndex = Number(answer);
+        if (!Number.isInteger(selectedIndex) || selectedIndex < 1 || selectedIndex > devices.length) {
+            throw new DeviceSelectionError(`Invalid device selection '${answer}'. Specify one with --device.`, devices);
+        }
+        return devices[selectedIndex - 1];
+    }
+    finally {
+        readline.close();
+    }
+}
+export async function resolveRunningDevice(requestedDevice, io = { input: process.stdin, output: process.stderr }) {
+    const devices = await discoverRunningDevices();
+    if (requestedDevice) {
+        const matches = devices.filter((device) => matchesDevice(device, requestedDevice));
+        if (matches.length === 1) {
+            return matches[0];
+        }
+        if (matches.length > 1) {
+            throw new DeviceSelectionError(`Device '${requestedDevice}' matches multiple running devices. ${deviceListForError(matches)}`, matches);
+        }
+        throw new DeviceSelectionError(`Device '${requestedDevice}' is not running or could not be detected. ${deviceListForError(devices)}`, devices);
+    }
+    if (devices.length === 1) {
+        return devices[0];
+    }
+    if (devices.length === 0) {
+        throw new DeviceSelectionError('No running Android devices or booted iOS simulators were detected. Start a target device or pass --device for a detected running target.', devices);
+    }
+    return promptForDevice(devices, io);
+}

package/dist/main.js

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { executeCommand } from './cli.js';
+import { runDaemonFromEnv } from './daemon.js';
 import { makeError } from './errors.js';
 import { makeId, utcNowIso } from './utils.js';
 function isHelpData(value) {
@@ -13,6 +14,10 @@ function isHelpData(value) {
 }
 async function main(argv = process.argv.slice(2)) {
     try {
+        if (argv[0] === '__daemon') {
+            await runDaemonFromEnv();
+            return 0;
+        }
         const result = await executeCommand(argv);
         if (isHelpData(result.response.data)) {
             console.log(result.response.data.usageText);

package/dist/runner.js

@@ -61,10 +61,10 @@ function signatureSafeDetails(details) {
     }
     return safe;
 }
-export async function runScenario(scenario, adapter, device = 'local', timeoutMs, artifactBaseDir) {
+export async function runScenario(scenario, adapter, device = 'local', timeoutMs, artifactBaseDir, closeAdapter = true) {
     const started_at = utcNowIso();
     const run_id = makeId('run');
-    const platform = scenario.meta.platform;
+    const platform = adapter.capability().platform;
     const stepResults = [];
     const artifacts = [];
     let topError;
@@ -166,7 +166,9 @@ export async function runScenario(scenario, adapter, device = 'local', timeoutMs
         };
     }
     finally {
-        await adapter.close();
+        if (closeAdapter) {
+            await adapter.close();
+        }
     }
 }
 export function determinismCheck(signatures) {