visor-ai 0.2.7 → 0.2.9

package/dist/daemon.js

@@ -4,6 +4,7 @@ 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 { createAppMapContext, createMapSummary, discoverAppMap, persistAppMapContext, runMappedCommand } from './appMap.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';
@@ -19,6 +20,22 @@ export class DaemonRequestTimeoutError extends Error {
         this.name = 'DaemonRequestTimeoutError';
     }
 }
+export class DaemonOperationError extends Error {
+    data;
+    constructor(message, data) {
+        super(message);
+        this.name = 'DaemonOperationError';
+        this.data = data;
+    }
+}
+class DaemonResponseError extends Error {
+    data;
+    constructor(message, data) {
+        super(message);
+        this.name = 'DaemonResponseError';
+        this.data = data;
+    }
+}
 function daemonDir() {
     return ensureDir(path.join(process.cwd(), '.visor', 'daemon'));
 }
@@ -139,7 +156,7 @@ async function requestDaemon(request, timeoutMs = 1000) {
 async function daemonRequestData(request, timeoutMs = 1000) {
     const response = await requestDaemon(request, timeoutMs);
     if (!response.ok) {
-        throw new Error(response.error);
+        throw new DaemonOperationError(response.error, response.data);
     }
     return response.data;
 }
@@ -343,11 +360,14 @@ export async function stopVisorDaemon(serverUrl = DEFAULT_SERVER_URL, force = fa
         appium: await statusManagedAppium(serverUrl)
     };
 }
-export async function runDaemonAction(runtime, command, args) {
-    return daemonRequestData({ type: 'action', runtime, command, args }, 300000);
+export async function runDaemonAction(runtime, command, args, mapOptions) {
+    return daemonRequestData({ type: 'action', runtime, command, args, mapOptions }, 300000);
 }
-export async function runDaemonScenario(runtime, scenario, device, timeout, outputDir) {
-    return daemonRequestData({ type: 'scenario', runtime, scenario, device, timeout, outputDir }, 600000);
+export async function runDaemonScenario(runtime, scenario, device, timeout, outputDir, mapOptions) {
+    return daemonRequestData({ type: 'scenario', runtime, scenario, device, timeout, outputDir, mapOptions }, 600000);
+}
+export async function runDaemonDiscover(runtime, mapOptions) {
+    return daemonRequestData({ type: 'discover', runtime, mapOptions }, 300000);
 }
 export async function runDaemonFromEnv() {
     const options = {
@@ -398,10 +418,10 @@ export async function runDaemonFromEnv() {
             // The backing WebDriver session is already gone; removing it from the cache is enough.
         }
     }
-    async function runActionWithSessionRetry(runtime, command, args) {
+    async function runActionWithSessionRetry(runtime, command, args, mapOptions) {
         const adapter = await sessionFor(runtime);
         try {
-            return await adapter[command](args);
+            return await runActionWithMap(adapter, command, args, mapOptions);
         }
         catch (error) {
             if (!isRecoverableSessionCacheError(error)) {
@@ -409,7 +429,46 @@ export async function runDaemonFromEnv() {
             }
             await discardSession(runtime);
             const freshAdapter = await sessionFor(runtime);
-            return freshAdapter[command](args);
+            return runActionWithMap(freshAdapter, command, args, mapOptions);
+        }
+    }
+    async function runActionWithMap(adapter, command, args, mapOptions) {
+        const options = mapOptions;
+        const context = createAppMapContext(adapter, options);
+        if (!context) {
+            const summary = createMapSummary(adapter, options);
+            try {
+                const details = await adapter[command](args);
+                return {
+                    ...details,
+                    map: summary
+                };
+            }
+            catch (error) {
+                throw new DaemonResponseError(errorMessage(error), {
+                    map: summary
+                });
+            }
+        }
+        try {
+            const details = await runMappedCommand(context, command, args);
+            const stepMap = details.map && typeof details.map === 'object' ? details.map : {};
+            const summary = persistAppMapContext(context);
+            return {
+                ...details,
+                map: {
+                    ...summary,
+                    ...stepMap
+                }
+            };
+        }
+        catch (error) {
+            throw new DaemonResponseError(errorMessage(error), {
+                map: persistAppMapContext(context)
+            });
+        }
+        finally {
+            persistAppMapContext(context);
         }
     }
     function enqueue(work) {
@@ -463,11 +522,24 @@ export async function runDaemonFromEnv() {
                         });
                         return;
                     }
+                    else if (request.type === 'discover') {
+                        const data = await enqueue(async () => {
+                            activeOperation = `discover:${runtimeKey(request.runtime)}`;
+                            try {
+                                const adapter = await sessionFor(request.runtime);
+                                return await discoverAppMap(adapter, request.mapOptions);
+                            }
+                            finally {
+                                activeOperation = null;
+                            }
+                        });
+                        response = { ok: true, data };
+                    }
                     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);
+                                return await runActionWithSessionRetry(request.runtime, request.command, request.args, request.mapOptions);
                             }
                             finally {
                                 activeOperation = null;
@@ -480,7 +552,7 @@ export async function runDaemonFromEnv() {
                             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);
+                                return await runScenario(request.scenario, adapter, request.device, request.timeout, request.outputDir, false, request.mapOptions);
                             }
                             finally {
                                 activeOperation = null;
@@ -490,7 +562,11 @@ export async function runDaemonFromEnv() {
                     }
                 }
                 catch (error) {
-                    response = { ok: false, error: errorMessage(error) };
+                    response = {
+                        ok: false,
+                        error: errorMessage(error),
+                        data: error instanceof DaemonResponseError ? error.data : undefined
+                    };
                 }
                 socket.end(`${JSON.stringify(response)}\n`);
             })();

package/dist/localRuntime.js

@@ -0,0 +1,124 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const TINY_PNG = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMB/axDRf0AAAAASUVORK5CYII=', 'base64');
+function resolveArtifactPath(args, extension, fallbackLabel) {
+    const label = String(args.label ?? fallbackLabel);
+    return path.resolve(typeof args.path === 'string' ? args.path : `${label}.${extension}`);
+}
+function targetValue(target) {
+    const separatorIndex = target.indexOf('=');
+    return separatorIndex === -1 ? target : target.slice(separatorIndex + 1);
+}
+export class LocalRuntimeAdapter {
+    counter = 0;
+    route = 'app://home';
+    capability() {
+        return {
+            platform: 'android',
+            commands: ['navigate', 'tap', 'act', 'scroll', 'screenshot', 'wait', 'source']
+        };
+    }
+    async navigate(args) {
+        this.route = String(args.to ?? this.route);
+        return {
+            action: 'navigate',
+            platform: 'android',
+            args: { to: this.route }
+        };
+    }
+    async tap(args) {
+        const target = String(args.target ?? '');
+        if (targetValue(target) === 'Increment') {
+            this.counter += 1;
+        }
+        return {
+            action: 'tap',
+            platform: 'android',
+            args: { target }
+        };
+    }
+    async act(args) {
+        const name = String(args.name ?? '');
+        if (name === 'reset') {
+            this.counter = 0;
+            this.route = 'app://home';
+        }
+        if (name === 'home') {
+            this.route = 'app://home';
+        }
+        return {
+            action: 'act',
+            platform: 'android',
+            args
+        };
+    }
+    async scroll(args) {
+        return {
+            action: 'scroll',
+            platform: 'android',
+            args: {
+                direction: args.direction ?? 'down',
+                percent: args.percent ?? 70
+            }
+        };
+    }
+    async screenshot(args) {
+        const label = String(args.label ?? 'capture');
+        const filePath = resolveArtifactPath(args, 'png', label);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, TINY_PNG);
+        return {
+            action: 'screenshot',
+            platform: 'android',
+            args: {
+                label,
+                file: path.basename(filePath),
+                path: filePath,
+                width: 1,
+                height: 1
+            }
+        };
+    }
+    async wait(args) {
+        return {
+            action: 'wait',
+            platform: 'android',
+            args: { ms: Number(args.ms ?? 0) }
+        };
+    }
+    async source(args) {
+        const label = String(args.label ?? 'source');
+        const filePath = resolveArtifactPath(args, 'xml', label);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        const content = this.sourceXml();
+        fs.writeFileSync(filePath, content, 'utf8');
+        return {
+            action: 'source',
+            platform: 'android',
+            args: {
+                label,
+                file: path.basename(filePath),
+                path: filePath,
+                format: 'xml',
+                bytes: Buffer.byteLength(content, 'utf8')
+            }
+        };
+    }
+    async exists(target) {
+        const value = targetValue(target);
+        return value === 'Increment' || value === String(this.counter) || this.sourceXml().includes(value);
+    }
+    async close() {
+        return undefined;
+    }
+    sourceXml() {
+        return [
+            '<hierarchy>',
+            `  <node text="Route: ${this.route}" />`,
+            `  <node text="${this.counter}" label="${this.counter}" name="${this.counter}" value="${this.counter}" />`,
+            '  <node text="Increment" content-desc="Increment" label="Increment" name="Increment" />',
+            '</hierarchy>',
+            ''
+        ].join('\n');
+    }
+}

package/dist/runner.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
+import { createAppMapContext, createMapSummary, persistAppMapContext, runMappedCommand } from './appMap.js';
 import { makeError } from './errors.js';
 import { makeId, signatureFor, utcNowIso } from './utils.js';
 async function runStep(adapter, command, args) {
@@ -59,15 +60,32 @@ function signatureSafeDetails(details) {
     if (args && typeof args === 'object' && !Array.isArray(args)) {
         delete args.path;
     }
+    const map = safe.map;
+    if (map && typeof map === 'object' && !Array.isArray(map)) {
+        const mapDetails = map;
+        const route = Array.isArray(mapDetails.route)
+            ? mapDetails.route
+                .filter((step) => Boolean(step) && typeof step === 'object' && !Array.isArray(step))
+                .map((step) => ({
+                command: step.command,
+                target: step.target
+            }))
+            : [];
+        safe.map = {
+            route
+        };
+    }
     return safe;
 }
-export async function runScenario(scenario, adapter, device = 'local', timeoutMs, artifactBaseDir, closeAdapter = true) {
+export async function runScenario(scenario, adapter, device = 'local', timeoutMs, artifactBaseDir, closeAdapter = true, mapOptions) {
     const started_at = utcNowIso();
     const run_id = makeId('run');
     const platform = adapter.capability().platform;
     const stepResults = [];
     const artifacts = [];
     let topError;
+    const mapContext = createAppMapContext(adapter, mapOptions);
+    const disabledMapSummary = mapContext ? undefined : createMapSummary(adapter, mapOptions);
     let screenshotDir;
     let sourceDir;
     if (artifactBaseDir) {
@@ -89,7 +107,9 @@ export async function runScenario(scenario, adapter, device = 'local', timeoutMs
                     const label = String(stepArgs.label ?? step.id);
                     stepArgs.path = path.join(sourceDir, `${label}.xml`);
                 }
-                const details = await runStep(adapter, step.command, stepArgs);
+                const details = mapContext
+                    ? await runMappedCommand(mapContext, step.command, stepArgs)
+                    : await runStep(adapter, step.command, stepArgs);
                 const durationMs = Math.round(performance.now() - started);
                 const result = {
                     id: step.id,
@@ -140,6 +160,7 @@ export async function runScenario(scenario, adapter, device = 'local', timeoutMs
         }
         const allPass = stepsOk && assertionEvaluation.ok;
         const ended_at = utcNowIso();
+        const mapSummary = persistAppMapContext(mapContext) ?? disabledMapSummary;
         const signatureInput = {
             platform,
             steps: stepResults.map((step) => ({
@@ -162,10 +183,12 @@ export async function runScenario(scenario, adapter, device = 'local', timeoutMs
             artifacts,
             determinism_signature: signatureFor(signatureInput),
             seed: typeof scenario.config.seed === 'number' ? scenario.config.seed : undefined,
+            map: mapSummary,
             error: topError
         };
     }
     finally {
+        persistAppMapContext(mapContext);
         if (closeAdapter) {
             await adapter.close();
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "visor-ai",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Visor CLI for LLM-driven mobile app interaction and artifact capture",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,9 @@
     "build": "rm -rf dist && tsc -p tsconfig.json",
     "dev": "tsx src/main.ts",
     "test": "vitest run",
+    "test:e2e:local": "node scripts/local-e2e.mjs",
     "check": "npm run build && npm run test",
+    "verify": "npm run build && npm run test && npm run test:e2e:local",
     "release": "node scripts/release.mjs",
     "release:patch": "node scripts/release.mjs patch",
     "release:minor": "node scripts/release.mjs minor",
@@ -51,6 +53,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.13.10",
+    "appium-uiautomator2-driver": "^4.2.9",
     "appium-xcuitest-driver": "^9.10.5",
     "tsx": "^4.19.3",
     "typescript": "^5.8.2",