wuying-agentbay-sdk 0.1.0 → 0.4.0

package/dist/tests/unit/ui.test.js

@@ -1,158 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const src_1 = require("../../src");
-const test_helpers_1 = require("../utils/test-helpers");
-const logger_1 = require("../../src/utils/logger");
-// Helper function to parse content array from API response for UI elements
-function parseUIContent(content) {
-    if (!Array.isArray(content) || content.length === 0) {
-        return [];
-    }
-    // Try to extract and parse text from the first content item
-    const item = content[0];
-    if (item && typeof item === 'object' && item.text && typeof item.text === 'string') {
-        try {
-            return JSON.parse(item.text);
-        }
-        catch (e) {
-            (0, logger_1.log)(`Warning: Failed to parse content text as JSON: ${e}`);
-            return [];
-        }
-    }
-    return [];
-}
-// Helper function to check if a content array contains base64 image data
-function containsBase64Image(content) {
-    if (!Array.isArray(content) || content.length === 0) {
-        return false;
-    }
-    // Look for base64 image data in the text fields
-    return content.some(item => item && typeof item === 'object' &&
-        typeof item.text === 'string' &&
-        (item.text.startsWith('data:image') || item.text.includes('base64')));
-}
-// Type declarations are now in tests/jest.d.ts
-describe('UI', () => {
-    let agentBay;
-    let session;
-    beforeEach(async () => {
-        const apiKey = (0, test_helpers_1.getTestApiKey)();
-        agentBay = new src_1.AgentBay({ apiKey });
-        // Create a session with mobile_latest image (consistent with Go implementation)
-        (0, logger_1.log)('Creating a new session for UI testing...');
-        session = await agentBay.create({ imageId: 'mobile_latest' });
-        (0, logger_1.log)(`Session created with ID: ${session.sessionId}`);
-    });
-    afterEach(async () => {
-        // Clean up the session
-        try {
-            await agentBay.delete(session);
-            (0, logger_1.log)(`Session deleted successfully: ${session.sessionId}`);
-        }
-        catch (error) {
-            (0, logger_1.log)(`Warning: Error deleting session: ${error}`);
-        }
-    });
-    describe('getClickableUIElements', () => {
-        it.only('should retrieve clickable UI elements if implemented', async () => {
-            if (session.ui && typeof session.ui.getClickableUIElements === 'function') {
-                (0, logger_1.log)('Testing UI.getClickableUIElements method...');
-                try {
-                    const content = await session.ui.getClickableUIElements();
-                    (0, logger_1.log)(`Retrieved content:`, content);
-                    // Verify the content
-                    expect(content).toBeDefined();
-                    expect(Array.isArray(content)).toBe(true);
-                    // Try to parse UI elements from content
-                    const elements = parseUIContent(content);
-                    (0, logger_1.log)(`Parsed ${elements.length} clickable UI elements`);
-                    // Additional checks on parsed elements if available
-                    if (elements.length > 0) {
-                        (0, logger_1.log)('First UI element:', elements[0]);
-                    }
-                }
-                catch (error) {
-                    (0, logger_1.log)(`Note: UI.getClickableUIElements execution failed: ${error}`);
-                    // Don't fail the test if the method is not fully implemented
-                }
-            }
-            else {
-                (0, logger_1.log)('Note: UI.getClickableUIElements method is not available, skipping test');
-            }
-        });
-    });
-    describe('getAllUIElements', () => {
-        it.only('should retrieve all UI elements if implemented', async () => {
-            if (session.ui && typeof session.ui.getAllUIElements === 'function') {
-                (0, logger_1.log)('Testing UI.getAllUIElements method...');
-                try {
-                    const content = await session.ui.getAllUIElements();
-                    (0, logger_1.log)(`Retrieved content:`, content);
-                    // Verify the content
-                    expect(content).toBeDefined();
-                    expect(Array.isArray(content)).toBe(true);
-                    // Try to parse UI elements from content
-                    const elements = parseUIContent(content);
-                    (0, logger_1.log)(`Parsed ${elements.length} UI elements`);
-                    // Log the first element if available
-                    if (elements.length > 0) {
-                        (0, logger_1.log)('First UI element:', elements[0]);
-                    }
-                }
-                catch (error) {
-                    (0, logger_1.log)(`Note: UI.getAllUIElements execution failed: ${error}`);
-                    // Don't fail the test if the method is not fully implemented
-                }
-            }
-            else {
-                (0, logger_1.log)('Note: UI.getAllUIElements method is not available, skipping test');
-            }
-        });
-    });
-    describe('sendKey', () => {
-        it.only('should send key events if implemented', async () => {
-            if (session.ui && typeof session.ui.sendKey === 'function') {
-                (0, logger_1.log)('Testing UI.sendKey method...');
-                try {
-                    // Try to send HOME key
-                    const content = await session.ui.sendKey(3); // HOME key
-                    (0, logger_1.log)(`Send key content:`, content);
-                    // Verify the content
-                    expect(content).toBeDefined();
-                    expect(Array.isArray(content)).toBe(true);
-                }
-                catch (error) {
-                    (0, logger_1.log)(`Note: UI.sendKey execution failed: ${error}`);
-                    // Don't fail the test if the method is not fully implemented
-                }
-            }
-            else {
-                (0, logger_1.log)('Note: UI.sendKey method is not available, skipping test');
-            }
-        });
-    });
-    describe('screenshot', () => {
-        it.only('should take screenshots if implemented', async () => {
-            if (session.ui && typeof session.ui.screenshot === 'function') {
-                (0, logger_1.log)('Testing UI.screenshot method...');
-                try {
-                    const content = await session.ui.screenshot();
-                    (0, logger_1.log)(`Screenshot content length: ${Array.isArray(content) ? content.length : 0} items`);
-                    // Verify the screenshot content
-                    expect(content).toBeDefined();
-                    expect(Array.isArray(content)).toBe(true);
-                    // Check if the content contains base64 image data
-                    const hasImageData = containsBase64Image(content);
-                    expect(hasImageData).toBe(true);
-                }
-                catch (error) {
-                    (0, logger_1.log)(`Note: UI.screenshot execution failed: ${error}`);
-                    // Don't fail the test if the method is not fully implemented
-                }
-            }
-            else {
-                (0, logger_1.log)('Note: UI.screenshot method is not available, skipping test');
-            }
-        });
-    });
-});

package/dist/tests/unit/window.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/unit/window.test.js

@@ -1,331 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const src_1 = require("../../src");
-const window_1 = require("../../src/window/window");
-const test_helpers_1 = require("../utils/test-helpers");
-const logger_1 = require("../../src/utils/logger");
-// Helper function to parse window data from content array
-function parseWindowsContent(content) {
-    if (!Array.isArray(content) || content.length === 0) {
-        return [];
-    }
-    // Try to extract and parse text from the first content item
-    const item = content[0];
-    if (item && typeof item === 'object' && item.text && typeof item.text === 'string') {
-        try {
-            return JSON.parse(item.text);
-        }
-        catch (e) {
-            (0, logger_1.log)(`Warning: Failed to parse content text as JSON: ${e}`);
-            return [];
-        }
-    }
-    return [];
-}
-// Helper function to parse single window data from content array
-function parseWindowContent(content) {
-    if (!Array.isArray(content) || content.length === 0) {
-        return null;
-    }
-    // Try to extract and parse text from the first content item
-    const item = content[0];
-    if (item && typeof item === 'object' && item.text && typeof item.text === 'string') {
-        try {
-            return JSON.parse(item.text);
-        }
-        catch (e) {
-            (0, logger_1.log)(`Warning: Failed to parse content text as JSON: ${e}`);
-            return null;
-        }
-    }
-    return null;
-}
-// Helper function to check if content has error
-function hasErrorInContent(content) {
-    if (!Array.isArray(content)) {
-        return true;
-    }
-    if (content.length === 0) {
-        return true;
-    }
-    // Check if first content item has error text
-    return content.some(item => item && typeof item === 'object' &&
-        item.text && typeof item.text === 'string' &&
-        (item.text.includes('error') || item.text.includes('Error')));
-}
-// Type declarations are now in tests/jest.d.ts
-describe('WindowManager', () => {
-    let agentBay;
-    let session;
-    let windowManager;
-    beforeEach(async () => {
-        // Create a real AgentBay instance with test API key
-        const apiKey = (0, test_helpers_1.getTestApiKey)();
-        agentBay = new src_1.AgentBay({ apiKey });
-        // Create a real session
-        (0, logger_1.log)('Creating a new session for window testing...');
-        session = await agentBay.create();
-        windowManager = new window_1.WindowManager(session);
-    });
-    afterEach(async () => {
-        (0, logger_1.log)('Cleaning up: Deleting the session...');
-        try {
-            if (session)
-                await agentBay.delete(session);
-            (0, logger_1.log)('Session successfully deleted');
-        }
-        catch (error) {
-            (0, logger_1.log)(`Warning: Error deleting session: ${error}`);
-        }
-    });
-    describe('listRootWindows()', () => {
-        it.only('should return a list of root windows', async () => {
-            (0, logger_1.log)('Testing listRootWindows...');
-            try {
-                // Call the method
-                const content = await windowManager.listRootWindows();
-                (0, logger_1.log)(`Retrieved content:`, content);
-                // Verify content format
-                expect(content).toBeDefined();
-                expect(Array.isArray(content)).toBe(true);
-                expect(hasErrorInContent(content)).toBe(false);
-                // Parse windows from content
-                const windows = parseWindowsContent(content);
-                (0, logger_1.log)(`Found ${windows.length} root windows`);
-                // Verify the results
-                if (windows.length > 0) {
-                    windows.forEach((window) => {
-                        expect(window.window_id).toBeDefined();
-                        expect(window.title).toBeDefined();
-                        expect(window.pid).toBeDefined();
-                        expect(window.pname).toBeDefined();
-                    });
-                }
-                else {
-                    (0, logger_1.log)('No windows found, this might be normal in some environments');
-                }
-            }
-            catch (error) {
-                (0, logger_1.log)(`Error in listRootWindows test: ${error}`);
-                // Skip test if we can't list windows
-                expect(true).toBe(true);
-            }
-        });
-    });
-    describe('getActiveWindow()', () => {
-        it.only('should return the active window', async () => {
-            (0, logger_1.log)('Testing getActiveWindow...');
-            try {
-                const content = await windowManager.getActiveWindow();
-                (0, logger_1.log)(`Active window content:`, content);
-                // Verify content format
-                expect(content).toBeDefined();
-                expect(Array.isArray(content)).toBe(true);
-                expect(hasErrorInContent(content)).toBe(false);
-                // Parse window from content
-                const window = parseWindowContent(content);
-                if (window) {
-                    (0, logger_1.log)(`Active window: ${window.title} (ID: ${window.window_id})`);
-                    // Verify the results
-                    expect(window.window_id).toBeDefined();
-                    expect(window.title).toBeDefined();
-                    expect(window.pid).toBeDefined();
-                    expect(window.pname).toBeDefined();
-                }
-            }
-            catch (error) {
-                (0, logger_1.log)(`Error in getActiveWindow test: ${error}`);
-                // Skip test if we can't get active window
-                expect(true).toBe(true);
-            }
-        });
-    });
-    describe('activateWindow()', () => {
-        it.only('should activate a window', async () => {
-            (0, logger_1.log)('Testing activateWindow...');
-            try {
-                // First get a list of windows
-                const listContent = await windowManager.listRootWindows();
-                const windows = parseWindowsContent(listContent);
-                if (windows.length === 0) {
-                    (0, logger_1.log)('No windows available for testing activateWindow');
-                    return;
-                }
-                // Use the first window for testing
-                const windowId = windows[0].window_id;
-                (0, logger_1.log)(`Activating window with ID: ${windowId}`);
-                // Call the method
-                const content = await windowManager.activateWindow(windowId);
-                (0, logger_1.log)(`Activate window content:`, content);
-                // Verify content format
-                expect(content).toBeDefined();
-                expect(Array.isArray(content)).toBe(true);
-                expect(hasErrorInContent(content)).toBe(false);
-                (0, logger_1.log)('Window activated successfully');
-            }
-            catch (error) {
-                (0, logger_1.log)(`Error in activateWindow test: ${error}`);
-                // Skip test if we can't activate window
-                expect(true).toBe(true);
-            }
-        });
-    });
-    describe('maximizeWindow()', () => {
-        it.only('should maximize a window', async () => {
-            (0, logger_1.log)('Testing maximizeWindow...');
-            try {
-                // First get a list of windows
-                const listContent = await windowManager.listRootWindows();
-                const windows = parseWindowsContent(listContent);
-                if (windows.length === 0) {
-                    (0, logger_1.log)('No windows available for testing maximizeWindow');
-                    return;
-                }
-                // Use the first window for testing
-                const windowId = windows[0].window_id;
-                (0, logger_1.log)(`Maximizing window with ID: ${windowId}`);
-                // Call the method
-                const content = await windowManager.maximizeWindow(windowId);
-                (0, logger_1.log)(`Maximize window content:`, content);
-                // Verify content format
-                expect(content).toBeDefined();
-                expect(Array.isArray(content)).toBe(true);
-                expect(hasErrorInContent(content)).toBe(false);
-                (0, logger_1.log)('Window maximized successfully');
-            }
-            catch (error) {
-                (0, logger_1.log)(`Error in maximizeWindow test: ${error}`);
-                // Skip test if we can't maximize window
-                expect(true).toBe(true);
-            }
-        });
-    });
-    describe('minimizeWindow()', () => {
-        it.only('should minimize a window', async () => {
-            (0, logger_1.log)('Testing minimizeWindow...');
-            try {
-                // First get a list of windows
-                const listContent = await windowManager.listRootWindows();
-                const windows = parseWindowsContent(listContent);
-                if (windows.length === 0) {
-                    (0, logger_1.log)('No windows available for testing minimizeWindow');
-                    return;
-                }
-                // Use the first window for testing
-                const windowId = windows[0].window_id;
-                (0, logger_1.log)(`Minimizing window with ID: ${windowId}`);
-                // Call the method
-                const content = await windowManager.minimizeWindow(windowId);
-                (0, logger_1.log)(`Minimize window content:`, content);
-                // Verify content format
-                expect(content).toBeDefined();
-                expect(Array.isArray(content)).toBe(true);
-                expect(hasErrorInContent(content)).toBe(false);
-                (0, logger_1.log)('Window minimized successfully');
-            }
-            catch (error) {
-                (0, logger_1.log)(`Error in minimizeWindow test: ${error}`);
-                // Skip test if we can't minimize window
-                expect(true).toBe(true);
-            }
-        });
-    });
-    describe('restoreWindow()', () => {
-        it.only('should restore a window', async () => {
-            (0, logger_1.log)('Testing restoreWindow...');
-            try {
-                // First get a list of windows
-                const listContent = await windowManager.listRootWindows();
-                const windows = parseWindowsContent(listContent);
-                if (windows.length === 0) {
-                    (0, logger_1.log)('No windows available for testing restoreWindow');
-                    return;
-                }
-                // Use the first window for testing
-                const windowId = windows[0].window_id;
-                (0, logger_1.log)(`Restoring window with ID: ${windowId}`);
-                // Call the method
-                const content = await windowManager.restoreWindow(windowId);
-                (0, logger_1.log)(`Restore window content:`, content);
-                // Verify content format
-                expect(content).toBeDefined();
-                expect(Array.isArray(content)).toBe(true);
-                expect(hasErrorInContent(content)).toBe(false);
-                (0, logger_1.log)('Window restored successfully');
-            }
-            catch (error) {
-                (0, logger_1.log)(`Error in restoreWindow test: ${error}`);
-                // Skip test if we can't restore window
-                expect(true).toBe(true);
-            }
-        });
-    });
-    describe('resizeWindow()', () => {
-        it.only('should resize a window', async () => {
-            (0, logger_1.log)('Testing resizeWindow...');
-            try {
-                // First get a list of windows
-                const listContent = await windowManager.listRootWindows();
-                const windows = parseWindowsContent(listContent);
-                if (windows.length === 0) {
-                    (0, logger_1.log)('No windows available for testing resizeWindow');
-                    return;
-                }
-                // Use the first window for testing
-                const windowId = windows[0].window_id;
-                (0, logger_1.log)(`Resizing window with ID: ${windowId} to 800x600`);
-                // Call the method
-                const content = await windowManager.resizeWindow(windowId, 800, 600);
-                (0, logger_1.log)(`Resize window content:`, content);
-                // Verify content format
-                expect(content).toBeDefined();
-                expect(Array.isArray(content)).toBe(true);
-                expect(hasErrorInContent(content)).toBe(false);
-                (0, logger_1.log)('Window resized successfully to 800x600');
-            }
-            catch (error) {
-                (0, logger_1.log)(`Error in resizeWindow test: ${error}`);
-                // Skip test if we can't resize window
-                expect(true).toBe(true);
-            }
-        });
-    });
-    describe('focusMode()', () => {
-        it.only('should enable focus mode', async () => {
-            (0, logger_1.log)('Testing focusMode enable...');
-            try {
-                // Call the method
-                const content = await windowManager.focusMode(true);
-                (0, logger_1.log)(`Focus mode enable content:`, content);
-                // Verify content format
-                expect(content).toBeDefined();
-                expect(Array.isArray(content)).toBe(true);
-                expect(hasErrorInContent(content)).toBe(false);
-                (0, logger_1.log)('Focus mode enabled successfully');
-            }
-            catch (error) {
-                (0, logger_1.log)(`Error in focusMode enable test: ${error}`);
-                // Skip test if we can't enable focus mode
-                expect(true).toBe(true);
-            }
-        });
-        it.only('should disable focus mode', async () => {
-            (0, logger_1.log)('Testing focusMode disable...');
-            try {
-                // Call the method
-                const content = await windowManager.focusMode(false);
-                (0, logger_1.log)(`Focus mode disable content:`, content);
-                // Verify content format
-                expect(content).toBeDefined();
-                expect(Array.isArray(content)).toBe(true);
-                expect(hasErrorInContent(content)).toBe(false);
-                (0, logger_1.log)('Focus mode disabled successfully');
-            }
-            catch (error) {
-                (0, logger_1.log)(`Error in focusMode disable test: ${error}`);
-                // Skip test if we can't disable focus mode
-                expect(true).toBe(true);
-            }
-        });
-    });
-});

package/dist/tests/utils/test-helpers.d.ts

@@ -1,35 +0,0 @@
-import 'dotenv/config';
-/**
- * Get API key for testing
- * @returns The API key to use for tests
- */
-export declare function getTestApiKey(): string;
-/**
- * Check if a string contains "tool not found"
- * @param s The string to check
- * @returns True if the string contains "tool not found"
- */
-export declare function containsToolNotFound(s: string): boolean;
-/**
- * Extract resourceId from a URL
- * @param url The URL to extract from
- * @returns The extracted resourceId or empty string if not found
- */
-export declare function extractResourceId(url: string): string;
-/**
- * Wait for a specified amount of time
- * @param ms Milliseconds to wait
- * @returns A promise that resolves after the specified time
- */
-export declare function wait(ms: number): Promise<void>;
-/**
- * Generate a random string for test data
- * @param length Length of the string to generate
- * @returns A random string
- */
-export declare function randomString(length?: number): string;
-/**
- *
- * @returns A unique ID for testing
- */
-export declare function generateUniqueId(): string;

package/dist/tests/utils/test-helpers.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTestApiKey = getTestApiKey;
-exports.containsToolNotFound = containsToolNotFound;
-exports.extractResourceId = extractResourceId;
-exports.wait = wait;
-exports.randomString = randomString;
-exports.generateUniqueId = generateUniqueId;
-require("dotenv/config");
-const logger_1 = require("../../src/utils/logger");
-/**
- * Get API key for testing
- * @returns The API key to use for tests
- */
-function getTestApiKey() {
-    // For Node.js environments
-    let apiKey;
-    try {
-        apiKey = process.env.AGENTBAY_API_KEY;
-    }
-    catch (e) {
-        // process is not defined in some environments
-    }
-    if (!apiKey) {
-        (0, logger_1.log)('Warning: Using default API key. Set AGENTBAY_API_KEY environment variable for testing.');
-        return 'akm-xxx'; // Replace with your test API key
-    }
-    return apiKey;
-}
-/**
- * Check if a string contains "tool not found"
- * @param s The string to check
- * @returns True if the string contains "tool not found"
- */
-function containsToolNotFound(s) {
-    return s.toLowerCase().includes('tool not found');
-}
-/**
- * Extract resourceId from a URL
- * @param url The URL to extract from
- * @returns The extracted resourceId or empty string if not found
- */
-function extractResourceId(url) {
-    const matches = url.match(/resourceId=([^&]+)/);
-    if (matches && matches.length > 1) {
-        return matches[1];
-    }
-    return '';
-}
-/**
- * Wait for a specified amount of time
- * @param ms Milliseconds to wait
- * @returns A promise that resolves after the specified time
- */
-function wait(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-/**
- * Generate a random string for test data
- * @param length Length of the string to generate
- * @returns A random string
- */
-function randomString(length = 8) {
-    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-    let result = '';
-    for (let i = 0; i < length; i++) {
-        result += chars.charAt(Math.floor(Math.random() * chars.length));
-    }
-    return result;
-}
-/**
- *
- * @returns A unique ID for testing
- */
-function generateUniqueId() {
-    const timestamp = Date.now() * 1000;
-    const randomPart = Math.floor(Math.random() * 10001);
-    return `${timestamp}-${randomPart}`;
-}