wuying-agentbay-sdk 0.1.0 → 0.4.0

package/dist/src/window/window.js

@@ -1,220 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WindowManager = void 0;
-const CallMcpToolRequest_1 = require("../api/models/CallMcpToolRequest");
-const logger_1 = require("../utils/logger");
-const exceptions_1 = require("../exceptions");
-/**
- * Handles window management operations in the AgentBay cloud environment.
- */
-class WindowManager {
-    /**
-     * Creates a new WindowManager instance.
-     * @param session The session object that provides access to the AgentBay API.
-     */
-    constructor(session) {
-        this.session = session;
-    }
-    /**
-     * Helper method to call MCP tools and handle common response processing
-     *
-     * @param toolName - Name of the MCP tool to call
-     * @param args - Arguments to pass to the tool
-     * @param defaultErrorMsg - Default error message if specific error details are not available
-     * @returns A CallMcpToolResult with the response data
-     * @throws APIError if the call fails
-     */
-    async callMcpTool(toolName, args, defaultErrorMsg) {
-        try {
-            const argsJSON = JSON.stringify(args);
-            const request = new CallMcpToolRequest_1.CallMcpToolRequest({
-                authorization: `Bearer ${this.session.getAPIKey()}`,
-                sessionId: this.session.getSessionId(),
-                name: toolName,
-                args: argsJSON
-            });
-            // Log API request
-            (0, logger_1.log)(`API Call: CallMcpTool - ${toolName}`);
-            (0, logger_1.log)(`Request: SessionId=${request.sessionId}, Args=${request.args}`);
-            const response = await this.session.getClient().callMcpTool(request);
-            // Log API response
-            if (response && response.body) {
-                (0, logger_1.log)(`Response from CallMcpTool - ${toolName}:`, response.body);
-            }
-            // Extract data from response
-            if (!response.body?.data) {
-                throw new Error('Invalid response data format');
-            }
-            const data = response.body.data;
-            // Create result object
-            const result = {
-                data,
-                statusCode: response.statusCode || 0,
-                isError: false
-            };
-            // Check if there's an error in the response
-            if (data.isError === true) {
-                result.isError = true;
-                // Try to extract the error message from the content field
-                const contentArray = data.content;
-                if (contentArray && contentArray.length > 0) {
-                    result.content = contentArray;
-                    // Extract error message from the first content item
-                    if (contentArray[0]?.text) {
-                        result.errorMsg = contentArray[0].text;
-                        throw new Error(contentArray[0].text);
-                    }
-                }
-                throw new Error(defaultErrorMsg);
-            }
-            // Extract content array if it exists
-            if (Array.isArray(data.content)) {
-                result.content = data.content;
-            }
-            return result;
-        }
-        catch (error) {
-            (0, logger_1.logError)(`Error calling CallMcpTool - ${toolName}:`, error);
-            throw new exceptions_1.APIError(`Failed to call ${toolName}: ${error}`);
-        }
-    }
-    /**
-     * Lists all root windows in the system.
-     * @returns The content field from the API response
-     * @throws Error if the operation fails.
-     */
-    async listRootWindows() {
-        const args = {};
-        const result = await this.callMcpTool('list_root_windows', args, 'Failed to list root windows');
-        // Return the raw content field for the caller to parse
-        return result.data.content;
-    }
-    /**
-     * Gets the currently active window.
-     * @returns The content field from the API response
-     * @throws Error if the operation fails.
-     */
-    async getActiveWindow() {
-        const args = {};
-        const result = await this.callMcpTool('get_active_window', args, 'Failed to get active window');
-        // Return the raw content field for the caller to parse
-        return result.data.content;
-    }
-    /**
-     * Activates a window by ID.
-     * @param windowId The ID of the window to activate.
-     * @returns The content field from the API response
-     * @throws Error if the operation fails.
-     */
-    async activateWindow(windowId) {
-        const args = {
-            window_id: windowId
-        };
-        const result = await this.callMcpTool('activate_window', args, 'Failed to activate window');
-        // Return the raw content field for the caller to parse
-        return result.data.content;
-    }
-    /**
-     * Maximizes a window by ID.
-     * @param windowId The ID of the window to maximize.
-     * @returns The content field from the API response
-     * @throws Error if the operation fails.
-     */
-    async maximizeWindow(windowId) {
-        const args = {
-            window_id: windowId
-        };
-        const result = await this.callMcpTool('maximize_window', args, 'Failed to maximize window');
-        // Return the raw content field for the caller to parse
-        return result.data.content;
-    }
-    /**
-     * Minimizes a window by ID.
-     * @param windowId The ID of the window to minimize.
-     * @returns The content field from the API response
-     * @throws Error if the operation fails.
-     */
-    async minimizeWindow(windowId) {
-        const args = {
-            window_id: windowId
-        };
-        const result = await this.callMcpTool('minimize_window', args, 'Failed to minimize window');
-        // Return the raw content field for the caller to parse
-        return result.data.content;
-    }
-    /**
-     * Restores a window by ID.
-     * @param windowId The ID of the window to restore.
-     * @returns The content field from the API response
-     * @throws Error if the operation fails.
-     */
-    async restoreWindow(windowId) {
-        const args = {
-            window_id: windowId
-        };
-        const result = await this.callMcpTool('restore_window', args, 'Failed to restore window');
-        // Return the raw content field for the caller to parse
-        return result.data.content;
-    }
-    /**
-     * Closes a window by ID.
-     * @param windowId The ID of the window to close.
-     * @returns The content field from the API response
-     * @throws Error if the operation fails.
-     */
-    async closeWindow(windowId) {
-        const args = {
-            window_id: windowId
-        };
-        const result = await this.callMcpTool('close_window', args, 'Failed to close window');
-        // Return the raw content field for the caller to parse
-        return result.data.content;
-    }
-    /**
-     * Sets a window to fullscreen mode.
-     * @param windowId The ID of the window to set to fullscreen.
-     * @returns The content field from the API response
-     * @throws Error if the operation fails.
-     */
-    async fullscreenWindow(windowId) {
-        const args = {
-            window_id: windowId
-        };
-        const result = await this.callMcpTool('fullscreen_window', args, 'Failed to set window to fullscreen');
-        // Return the raw content field for the caller to parse
-        return result.data.content;
-    }
-    /**
-     * Resizes a window by ID.
-     * @param windowId The ID of the window to resize.
-     * @param width The new width of the window.
-     * @param height The new height of the window.
-     * @returns The content field from the API response
-     * @throws Error if the operation fails.
-     */
-    async resizeWindow(windowId, width, height) {
-        const args = {
-            window_id: windowId,
-            width,
-            height
-        };
-        const result = await this.callMcpTool('resize_window', args, 'Failed to resize window');
-        // Return the raw content field for the caller to parse
-        return result.data.content;
-    }
-    /**
-     * Enables or disables focus mode.
-     * @param on Whether to enable (true) or disable (false) focus mode.
-     * @returns The content field from the API response
-     * @throws Error if the operation fails.
-     */
-    async focusMode(on) {
-        const args = {
-            on
-        };
-        const result = await this.callMcpTool('focus_mode', args, 'Failed to set focus mode');
-        // Return the raw content field for the caller to parse
-        return result.data.content;
-    }
-}
-exports.WindowManager = WindowManager;

package/dist/tests/agent-bay.test.d.ts

@@ -1 +0,0 @@
-import 'dotenv/config';

package/dist/tests/agent-bay.test.js

@@ -1,366 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const src_1 = require("../src");
-require("dotenv/config");
-/**
- * Get API key for testing
- */
-function getTestApiKey() {
-    // For Node.js environments
-    let apiKey;
-    try {
-        apiKey = typeof process !== 'undefined' ? process.env.AGENTBAY_API_KEY : undefined;
-    }
-    catch (e) {
-        // process is not defined in some environments
-    }
-    if (!apiKey) {
-        console.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;
-}
-describe('AgentBay', () => {
-    describe('constructor', () => {
-        it('should initialize with API key from options', () => {
-            const apiKey = getTestApiKey();
-            const agentBay = new src_1.AgentBay({ apiKey });
-            expect(agentBay.apiKey).toBe(apiKey);
-        });
-        it('should initialize with API key from environment variable', () => {
-            const originalEnv = process.env.AGENTBAY_API_KEY;
-            process.env.AGENTBAY_API_KEY = 'env_api_key';
-            try {
-                const agentBay = new src_1.AgentBay();
-                expect(agentBay.apiKey).toBe('env_api_key');
-            }
-            finally {
-                // Restore original environment
-                if (originalEnv) {
-                    process.env.AGENTBAY_API_KEY = originalEnv;
-                }
-                else {
-                    delete process.env.AGENTBAY_API_KEY;
-                }
-            }
-        });
-        it('should throw AuthenticationError if no API key is provided', () => {
-            const originalEnv = process.env.AGENTBAY_API_KEY;
-            delete process.env.AGENTBAY_API_KEY;
-            try {
-                expect(() => new src_1.AgentBay()).toThrow();
-            }
-            finally {
-                // Restore original environment
-                if (originalEnv) {
-                    process.env.AGENTBAY_API_KEY = originalEnv;
-                }
-            }
-        });
-    });
-    describe('create, list, and delete', () => {
-        let agentBay;
-        let session;
-        beforeEach(() => {
-            const apiKey = getTestApiKey();
-            agentBay = new src_1.AgentBay({ apiKey });
-        });
-        it('should create, list, and delete a session', async () => {
-            // Create a session
-            console.log('Creating a new session...');
-            session = await agentBay.create();
-            console.log(`Session created with ID: ${session.sessionId}`);
-            // Ensure session ID is not empty
-            expect(session.sessionId).toBeDefined();
-            expect(session.sessionId.length).toBeGreaterThan(0);
-            // List sessions
-            console.log('Listing sessions...');
-            const sessions = agentBay.list();
-            // Ensure at least one session (the one we just created)
-            expect(sessions.length).toBeGreaterThanOrEqual(1);
-            // Check if our created session is in the list
-            const found = sessions.some(s => s.sessionId === session.sessionId);
-            expect(found).toBe(true);
-            // Delete the session
-            console.log('Deleting the session...');
-            await agentBay.delete(session);
-            // List sessions again to ensure it's deleted
-            const sessionsAfterDelete = agentBay.list();
-            // Check if the deleted session is not in the list
-            const stillExists = sessionsAfterDelete.some(s => s.sessionId === session.sessionId);
-            expect(stillExists).toBe(false);
-        });
-    });
-});
-describe('Session', () => {
-    let agentBay;
-    let session;
-    beforeEach(async () => {
-        const apiKey = getTestApiKey();
-        agentBay = new src_1.AgentBay({ apiKey });
-        // Create a session
-        console.log('Creating a new session for testing...');
-        session = await agentBay.create();
-        console.log(`Session created with ID: ${session.sessionId}`);
-    });
-    afterEach(async () => {
-        // Clean up the session
-        console.log('Cleaning up: Deleting the session...');
-        try {
-            await agentBay.delete(session);
-        }
-        catch (error) {
-            console.log(`Warning: Error deleting session: ${error}`);
-        }
-    });
-    describe('properties', () => {
-        it('should have valid sessionId', () => {
-            expect(session.sessionId).toBeDefined();
-            expect(session.sessionId.length).toBeGreaterThan(0);
-        });
-        it('should log resourceUrl', () => {
-            // ResourceUrl is optional, so we just log it without checking if it's non-empty
-            console.log(`Session resourceUrl: ${session.resourceUrl}`);
-        });
-        it('should have filesystem, command, and adb properties', () => {
-            expect(session.filesystem).toBeDefined();
-            expect(session.command).toBeDefined();
-            expect(session.adb).toBeDefined();
-        });
-    });
-    describe('methods', () => {
-        it('should return the session ID', () => {
-            const sessionId = session.getSessionId();
-            expect(sessionId).toBe(session.sessionId);
-        });
-        it('should return the API key', () => {
-            const apiKey = session.getAPIKey();
-            expect(apiKey).toBe(agentBay.getAPIKey());
-        });
-        it('should return the client', () => {
-            const client = session.getClient();
-            expect(client).toBeDefined();
-        });
-    });
-    describe('delete', () => {
-        it('should delete the session', async () => {
-            // Create a new session specifically for this test
-            console.log('Creating a new session for delete testing...');
-            const testSession = await agentBay.create();
-            console.log(`Session created with ID: ${testSession.sessionId}`);
-            // Test delete method
-            console.log('Testing session.delete method...');
-            try {
-                const result = await testSession.delete();
-                expect(result).toBe(true);
-                // Verify the session was deleted by checking it's not in the list
-                const sessions = agentBay.list();
-                const stillExists = sessions.some(s => s.sessionId === testSession.sessionId);
-                expect(stillExists).toBe(false);
-            }
-            catch (error) {
-                console.log(`Note: Session deletion failed: ${error}`);
-                // Clean up if the test failed
-                try {
-                    await agentBay.delete(testSession);
-                }
-                catch {
-                    // Ignore cleanup errors
-                }
-                throw error;
-            }
-        });
-    });
-    describe('command', () => {
-        it('should execute a command with default timeout', async () => {
-            if (session.command) {
-                console.log('Executing command with default timeout...');
-                try {
-                    const response = await session.command.executeCommand('ls');
-                    console.log(`Command execution result: ${response}`);
-                    expect(response).toBeDefined();
-                    // Check if response contains "tool not found"
-                    expect(response.toLowerCase().includes('tool not found')).toBe(false);
-                }
-                catch (error) {
-                    console.log(`Note: Command execution failed: ${error}`);
-                    // Don't fail the test if command execution is not supported
-                }
-            }
-            else {
-                console.log('Note: Command interface is nil, skipping command test');
-            }
-        });
-        it('should execute a command with custom timeout', async () => {
-            if (session.command) {
-                console.log('Executing command with custom timeout...');
-                try {
-                    const customTimeout = 2000; // 2 seconds
-                    const response = await session.command.executeCommand('ls', customTimeout);
-                    console.log(`Command execution result with custom timeout: ${response}`);
-                    expect(response).toBeDefined();
-                    // Check if response contains "tool not found"
-                    expect(response.toLowerCase().includes('tool not found')).toBe(false);
-                }
-                catch (error) {
-                    console.log(`Note: Command execution with custom timeout failed: ${error}`);
-                    // Don't fail the test if command execution is not supported
-                }
-            }
-            else {
-                console.log('Note: Command interface is nil, skipping command test');
-            }
-        });
-        it('should execute Python code with default timeout', async () => {
-            if (session.command) {
-                console.log('Executing Python code with default timeout...');
-                try {
-                    const pythonCode = `
-print("Hello, world!")
-x = 1 + 1
-print(x)
-`;
-                    const response = await session.command.runCode(pythonCode, 'python');
-                    console.log(`Python code execution result: ${response}`);
-                    expect(response).toBeDefined();
-                    // Check if response contains "tool not found"
-                    expect(response.toLowerCase().includes('tool not found')).toBe(false);
-                    // Check if response contains expected output
-                    expect(response.includes('Hello, world!')).toBe(true);
-                    expect(response.includes('2')).toBe(true);
-                }
-                catch (error) {
-                    console.log(`Note: Python code execution failed: ${error}`);
-                    // Don't fail the test if code execution is not supported
-                }
-            }
-            else {
-                console.log('Note: Command interface is nil, skipping code execution test');
-            }
-        });
-        it('should execute JavaScript code with custom timeout', async () => {
-            if (session.command) {
-                console.log('Executing JavaScript code with custom timeout...');
-                try {
-                    const jsCode = `
-console.log("Hello, world!");
-const x = 1 + 1;
-console.log(x);
-`;
-                    const customTimeout = 600; // 10 minutes
-                    const response = await session.command.runCode(jsCode, 'javascript', customTimeout);
-                    console.log(`JavaScript code execution result: ${response}`);
-                    expect(response).toBeDefined();
-                    // Check if response contains "tool not found"
-                    expect(response.toLowerCase().includes('tool not found')).toBe(false);
-                    // Check if response contains expected output
-                    expect(response.includes('Hello, world!')).toBe(true);
-                    expect(response.includes('2')).toBe(true);
-                }
-                catch (error) {
-                    console.log(`Note: JavaScript code execution failed: ${error}`);
-                    // Don't fail the test if code execution is not supported
-                }
-            }
-            else {
-                console.log('Note: Command interface is nil, skipping code execution test');
-            }
-        });
-        it('should reject invalid language', async () => {
-            if (session.command) {
-                console.log('Testing with invalid language...');
-                try {
-                    await session.command.runCode('print("test")', 'invalid_language');
-                    // Should not reach here
-                    console.log('Error: Expected error for invalid language, but got success');
-                    expect(false).toBe(true); // Force test to fail
-                }
-                catch (error) {
-                    console.log(`Correctly received error for invalid language: ${error}`);
-                    expect(error).toBeDefined();
-                    expect(String(error).includes('Unsupported language')).toBe(true);
-                }
-            }
-            else {
-                console.log('Note: Command interface is nil, skipping code execution test');
-            }
-        });
-    });
-    describe('filesystem', () => {
-        it('should read a file', async () => {
-            if (session.filesystem) {
-                console.log('Reading file...');
-                try {
-                    const content = await session.filesystem.readFile('/etc/hosts');
-                    console.log(`ReadFile result: content='${content}'`);
-                    expect(content).toBeDefined();
-                    // Check if response contains "tool not found"
-                    expect(content.toLowerCase().includes('tool not found')).toBe(false);
-                    console.log('File read successful');
-                }
-                catch (error) {
-                    console.log(`Note: File operation failed: ${error}`);
-                    // Don't fail the test if filesystem operations are not supported
-                }
-            }
-            else {
-                console.log('Note: FileSystem interface is nil, skipping file test');
-            }
-        });
-    });
-});
-describe('Adb', () => {
-    let agentBay;
-    let session;
-    beforeEach(async () => {
-        const apiKey = getTestApiKey();
-        agentBay = new src_1.AgentBay({ apiKey });
-        // Create a session
-        console.log('Creating a new session for ADB testing...');
-        session = await agentBay.create();
-        console.log(`Session created with ID: ${session.sessionId}`);
-    });
-    afterEach(async () => {
-        // Clean up the session
-        console.log('Cleaning up: Deleting the session...');
-        try {
-            await agentBay.delete(session);
-        }
-        catch (error) {
-            console.log(`Warning: Error deleting session: ${error}`);
-        }
-    });
-    describe('shell', () => {
-        it('should execute ADB shell commands', async () => {
-            if (session.adb) {
-                console.log('Executing ADB shell command...');
-                try {
-                    const response = await session.adb.shell('ls /sdcard');
-                    console.log(`ADB shell execution result: ${response}`);
-                    expect(response).toBeDefined();
-                    // Check if response contains "tool not found"
-                    expect(response.toLowerCase().includes('tool not found')).toBe(false);
-                }
-                catch (error) {
-                    console.log(`Note: ADB shell execution failed: ${error}`);
-                    // Don't fail the test if ADB is not supported
-                }
-                // Test another ADB command
-                try {
-                    console.log('Executing ADB shell command to check device properties...');
-                    const propResponse = await session.adb.shell('getprop');
-                    console.log(`ADB getprop execution result length: ${propResponse.length} bytes`);
-                    expect(propResponse).toBeDefined();
-                    // Check if response contains "tool not found"
-                    expect(propResponse.toLowerCase().includes('tool not found')).toBe(false);
-                }
-                catch (error) {
-                    console.log(`Note: ADB getprop execution failed: ${error}`);
-                }
-            }
-            else {
-                console.log('Note: Adb interface is nil, skipping ADB test');
-            }
-        });
-    });
-});

package/dist/tests/integration/context-persistence.test.d.ts

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