@desplega.ai/qa-use 2.2.3 → 2.2.5

package/lib/api/browser.test.ts

@@ -286,6 +286,56 @@ describe('BrowserApiClient', () => {
       expect(snapshot.snapshot).toContain('Example');
       expect(snapshot.url).toBe('https://example.com');
     });
+
+    it('should get ARIA snapshot with filtering options', async () => {
+      const mockSnapshot = {
+        snapshot: '- button "Submit" [ref=e1]',
+        url: 'https://example.com',
+        filter_stats: {
+          original_lines: 450,
+          filtered_lines: 42,
+          reduction_percent: 91,
+        },
+      };
+      mockAxiosInstance.get.mockResolvedValueOnce({ data: mockSnapshot });
+
+      const snapshot = await client.getSnapshot('session-123', {
+        interactive: true,
+        compact: true,
+        max_depth: 3,
+      });
+
+      expect(mockAxiosInstance.get).toHaveBeenCalledWith(
+        '/sessions/session-123/snapshot?interactive=true&compact=true&max_depth=3'
+      );
+      expect(snapshot.filter_stats?.reduction_percent).toBe(91);
+    });
+
+    it('should get ARIA snapshot with scope option', async () => {
+      const mockSnapshot = {
+        snapshot: '- heading "Main Content" [ref=e1]',
+        url: 'https://example.com',
+      };
+      mockAxiosInstance.get.mockResolvedValueOnce({ data: mockSnapshot });
+
+      await client.getSnapshot('session-123', { scope: '#main' });
+
+      expect(mockAxiosInstance.get).toHaveBeenCalledWith(
+        '/sessions/session-123/snapshot?scope=%23main'
+      );
+    });
+
+    it('should get ARIA snapshot without options (backward compatible)', async () => {
+      const mockSnapshot = {
+        snapshot: '- heading "Example" [ref=e1]',
+        url: 'https://example.com',
+      };
+      mockAxiosInstance.get.mockResolvedValueOnce({ data: mockSnapshot });
+
+      await client.getSnapshot('session-123');
+
+      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/sessions/session-123/snapshot');
+    });
   });
 
   describe('getScreenshot', () => {
@@ -375,4 +425,167 @@ describe('BrowserApiClient', () => {
       );
     });
   });
+
+  describe('generateTest', () => {
+    it('should generate test from session blocks', async () => {
+      const mockResult = {
+        yaml: 'name: Login Test\nsteps:\n  - goto: https://example.com',
+        test_definition: { name: 'Login Test' },
+        block_count: 3,
+      };
+      mockAxiosInstance.post.mockResolvedValueOnce({ data: mockResult });
+
+      const result = await client.generateTest('session-123', {
+        name: 'Login Test',
+      });
+
+      expect(mockAxiosInstance.post).toHaveBeenCalledWith('/sessions/session-123/generate-test', {
+        name: 'Login Test',
+      });
+      expect(result.yaml).toContain('Login Test');
+      expect(result.block_count).toBe(3);
+    });
+
+    it('should generate test with app_config and variables', async () => {
+      const mockResult = {
+        yaml: 'name: Test with Config\nsteps: []',
+        test_definition: { name: 'Test with Config' },
+        block_count: 5,
+      };
+      mockAxiosInstance.post.mockResolvedValueOnce({ data: mockResult });
+
+      const result = await client.generateTest('session-123', {
+        name: 'Test with Config',
+        app_config: 'my-app-config',
+        variables: { base_url: 'https://staging.example.com' },
+      });
+
+      expect(mockAxiosInstance.post).toHaveBeenCalledWith('/sessions/session-123/generate-test', {
+        name: 'Test with Config',
+        app_config: 'my-app-config',
+        variables: { base_url: 'https://staging.example.com' },
+      });
+      expect(result.block_count).toBe(5);
+    });
+  });
+
+  describe('getConsoleLogs', () => {
+    it('should get console logs', async () => {
+      const mockResult = {
+        logs: [{ level: 'error', text: 'Test error', timestamp: '2026-01-24T10:00:00Z' }],
+        total: 1,
+      };
+      mockAxiosInstance.get.mockResolvedValueOnce({ data: mockResult });
+
+      const result = await client.getConsoleLogs('session-123');
+
+      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/sessions/session-123/logs/console');
+      expect(result.logs).toHaveLength(1);
+      expect(result.logs[0].level).toBe('error');
+    });
+
+    it('should get console logs with filters', async () => {
+      const mockResult = { logs: [], total: 0 };
+      mockAxiosInstance.get.mockResolvedValueOnce({ data: mockResult });
+
+      await client.getConsoleLogs('session-123', { level: 'error', limit: 50 });
+
+      expect(mockAxiosInstance.get).toHaveBeenCalledWith(
+        '/sessions/session-123/logs/console?level=error&limit=50'
+      );
+    });
+
+    it('should get console logs with only level filter', async () => {
+      const mockResult = { logs: [], total: 0 };
+      mockAxiosInstance.get.mockResolvedValueOnce({ data: mockResult });
+
+      await client.getConsoleLogs('session-123', { level: 'warn' });
+
+      expect(mockAxiosInstance.get).toHaveBeenCalledWith(
+        '/sessions/session-123/logs/console?level=warn'
+      );
+    });
+  });
+
+  describe('getNetworkLogs', () => {
+    it('should get network logs', async () => {
+      const mockResult = {
+        requests: [
+          {
+            method: 'GET',
+            url: 'https://api.example.com',
+            status: 200,
+            duration_ms: 150,
+            timestamp: '2026-01-24T10:00:00Z',
+          },
+        ],
+        total: 1,
+      };
+      mockAxiosInstance.get.mockResolvedValueOnce({ data: mockResult });
+
+      const result = await client.getNetworkLogs('session-123');
+
+      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/sessions/session-123/logs/network');
+      expect(result.requests).toHaveLength(1);
+      expect(result.requests[0].status).toBe(200);
+    });
+
+    it('should get network logs with filters', async () => {
+      const mockResult = { requests: [], total: 0 };
+      mockAxiosInstance.get.mockResolvedValueOnce({ data: mockResult });
+
+      await client.getNetworkLogs('session-123', { status: '4xx,5xx', url_pattern: '*api*' });
+
+      expect(mockAxiosInstance.get).toHaveBeenCalledWith(
+        '/sessions/session-123/logs/network?status=4xx%2C5xx&url_pattern=*api*'
+      );
+    });
+
+    it('should get network logs with limit only', async () => {
+      const mockResult = { requests: [], total: 0 };
+      mockAxiosInstance.get.mockResolvedValueOnce({ data: mockResult });
+
+      await client.getNetworkLogs('session-123', { limit: 100 });
+
+      expect(mockAxiosInstance.get).toHaveBeenCalledWith(
+        '/sessions/session-123/logs/network?limit=100'
+      );
+    });
+  });
+
+  describe('createSession with record_blocks', () => {
+    it('should create session with record_blocks enabled', async () => {
+      const mockSession = {
+        id: 'session-rec',
+        status: 'starting',
+        created_at: '2026-01-24T10:00:00Z',
+      };
+      mockAxiosInstance.post.mockResolvedValueOnce({ data: mockSession });
+
+      await client.createSession({
+        record_blocks: true,
+      });
+
+      expect(mockAxiosInstance.post).toHaveBeenCalledWith('/sessions', {
+        headless: true,
+        viewport: 'desktop',
+        timeout: 300,
+        record_blocks: true,
+      });
+    });
+
+    it('should not include record_blocks when not provided', async () => {
+      const mockSession = {
+        id: 'session-no-rec',
+        status: 'starting',
+        created_at: '2026-01-24T10:00:00Z',
+      };
+      mockAxiosInstance.post.mockResolvedValueOnce({ data: mockSession });
+
+      await client.createSession({});
+
+      const callArgs = mockAxiosInstance.post.mock.calls[0];
+      expect(callArgs[1]).not.toHaveProperty('record_blocks');
+    });
+  });
 });

package/lib/api/browser.ts

@@ -10,10 +10,17 @@ import type {
   BrowserAction,
   ActionResult,
   SnapshotResult,
+  SnapshotOptions,
   UrlResult,
   BlocksResult,
   CreateBrowserSessionOptions,
   BrowserSessionStatus,
+  GenerateTestOptions,
+  GenerateTestResult,
+  ConsoleLogsOptions,
+  ConsoleLogsResult,
+  NetworkLogsOptions,
+  NetworkLogsResult,
 } from './browser-types.js';
 import type { ExtendedStep } from '../../src/types/test-definition.js';
 
@@ -67,6 +74,8 @@ export class BrowserApiClient {
         viewport: options.viewport ?? 'desktop',
         timeout: options.timeout ?? 300,
         ...(options.ws_url && { ws_url: options.ws_url }),
+        ...(options.record_blocks !== undefined && { record_blocks: options.record_blocks }),
+        ...(options.after_test_id && { after_test_id: options.after_test_id }),
       });
 
       return response.data as BrowserSession;
@@ -133,11 +142,16 @@ export class BrowserApiClient {
         return session;
       }
 
-      // If session is closed or failed, throw error
+      // If session is closed, throw error
       if (session.status === 'closed') {
         throw new Error(`Session ${sessionId} is closed`);
       }
 
+      // If session failed (e.g., after_test_id test failed), return session for error handling
+      if (session.status === 'failed') {
+        return session;
+      }
+
       // Wait before polling again
       await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
     }
@@ -167,10 +181,21 @@ export class BrowserApiClient {
 
   /**
    * Get the ARIA accessibility tree snapshot
+   * @param sessionId - The session ID
+   * @param options - Filtering options (interactive, compact, max_depth, scope)
    */
-  async getSnapshot(sessionId: string): Promise<SnapshotResult> {
+  async getSnapshot(sessionId: string, options: SnapshotOptions = {}): Promise<SnapshotResult> {
     try {
-      const response = await this.client.get(`/sessions/${sessionId}/snapshot`);
+      const params = new URLSearchParams();
+      if (options.interactive) params.append('interactive', 'true');
+      if (options.compact) params.append('compact', 'true');
+      if (options.max_depth !== undefined) params.append('max_depth', options.max_depth.toString());
+      if (options.scope) params.append('scope', options.scope);
+
+      const queryString = params.toString();
+      const url = `/sessions/${sessionId}/snapshot${queryString ? `?${queryString}` : ''}`;
+
+      const response = await this.client.get(url);
       return response.data as SnapshotResult;
     } catch (error) {
       throw this.handleError(error, 'get snapshot');
@@ -219,6 +244,80 @@ export class BrowserApiClient {
     }
   }
 
+  // ==========================================
+  // Test Generation
+  // ==========================================
+
+  /**
+   * Generate a test definition from recorded session blocks
+   * @param sessionId - The session ID
+   * @param options - Test generation options (name, app_config, variables)
+   * @returns Generated test YAML and metadata
+   */
+  async generateTest(sessionId: string, options: GenerateTestOptions): Promise<GenerateTestResult> {
+    try {
+      const response = await this.client.post(`/sessions/${sessionId}/generate-test`, options);
+      return response.data as GenerateTestResult;
+    } catch (error) {
+      throw this.handleError(error, 'generate test');
+    }
+  }
+
+  // ==========================================
+  // Logs
+  // ==========================================
+
+  /**
+   * Get console logs from a session
+   * @param sessionId - The session ID
+   * @param options - Filter options (level, limit)
+   * @returns Console log entries
+   */
+  async getConsoleLogs(
+    sessionId: string,
+    options: ConsoleLogsOptions = {}
+  ): Promise<ConsoleLogsResult> {
+    try {
+      const params = new URLSearchParams();
+      if (options.level) params.append('level', options.level);
+      if (options.limit !== undefined) params.append('limit', options.limit.toString());
+
+      const queryString = params.toString();
+      const url = `/sessions/${sessionId}/logs/console${queryString ? `?${queryString}` : ''}`;
+
+      const response = await this.client.get(url);
+      return response.data as ConsoleLogsResult;
+    } catch (error) {
+      throw this.handleError(error, 'get console logs');
+    }
+  }
+
+  /**
+   * Get network request logs from a session
+   * @param sessionId - The session ID
+   * @param options - Filter options (status, url_pattern, limit)
+   * @returns Network log entries
+   */
+  async getNetworkLogs(
+    sessionId: string,
+    options: NetworkLogsOptions = {}
+  ): Promise<NetworkLogsResult> {
+    try {
+      const params = new URLSearchParams();
+      if (options.status) params.append('status', options.status);
+      if (options.url_pattern) params.append('url_pattern', options.url_pattern);
+      if (options.limit !== undefined) params.append('limit', options.limit.toString());
+
+      const queryString = params.toString();
+      const url = `/sessions/${sessionId}/logs/network${queryString ? `?${queryString}` : ''}`;
+
+      const response = await this.client.get(url);
+      return response.data as NetworkLogsResult;
+    } catch (error) {
+      throw this.handleError(error, 'get network logs');
+    }
+  }
+
   // ==========================================
   // WebSocket Streaming
   // ==========================================
@@ -273,7 +372,17 @@ export type {
   BrowserAction,
   ActionResult,
   SnapshotResult,
+  SnapshotOptions,
+  SnapshotFilterStats,
   UrlResult,
   CreateBrowserSessionOptions,
   BrowserSessionStatus,
+  GenerateTestOptions,
+  GenerateTestResult,
+  ConsoleLogsOptions,
+  ConsoleLogsResult,
+  ConsoleLogEntry,
+  NetworkLogsOptions,
+  NetworkLogsResult,
+  NetworkLogEntry,
 } from './browser-types.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/qa-use",
-  "version": "2.2.3",
+  "version": "2.2.5",
   "packageManager": "bun@^1.3.4",
   "description": "QA automation tool for browser testing with MCP server support",
   "type": "module",