wuying-agentbay-sdk 0.11.0 → 0.13.0

package/docs/examples/common-features/basics/session-pause-resume/session-pause-resume.ts

@@ -0,0 +1,237 @@
+import { AgentBay, Session, log, logError, newCreateSessionParams } from 'wuying-agentbay-sdk'
+
+/**
+ * Pause and resume a session
+ * 
+ * This example demonstrates how to pause and resume a session using the AgentBay SDK.
+ * Pausing a session puts it into a dormant state, consuming fewer resources while
+ * maintaining its state. Resuming a session brings it back to an active state.
+ */
+async function pauseAndResumeSession() {
+  // Initialize the AgentBay client
+  const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+
+  try {
+    // Create a session with labels for identification
+    const params = newCreateSessionParams().withLabels({
+      project: 'pause-resume-example',
+      environment: 'development',
+      purpose: 'demonstration'
+    });
+
+    log('Creating session...');
+    const createResult = await agentBay.create(params);
+
+    if (createResult.success && createResult.session) {
+      const session = createResult.session;
+      log(`✅ Session created successfully with ID: ${session.sessionId}`);
+      log(`📎 Request ID: ${createResult.requestId}`);
+
+      // Perform some work in the session before pausing
+      log('Performing some work in the session...');
+      const commandResult = await session.command.executeCommand('echo "Hello from paused session!"');
+      if (commandResult.success) {
+        log(`💻 Command output: ${commandResult.output}`);
+      }
+
+      // Pause the session
+      log('\n⏸️  Pausing session...');
+      const pauseResult = await agentBay.pauseAsync(session);
+      
+      if (pauseResult.success) {
+        log(`✅ Session pause initiated successfully`);
+        log(`📎 Pause Request ID: ${pauseResult.requestId}`);
+        
+        // Check session status after pause
+        const sessionStatusAfterPause = await agentBay.getSession(session.sessionId);
+        if (sessionStatusAfterPause.success && sessionStatusAfterPause.data) {
+          log(`📊 Session status after pause: ${sessionStatusAfterPause.data.status || 'Unknown'}`);
+        }
+      } else {
+        log(`❌ Failed to pause session: ${pauseResult.errorMessage}`);
+        // Continue with the example even if pause fails
+      }
+
+      // Wait a bit for the pause to complete
+      log('\n⏳ Waiting for session to pause...');
+      await new Promise(resolve => setTimeout(resolve, 5000));
+
+      // Resume the session
+      log('\n▶️  Resuming session...');
+      const resumeResult = await agentBay.resumeAsync(session);
+      
+      if (resumeResult.success) {
+        log(`✅ Session resume initiated successfully`);
+        log(`📎 Resume Request ID: ${resumeResult.requestId}`);
+        
+        // Check session status after resume
+        const sessionStatusAfterResume = await agentBay.getSession(session.sessionId);
+        if (sessionStatusAfterResume.success && sessionStatusAfterResume.data) {
+          log(`📊 Session status after resume: ${sessionStatusAfterResume.data.status || 'Unknown'}`);
+        }
+      } else {
+        log(`❌ Failed to resume session: ${resumeResult.errorMessage}`);
+        // Continue with the example even if resume fails
+      }
+
+      // Wait a bit for the resume to complete
+      log('\n⏳ Waiting for session to resume...');
+      await new Promise(resolve => setTimeout(resolve, 5000));
+
+      // Perform some work in the session after resuming
+      log('\nPerforming some work in the resumed session...');
+      const commandResultAfterResume = await session.command.executeCommand('echo "Hello from resumed session!"');
+      if (commandResultAfterResume.success) {
+        log(`💻 Command output: ${commandResultAfterResume.output}`);
+      }
+
+      // Clean up by deleting the session
+      log('\n🧹 Cleaning up - deleting session...');
+      const deleteResult = await agentBay.delete(session);
+      if (deleteResult.success) {
+        log('✅ Session deleted successfully');
+      } else {
+        log(`❌ Failed to delete session: ${deleteResult.errorMessage}`);
+      }
+    } else {
+      log(`❌ Failed to create session: ${createResult.errorMessage}`);
+    }
+  } catch (error) {
+    logError('Error in pause and resume example:', error);
+  }
+}
+
+/**
+ * Handle non-existent session pause/resume
+ * 
+ * This example demonstrates how the SDK handles attempts to pause or resume
+ * sessions that don't exist.
+ */
+async function handleNonExistentSession() {
+  // Initialize the AgentBay client
+  const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+
+  log('\n' + '='.repeat(50));
+  log('Handling Non-Existent Session Example');
+  log('='.repeat(50));
+
+  // Create a session object with invalid ID
+  const fakeSessionId = 'session-nonexistent-12345';
+  log(`\nCreating session object for non-existent session: ${fakeSessionId}`);
+  
+  // Create a real session object with invalid ID
+  const fakeSession = new Session(agentBay, fakeSessionId);
+
+  try {
+    // Try to pause the non-existent session
+    log('⏸️  Attempting to pause non-existent session...');
+    const pauseResult = await agentBay.pauseAsync(fakeSession);
+    log(`Pause result: Success=${pauseResult.success}, Error=${pauseResult.errorMessage || 'None'}`);
+    
+    log('▶️  Attempting to resume non-existent session...');
+    const resumeResult = await agentBay.resumeAsync(fakeSession);
+    log(`Resume result: Success=${resumeResult.success}, Error=${resumeResult.errorMessage || 'None'}`);
+  } catch (error) {
+    log(`Expected error when handling non-existent session: ${error}`);
+  }
+}
+
+/**
+ * Pause and resume with custom parameters
+ * 
+ * This example demonstrates how to use custom timeout and polling interval
+ * parameters when pausing and resuming sessions.
+ */
+async function pauseAndResumeWithCustomParameters() {
+  // Initialize the AgentBay client
+  const agentBay = new AgentBay({ apiKey: process.env.AGENTBAY_API_KEY });
+
+  log('\n' + '='.repeat(50));
+  log('Custom Parameters Example');
+  log('='.repeat(50));
+
+  try {
+    // Create a session
+    const params = newCreateSessionParams().withLabels({
+      project: 'pause-resume-custom-example',
+      environment: 'development',
+      purpose: 'custom-parameters'
+    });
+
+    log('Creating session with custom parameters example...');
+    const createResult = await agentBay.create(params);
+
+    if (createResult.success && createResult.session) {
+      const session = createResult.session;
+      log(`✅ Session created successfully with ID: ${session.sessionId}`);
+
+      // Pause the session with custom parameters
+      // Using shorter timeout and poll interval for demonstration
+      log('\n⏸️  Pausing session with custom parameters (timeout=30s, pollInterval=1s)...');
+      const pauseResult = await agentBay.pauseAsync(session, 30, 1);
+      
+      if (pauseResult.success) {
+        log(`✅ Session pause with custom parameters initiated successfully`);
+        log(`📎 Request ID: ${pauseResult.requestId}`);
+        
+        // Check session status after pause
+        const sessionStatusAfterPause = await agentBay.getSession(session.sessionId);
+        if (sessionStatusAfterPause.success && sessionStatusAfterPause.data) {
+          log(`📊 Session status after pause: ${sessionStatusAfterPause.data.status || 'Unknown'}`);
+        }
+      } else {
+        log(`❌ Failed to pause session with custom parameters: ${pauseResult.errorMessage}`);
+      }
+
+      // Wait a bit
+      await new Promise(resolve => setTimeout(resolve, 3000));
+
+      // Resume the session with custom parameters
+      log('\n▶️  Resuming session with custom parameters (timeout=30s, pollInterval=1s)...');
+      const resumeResult = await agentBay.resumeAsync(session, 30, 1);
+      
+      if (resumeResult.success) {
+        log(`✅ Session resume with custom parameters initiated successfully`);
+        log(`📎 Request ID: ${resumeResult.requestId}`);
+        
+        // Check session status after resume
+        const sessionStatusAfterResume = await agentBay.getSession(session.sessionId);
+        if (sessionStatusAfterResume.success && sessionStatusAfterResume.data) {
+          log(`📊 Session status after resume: ${sessionStatusAfterResume.data.status || 'Unknown'}`);
+        }
+      } else {
+        log(`❌ Failed to resume session with custom parameters: ${resumeResult.errorMessage}`);
+      }
+
+      // Clean up
+      log('\n🧹 Cleaning up - deleting session...');
+      const deleteResult = await agentBay.delete(session);
+      if (deleteResult.success) {
+        log('✅ Session deleted successfully');
+      } else {
+        log(`❌ Failed to delete session: ${deleteResult.errorMessage}`);
+      }
+    } else {
+      log(`❌ Failed to create session: ${createResult.errorMessage}`);
+    }
+  } catch (error) {
+    logError('Error in custom parameters example:', error);
+  }
+}
+
+/**
+ * Run all examples
+ */
+async function main() {
+  log('Session Pause and Resume Examples');
+  log('=================================');
+
+  await pauseAndResumeSession();
+  await handleNonExistentSession();
+  await pauseAndResumeWithCustomParameters();
+}
+
+main().catch(error => {
+  logError('Error in main:', error);
+  process.exit(1);
+});

package/docs/examples/mobile-use/mobile-get-adb-url/index.ts

@@ -5,7 +5,7 @@
  * an ADB (Android Debug Bridge) connection URL for a mobile session.
  */
 
-import { AgentBay } from '@aliyun/wuying-agentbay-sdk';
+import { AgentBay } from 'wuying-agentbay-sdk';
 
 async function main() {
   // Get API key from environment variable

package/docs/examples/mobile-use/mobile-simulate-basic-usage.ts

@@ -0,0 +1,202 @@
+/**
+ * Mobile Simulate Example
+ * 
+ * This example demonstrates how to use the mobile simulate feature to simulate
+ * different mobile devices across sessions.
+ */
+
+// @ts-nocheck
+import { AgentBay, Session, MobileSimulateService, MobileSimulateMode } from 'wuying-agentbay-sdk';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+let session1: Session | null = null;
+let session2: Session | null = null;
+let mobileSimContextId: string | null = null;
+
+async function runOnFirstMobileSession(client: AgentBay): Promise<void> {
+  console.log('=== First Mobile Session ===');
+  
+  try {
+    // Upload mobile info file for first time
+    // How to get the mobile info file please contact the support team.
+    console.log('Uploading mobile info file for first time...');
+    
+    // Get the path to mobile_info_model_a.json
+    // Navigate from typescript/docs/examples/mobile-use/mobile-simulate-example to resource/
+    const mobileInfoFilePath = join(
+      __dirname,
+      '..',
+      '..',
+      '..',
+      '..',
+      'resource',
+      'mobile_info_model_a.json'
+    );
+    
+    // Read the mobile info file
+    const mobileInfoContent = readFileSync(mobileInfoFilePath, 'utf-8');
+    
+    // Upload mobile info
+    const simulateService = new MobileSimulateService(client);
+    simulateService.setSimulateEnable(true);
+    simulateService.setSimulateMode(MobileSimulateMode.PropertiesOnly);
+    const uploadResult = await simulateService.uploadMobileInfo(mobileInfoContent);
+    if (!uploadResult.success) {
+      throw new Error(`Failed to upload mobile info file: ${uploadResult.errorMessage}`);
+    }
+    
+    mobileSimContextId = uploadResult.mobileSimulateContextId!;
+    console.log(`Mobile simulate context id uploaded successfully: ${mobileSimContextId}`);
+    
+    // Create session with mobile simulate configuration
+    console.log('Creating first session...');
+    const sessionResult = await client.create({
+      imageId: 'mobile_latest',
+      extraConfigs: {
+        mobile: {
+          // Set mobile simulate config
+          simulateConfig: simulateService.getSimulateConfig(),
+        },
+      },
+    });
+    
+    if (!sessionResult.success || !sessionResult.session) {
+      throw new Error(`Failed to create session: ${sessionResult.errorMessage}`);
+    }
+    
+    session1 = sessionResult.session;
+    console.log(`Session created with ID: ${session1!.sessionId}`);
+    
+    // Wait for mobile simulate to complete
+    console.log('Waiting for mobile simulate to complete...');
+    await new Promise(resolve => setTimeout(resolve, 5000));
+    
+    // Get device model after mobile simulate
+    console.log('Getting device model after mobile simulate...');
+    const result = await session1!.command.executeCommand('getprop ro.product.model');
+    if (!result.success) {
+      throw new Error(`Failed to get device model: ${result.errorMessage}`);
+    }
+    
+    const productModel = result.output.trim();
+    console.log(`First session device model: ${productModel}`);
+    
+  } catch (error) {
+    throw new Error(`Error during run_on_first_mobile_session: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+async function runOnSecondMobileSession(client: AgentBay): Promise<void> {
+  console.log('\n=== Second Mobile Session ===');
+  
+  try {
+    // Use the same mobile simulate context id as the first session
+    console.log('Creating second session...');
+    const simulateService = new MobileSimulateService(client);
+    simulateService.setSimulateEnable(true);
+    simulateService.setSimulateMode(MobileSimulateMode.PropertiesOnly);
+    simulateService.setSimulateContextId(mobileSimContextId!);
+    const sessionResult = await client.create({
+      imageId: 'mobile_latest',
+      extraConfigs: {
+        mobile: {
+          lockResolution: false,
+          // Set mobile simulate config
+          simulateConfig: simulateService.getSimulateConfig(),
+        },
+      },
+    });
+    
+    if (!sessionResult.success || !sessionResult.session) {
+      throw new Error(`Failed to create session: ${sessionResult.errorMessage}`);
+    }
+    
+    session2 = sessionResult.session;
+    console.log(`Session created with ID: ${session2!.sessionId}`);
+    
+    // Wait for mobile simulate to complete
+    console.log('Waiting for mobile simulate to complete...');
+    await new Promise(resolve => setTimeout(resolve, 5000));
+    
+    // Get device model after mobile simulate
+    console.log('Getting device model after mobile simulate...');
+    const result = await session2!.command.executeCommand('getprop ro.product.model');
+    if (!result.success) {
+      throw new Error(`Failed to get device model: ${result.errorMessage}`);
+    }
+    
+    const productModel = result.output.trim();
+    console.log(`Second session device model: ${productModel}`);
+    
+  } catch (error) {
+    throw new Error(`Error during run_on_second_mobile_session: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+async function main() {
+  console.log('=== Mobile Simulate Example ===\n');
+  
+  // Get API key from environment variable
+  const apiKey = process.env.AGENTBAY_API_KEY;
+  if (!apiKey) {
+    console.error('Error: AGENTBAY_API_KEY environment variable is not set');
+    console.error('Please set it with: export AGENTBAY_API_KEY=your_api_key');
+    process.exit(1);
+  }
+  
+  // Initialize AgentBay client
+  const client = new AgentBay({ apiKey });
+  console.log('AgentBay client initialized');
+  
+  try {
+    // Run on first mobile session
+    await runOnFirstMobileSession(client);
+    
+    // Delete first session
+    console.log('\nDeleting first session...');
+    const deleteResult1 = await session1!.delete();
+    if (!deleteResult1.success) {
+      throw new Error(`Failed to delete first session: ${deleteResult1.errorMessage}`);
+    }
+    console.log(`First session deleted successfully (RequestID: ${deleteResult1.requestId})`);
+    
+    // Run on second mobile session
+    await runOnSecondMobileSession(client);
+    
+    // Delete second session
+    console.log('\nDeleting second session...');
+    const deleteResult2 = await session2!.delete();
+    if (!deleteResult2.success) {
+      throw new Error(`Failed to delete second session: ${deleteResult2.errorMessage}`);
+    }
+    console.log(`Second session deleted successfully (RequestID: ${deleteResult2.requestId})`);
+    
+    console.log('\n=== Example completed successfully ===');
+    
+  } catch (error) {
+    console.error('Error:', error instanceof Error ? error.message : String(error));
+    
+    // Cleanup sessions on error
+    if (session1) {
+      try {
+        await session1.delete();
+      } catch (e) {
+        console.warn('Warning: Failed to cleanup first session');
+      }
+    }
+    if (session2) {
+      try {
+        await session2.delete();
+      } catch (e) {
+        console.warn('Warning: Failed to cleanup second session');
+      }
+    }
+    
+    process.exit(1);
+  }
+}
+
+// Run the example
+main();
+

package/docs/examples/mobile-use/mobile-simulate-with-ctx.ts

@@ -0,0 +1,170 @@
+/**
+ * Mobile Simulate with User Specific Context Example
+ * 
+ * This example demonstrates how to use the mobile simulate feature with a user specific context 
+ * to simulate mobile devices across sessions.
+ * 
+ * Steps:
+ * 1. Get a user specific context
+ * 2. Check if the mobile dev info file exists in user's specific context, if not, get a mobile dev info file from DumpSDK or real device
+ * 3. Upload mobile dev info file to user's specific context
+ * 4. Create a session with mobile simulate configuration and user's specific context
+ * 5. Wait for mobile simulate to complete
+ * 6. Get device model after mobile simulate
+ * 7. Delete session
+ */
+
+// @ts-nocheck
+import { AgentBay, Session, MobileSimulateService, MobileSimulateMode, ContextSync, SyncPolicy, BWList, WhiteList } from 'wuying-agentbay-sdk';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+let session: Session | null = null;
+
+async function runOnMobileSession(client: AgentBay): Promise<void> {
+  try {
+    console.log('Getting a user specific context...');
+    const contextResult = await client.context.get('13000000001', true);
+    if (!contextResult.success || !contextResult.context) {
+      throw new Error(`Failed to get context: ${contextResult.errorMessage}`);
+    }
+    
+    const context = contextResult.context;
+    console.log(`context.id = ${context.id}, context.name = ${context.name}`);
+    
+    // Create sync policy with white list
+    const syncPolicy: SyncPolicy = {
+      bwList: {
+        whiteLists: [
+          {
+            path: '/com.wuying.devinfo',
+            excludePaths: []
+          }
+        ]
+      }
+    };
+    
+    const contextSync: ContextSync = {
+      contextId: context.id,
+      path: '/data/data',
+      policy: syncPolicy
+    };
+    
+    console.log('Checking or uploading mobile dev info file...');
+
+    const simulateService = new MobileSimulateService(client);
+    simulateService.setSimulateEnable(true);
+    simulateService.setSimulateMode(MobileSimulateMode.PropertiesOnly);
+    
+    // Check if the mobile dev info file exists in user's specific context
+    const hasMobileInfo = await simulateService.hasMobileInfo(contextSync);
+    if (!hasMobileInfo) {
+      // If not, get a mobile dev info file from DumpSDK or real device
+      const mobileInfoFilePath = join(
+        __dirname,
+        '..',
+        '..',
+        '..',
+        '..',
+        'resource',
+        'mobile_info_model_a.json'
+      );
+      
+      const mobileInfoContent = readFileSync(mobileInfoFilePath, 'utf-8');
+      
+      const uploadResult = await simulateService.uploadMobileInfo(mobileInfoContent, contextSync);
+      if (!uploadResult.success) {
+        throw new Error(`Failed to upload mobile dev info: ${uploadResult.errorMessage}`);
+      }
+      console.log('Mobile dev info uploaded successfully');
+    } else {
+      console.log(`Mobile dev info already exists: ${hasMobileInfo}`);
+    }
+    
+    // Create session with mobile simulate configuration and user's specific context
+    console.log('Creating session...');
+    const sessionResult = await client.create({
+      imageId: 'mobile_latest',
+      contextSync: [contextSync],
+      extraConfigs: {
+        mobile: {
+          // Set mobile simulate config
+          simulateConfig: simulateService.getSimulateConfig(),
+        },
+      },
+    });
+    
+    if (!sessionResult.success || !sessionResult.session) {
+      throw new Error(`Failed to create session: ${sessionResult.errorMessage}`);
+    }
+    
+    session = sessionResult.session;
+    console.log(`Session created with ID: ${session.sessionId}`);
+    
+    // Wait for mobile simulate to complete
+    console.log('Waiting for mobile simulate to complete...');
+    await new Promise(resolve => setTimeout(resolve, 5000));
+    
+    // Get device model after mobile simulate
+    console.log('Getting device model after mobile simulate...');
+    const result = await session.command.executeCommand('getprop ro.product.model');
+    if (!result.success) {
+      throw new Error(`Failed to get device model: ${result.errorMessage}`);
+    }
+    
+    const productModel = result.output.trim();
+    console.log(`Session device model: ${productModel}`);
+    
+  } catch (error) {
+    throw new Error(`Error during runOnMobileSession: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+async function main() {
+  console.log('=== Mobile Simulate with User Specific Context Example ===\n');
+  
+  // Get API key from environment variable
+  const apiKey = process.env.AGENTBAY_API_KEY;
+  if (!apiKey) {
+    console.error('Error: AGENTBAY_API_KEY environment variable is not set');
+    console.error('Please set it with: export AGENTBAY_API_KEY=your_api_key');
+    process.exit(1);
+  }
+  
+  // Initialize AgentBay client
+  const client = new AgentBay({ apiKey });
+  console.log('AgentBay client initialized');
+  
+  try {
+    // Run on mobile session
+    await runOnMobileSession(client);
+    
+    // Delete session
+    console.log('\nDeleting session...');
+    const deleteResult = await session!.delete({ syncContext: true });
+    if (!deleteResult.success) {
+      throw new Error(`Failed to delete session: ${deleteResult.errorMessage}`);
+    }
+    console.log(`Session deleted successfully (RequestID: ${deleteResult.requestId})`);
+    
+    console.log('\n=== Example completed successfully ===');
+    
+  } catch (error) {
+    console.error('Error:', error instanceof Error ? error.message : String(error));
+    
+    // Cleanup session on error
+    if (session) {
+      try {
+        await session.delete({ syncContext: true });
+      } catch (e) {
+        console.warn('Warning: Failed to cleanup session');
+      }
+    }
+    
+    process.exit(1);
+  }
+}
+
+// Run the example
+main();
+

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "wuying-agentbay-sdk",
-    "version": "0.11.0",
+    "version": "0.13.0",
     "description": "TypeScript SDK for interacting with the Wuying AgentBay cloud runtime environment",
     "main": "./dist/index.cjs",
     "module": "./dist/index.mjs",
@@ -50,7 +50,7 @@
         "@types/jest": "^26.0.24",
         "@types/js-yaml": "^4.0.9",
         "@types/mocha": "^10.0.10",
-        "@types/node": "^18.15.0",
+        "@types/node": "^18.19.130",
         "@types/sinon": "^10.0.0",
         "@typescript-eslint/eslint-plugin": "^5.54.0",
         "@typescript-eslint/parser": "^5.54.0",
@@ -64,11 +64,11 @@
         "prettier": "^2.8.4",
         "sinon": "^15.2.0",
         "ts-jest": "^26.5.6",
-        "ts-node": "^10.9.2",
         "tsup": "^8.5.0",
-        "typedoc": "^0.25.0",
         "typedoc-plugin-markdown": "^3.16.0",
-        "typescript": "4.9.5"
+        "typescript": "^4.9.5",
+        "zod": "^3.25.76",
+        "zod-to-json-schema": "^3.22.4"
     },
     "dependencies": {
         "@alicloud/openapi-core": "^1.0.4",