visor-ai 0.2.8 → 0.2.9

package/dist/adapters.js

@@ -10,6 +10,7 @@ export const ELEMENT_ID = 'id';
 export const ANDROID_UIAUTOMATOR = '-android uiautomator';
 export const IOS_PREDICATE = '-ios predicate string';
 export const IOS_CLASS_CHAIN = '-ios class chain';
+const TEXT_ATTRIBUTES = ['text', 'content-desc', 'label', 'name', 'value'];
 function env(preferred, legacy, defaultValue) {
     return process.env[preferred] ?? process.env[legacy] ?? defaultValue;
 }
@@ -48,6 +49,38 @@ function pngDimensions(filePath) {
         return { width: null, height: null };
     }
 }
+function validateRect(rect) {
+    const candidate = rect && typeof rect === 'object' && !Array.isArray(rect)
+        ? rect
+        : {};
+    const x = Number(candidate.x);
+    const y = Number(candidate.y);
+    const width = Number(candidate.width);
+    const height = Number(candidate.height);
+    if (![x, y, width, height].every(Number.isFinite) || width <= 0 || height <= 0) {
+        throw new Error('Element rectangle is invalid');
+    }
+    return { x, y, width, height };
+}
+function xpathLiteral(value) {
+    if (!value.includes("'")) {
+        return `'${value}'`;
+    }
+    if (!value.includes('"')) {
+        return `"${value}"`;
+    }
+    return `concat(${value
+        .split("'")
+        .map((part) => `'${part}'`)
+        .join(', "\"\'\"", ')})`;
+}
+function textXPath(value, mode) {
+    const literal = xpathLiteral(value);
+    const clauses = TEXT_ATTRIBUTES.map((attribute) => mode === 'exact'
+        ? `@${attribute} = ${literal}`
+        : `contains(@${attribute}, ${literal})`);
+    return `//*[${clauses.join(' or ')}]`;
+}
 export function formatDriverCreationError(platform, appId, attachToRunning, error) {
     const message = errorMessage(error);
     if (platform === 'ios' && message.includes('bundle identifier') && message.includes('unknown')) {
@@ -63,28 +96,30 @@ export function formatDriverCreationError(platform, appId, attachToRunning, erro
     return `Failed to create WebdriverIO Appium session: ${message}`;
 }
 export function parseTarget(target) {
+    const valueAfterPrefix = () => target.slice(target.indexOf('=') + 1);
+    if (target.startsWith('text~=')) {
+        return [XPATH, textXPath(valueAfterPrefix(), 'contains')];
+    }
     if (target.startsWith('text=')) {
-        const value = target.split('=', 2)[1] ?? '';
-        const xpath = `//*[contains(@text, '${value}') or contains(@content-desc, '${value}') or contains(@label, '${value}') or contains(@name, '${value}') or contains(@value, '${value}')]`;
-        return [XPATH, xpath];
+        return [XPATH, textXPath(valueAfterPrefix(), 'exact')];
     }
     if (target.startsWith('id=')) {
-        return [ELEMENT_ID, target.split('=', 2)[1] ?? ''];
+        return [ELEMENT_ID, valueAfterPrefix()];
     }
     if (target.startsWith('xpath=')) {
-        return [XPATH, target.split('=', 2)[1] ?? ''];
+        return [XPATH, valueAfterPrefix()];
     }
     if (target.startsWith('uiautomator=')) {
-        return [ANDROID_UIAUTOMATOR, target.split('=', 2)[1] ?? ''];
+        return [ANDROID_UIAUTOMATOR, valueAfterPrefix()];
     }
     if (target.startsWith('predicate=')) {
-        return [IOS_PREDICATE, target.split('=', 2)[1] ?? ''];
+        return [IOS_PREDICATE, valueAfterPrefix()];
     }
     if (target.startsWith('classchain=')) {
-        return [IOS_CLASS_CHAIN, target.split('=', 2)[1] ?? ''];
+        return [IOS_CLASS_CHAIN, valueAfterPrefix()];
     }
     if (target.startsWith('accessibility=')) {
-        return [ACCESSIBILITY_ID, target.split('=', 2)[1] ?? ''];
+        return [ACCESSIBILITY_ID, valueAfterPrefix()];
     }
     return [ACCESSIBILITY_ID, target];
 }
@@ -194,7 +229,7 @@ export class RealAppiumAdapter {
         const target = String(args.target);
         const selector = selectorForTarget(target);
         const element = await this.requireDriver().$(selector.selector);
-        await element.click();
+        await this.tapElementCenter(element);
         return {
             action: 'tap',
             platform: this.platform,
@@ -224,7 +259,52 @@ export class RealAppiumAdapter {
                 args: { name }
             };
         }
-        throw new Error('Unsupported act operation; use --name type --target <selector> --value <text> or --name back');
+        if (name === 'drag') {
+            const gesture = await this.resolveDragGesture(args);
+            await this.dragPointer(gesture.start, gesture.end);
+            return {
+                action: 'act',
+                platform: this.platform,
+                args: {
+                    name,
+                    startX: gesture.start.x,
+                    startY: gesture.start.y,
+                    endX: gesture.end.x,
+                    endY: gesture.end.y
+                }
+            };
+        }
+        if (name === 'slider') {
+            const gesture = await this.resolveSliderGesture(args);
+            await this.dragPointer(gesture.start, gesture.end);
+            return {
+                action: 'act',
+                platform: this.platform,
+                args: {
+                    name,
+                    target,
+                    value: gesture.value,
+                    startValue: gesture.startValue
+                }
+            };
+        }
+        if (name === 'home') {
+            await this.pressHome();
+            return {
+                action: 'act',
+                platform: this.platform,
+                args: { name }
+            };
+        }
+        if (name === 'reset') {
+            await this.resetApp();
+            return {
+                action: 'act',
+                platform: this.platform,
+                args: { name, app_id: this.appId }
+            };
+        }
+        throw new Error('Unsupported act operation; use --name type --target <selector> --value <text>, --name drag, --name slider, --name back, --name home, or --name reset');
     }
     async scroll(args) {
         const { direction, percent, gesturePercent } = resolveScrollOptions(args);
@@ -382,6 +462,98 @@ export class RealAppiumAdapter {
         }
         throw new Error(`Coordinate tap is unsupported for platform: ${this.platform}`);
     }
+    async tapElementCenter(element) {
+        try {
+            const rect = await this.elementRect(element);
+            const x = Math.round(rect.x + rect.width / 2);
+            const y = Math.round(rect.y + rect.height / 2);
+            await this.tapPoint(x, y);
+        }
+        catch {
+            await element.click();
+        }
+    }
+    async elementRect(element) {
+        if (typeof element.getRect === 'function') {
+            const rect = await element.getRect();
+            return validateRect(rect);
+        }
+        if (typeof element.getLocation === 'function' && typeof element.getSize === 'function') {
+            const location = await element.getLocation();
+            const size = await element.getSize();
+            return validateRect({
+                x: location.x,
+                y: location.y,
+                width: size.width,
+                height: size.height
+            });
+        }
+        throw new Error('Element rectangle is unavailable');
+    }
+    async pressHome() {
+        const driver = this.requireDriver();
+        if (this.platform === 'ios') {
+            await driver.execute('mobile: pressButton', { name: 'home' });
+            return;
+        }
+        if (typeof driver.pressKeyCode === 'function') {
+            await driver.pressKeyCode(3);
+            return;
+        }
+        await driver.execute('mobile: pressKey', { keycode: 3 });
+    }
+    async resetApp() {
+        if (!this.appId) {
+            throw new Error('act reset requires --app-id so Visor can restart the target app');
+        }
+        const driver = this.requireDriver();
+        if (typeof driver.terminateApp === 'function') {
+            await driver.terminateApp(this.appId);
+        }
+        else {
+            await driver.execute('mobile: terminateApp', this.platform === 'ios' ? { bundleId: this.appId } : { appId: this.appId });
+        }
+        await sleep(500);
+        if (typeof driver.activateApp === 'function') {
+            await driver.activateApp(this.appId);
+            return;
+        }
+        await driver.execute('mobile: activateApp', this.platform === 'ios' ? { bundleId: this.appId } : { appId: this.appId });
+    }
+    async resolveDragGesture(args) {
+        const normalized = Boolean(args.normalized);
+        const size = normalized ? await this.requireDriver().getWindowSize() : null;
+        const start = {
+            x: gestureNumber(args, ['startX', 'start-x', 'fromX', 'from-x'], 'act drag requires startX/startY and endX/endY'),
+            y: gestureNumber(args, ['startY', 'start-y', 'fromY', 'from-y'], 'act drag requires startX/startY and endX/endY')
+        };
+        const end = {
+            x: gestureNumber(args, ['endX', 'end-x', 'toX', 'to-x'], 'act drag requires startX/startY and endX/endY'),
+            y: gestureNumber(args, ['endY', 'end-y', 'toY', 'to-y'], 'act drag requires startX/startY and endX/endY')
+        };
+        return {
+            start: normalized && size ? scalePoint(start, size.width, size.height) : roundPoint(start),
+            end: normalized && size ? scalePoint(end, size.width, size.height) : roundPoint(end)
+        };
+    }
+    async resolveSliderGesture(args) {
+        const target = typeof args.target === 'string' ? args.target : '';
+        if (!target) {
+            throw new Error('act slider requires args.target');
+        }
+        const value = unitIntervalNumber(args.value, 'act slider args.value must be a number between 0 and 1');
+        const startValue = unitIntervalNumber(args.startValue ?? args['start-value'] ?? 0.5, 'act slider args.startValue must be a number between 0 and 1');
+        const selector = selectorForTarget(target);
+        const element = await this.requireDriver().$(selector.selector);
+        const rect = await this.elementRect(element);
+        const y = Math.round(rect.y + rect.height / 2);
+        return {
+            start: { x: Math.round(rect.x + rect.width * startValue), y },
+            end: { x: Math.round(rect.x + rect.width * value), y },
+            value,
+            startValue
+        };
+    }
     async scrollViewport(direction, gesturePercent) {
         const driver = this.requireDriver();
         const size = await driver.getWindowSize();
@@ -419,31 +591,61 @@ export class RealAppiumAdapter {
         }
         throw new Error(`Scroll is unsupported for platform: ${this.platform}`);
     }
-    async swipeViewport(direction, gesturePercent, viewportWidth, viewportHeight) {
+    async dragPointer(start, end) {
         const driver = this.requireDriver();
-        const x = Math.round(viewportWidth / 2);
-        const lowY = Math.round(viewportHeight * 0.75);
-        const highY = Math.round(viewportHeight * 0.25);
-        const travel = Math.max(1, Math.round(viewportHeight * gesturePercent));
-        const startY = direction === 'down' ? lowY : highY;
-        const unclampedEndY = direction === 'down' ? startY - travel : startY + travel;
-        const endY = Math.max(1, Math.min(viewportHeight - 1, unclampedEndY));
         await driver.performActions([
             {
                 type: 'pointer',
                 id: 'finger1',
                 parameters: { pointerType: 'touch' },
                 actions: [
-                    { type: 'pointerMove', duration: 0, x, y: startY },
+                    { type: 'pointerMove', duration: 0, x: start.x, y: start.y },
                     { type: 'pointerDown', button: 0 },
-                    { type: 'pause', duration: 150 },
-                    { type: 'pointerMove', duration: 400, x, y: endY },
+                    { type: 'pause', duration: 100 },
+                    { type: 'pointerMove', duration: 400, x: end.x, y: end.y },
                     { type: 'pointerUp', button: 0 }
                 ]
             }
         ]);
         await driver.releaseActions();
     }
+    async swipeViewport(direction, gesturePercent, viewportWidth, viewportHeight) {
+        const x = Math.round(viewportWidth / 2);
+        const lowY = Math.round(viewportHeight * 0.75);
+        const highY = Math.round(viewportHeight * 0.25);
+        const travel = Math.max(1, Math.round(viewportHeight * gesturePercent));
+        const startY = direction === 'down' ? lowY : highY;
+        const unclampedEndY = direction === 'down' ? startY - travel : startY + travel;
+        const endY = Math.max(1, Math.min(viewportHeight - 1, unclampedEndY));
+        await this.dragPointer({ x, y: startY }, { x, y: endY });
+    }
+}
+function gestureNumber(args, keys, message) {
+    const raw = keys.map((key) => args[key]).find((value) => value !== undefined);
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed)) {
+        throw new Error(message);
+    }
+    return parsed;
+}
+function unitIntervalNumber(value, message) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 0 || parsed > 1) {
+        throw new Error(message);
+    }
+    return parsed;
+}
+function scalePoint(point, width, height) {
+    return {
+        x: Math.round(point.x * width),
+        y: Math.round(point.y * height)
+    };
+}
+function roundPoint(point) {
+    return {
+        x: Math.round(point.x),
+        y: Math.round(point.y)
+    };
 }
 export async function getAdapter(platform, serverUrl = DEFAULT_SERVER_URL, device, appId, attachToRunning = false) {
     const normalized = platform.toLowerCase();