linkedin-automation-cli 1.0.0

package/src/agent/claude-client.test.ts

@@ -0,0 +1,707 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { ClaudeClient, ClaudeAPIError } from './claude-client';
+import type { DOMRepresentation, ActionContext, ActionPlan } from './types';
+
+describe('ClaudeClient', () => {
+  let client: ClaudeClient;
+  const mockFetch = vi.fn();
+
+  const validConfig = {
+    apiKey: 'test-api-key',
+    model: 'qwen3.5-plus',
+    baseUrl: 'https://coding.dashscope.aliyuncs.com/apps/anthropic/v1',
+  };
+
+  const mockDOM: DOMRepresentation = {
+    url: 'https://linkedin.com/in/test-user',
+    title: 'Test User - LinkedIn',
+    elements: [
+      {
+        id: 'btn-1',
+        tag: 'button',
+        role: 'button',
+        ariaLabel: 'Connect',
+        text: 'Connect',
+        visible: true,
+        enabled: true,
+        bbox: { x: 100, y: 200, width: 120, height: 40 },
+      },
+    ],
+    metadata: {
+      pageType: 'profile',
+      profileName: 'Test User',
+      connectionState: 'not_connected',
+    },
+  };
+
+  const mockContext: ActionContext = {
+    previousActions: [],
+    goal: 'Send a connection request to Test User',
+    retryCount: 0,
+  };
+
+  const createMockResponse = (actionPlan: {
+    reasoning?: string;
+    expectedOutcome?: string;
+    actions?: Record<string, unknown>[];
+    status?: ActionPlan['status'];
+  }) => {
+    return {
+      id: 'msg-123',
+      type: 'message',
+      role: 'assistant',
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            reasoning: actionPlan.reasoning || 'Test reasoning',
+            expectedOutcome: actionPlan.expectedOutcome || 'Test outcome',
+            actions: actionPlan.actions || [],
+            status: actionPlan.status || 'pending',
+          }),
+        },
+      ],
+      model: 'qwen3.5-plus',
+      stop_reason: 'end_turn',
+      stop_sequence: null,
+      usage: {
+        input_tokens: 100,
+        output_tokens: 50,
+      },
+    };
+  };
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    globalThis.fetch = mockFetch;
+    client = new ClaudeClient(validConfig);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should create a client with valid config', () => {
+      const client = new ClaudeClient(validConfig);
+      expect(client).toBeInstanceOf(ClaudeClient);
+    });
+
+    it('should use default baseUrl when not provided', () => {
+      const client = new ClaudeClient({
+        apiKey: 'test-key',
+        model: 'qwen3.5-plus',
+      });
+      expect(client).toBeInstanceOf(ClaudeClient);
+    });
+
+    it('should use default model when not provided', async () => {
+      const client = new ClaudeClient({
+        apiKey: 'test-key',
+        baseUrl: 'https://custom.api.com',
+        model: 'qwen3.5-plus',
+      });
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () =>
+          createMockResponse({
+            actions: [{ type: 'click', elementId: 'btn-1', description: 'Click' }],
+          }),
+      });
+
+      await client.generateActionPlan(mockDOM, mockContext);
+
+      const body = JSON.parse(mockFetch.mock.calls[0][1].body as string);
+      expect(body.model).toBe('qwen3.5-plus');
+    });
+  });
+
+  describe('generateActionPlan', () => {
+    it('should send correct API request', async () => {
+      const mockResponse = createMockResponse({
+        actions: [{ type: 'click', elementId: 'btn-1', description: 'Click connect' }],
+      });
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => mockResponse,
+      } as unknown as globalThis.Response);
+
+      await client.generateActionPlan(mockDOM, mockContext);
+
+      expect(mockFetch).toHaveBeenCalledTimes(1);
+      const [url, options] = mockFetch.mock.calls[0];
+
+      expect(url).toBe(`${validConfig.baseUrl}/messages`);
+      expect(options.method).toBe('POST');
+      expect(options.headers).toEqual({
+        'Content-Type': 'application/json',
+        Authorization: 'Bearer test-api-key',
+      });
+
+      const body = JSON.parse(options.body as string);
+      expect(body.model).toBe('qwen3.5-plus');
+      expect(body.max_tokens).toBe(4096);
+      expect(body.messages).toHaveLength(2);
+      expect(body.messages[0].role).toBe('system');
+      expect(body.messages[1].role).toBe('user');
+    });
+
+    it('should parse successful response into ActionPlan', async () => {
+      const mockResponse = createMockResponse({
+        reasoning: 'Need to click connect button',
+        expectedOutcome: 'Connection request modal opens',
+        actions: [{ type: 'click', elementId: 'btn-1', description: 'Click connect button' }],
+        status: 'pending',
+      });
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => mockResponse,
+      } as unknown as globalThis.Response);
+
+      const plan = await client.generateActionPlan(mockDOM, mockContext);
+
+      expect(plan.reasoning).toBe('Need to click connect button');
+      expect(plan.expectedOutcome).toBe('Connection request modal opens');
+      expect(plan.actions).toHaveLength(1);
+      expect(plan.actions[0].type).toBe('click');
+      expect(plan.status).toBe('pending');
+    });
+
+    it('should include goal and DOM in user message', async () => {
+      const mockResponse = createMockResponse({});
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => mockResponse,
+      } as unknown as globalThis.Response);
+
+      await client.generateActionPlan(mockDOM, mockContext);
+
+      const body = JSON.parse(mockFetch.mock.calls[0][1].body as string);
+      const userMessage = body.messages[1].content;
+
+      expect(userMessage).toContain(`Goal: ${mockContext.goal}`);
+      expect(userMessage).toContain('Current page DOM:');
+      expect(userMessage).toContain(JSON.stringify(mockDOM, null, 2));
+    });
+
+    it('should include previous actions in user message', async () => {
+      const contextWithHistory: ActionContext = {
+        ...mockContext,
+        previousActions: [
+          {
+            action: {
+              type: 'navigate',
+              url: 'https://linkedin.com/in/test-user',
+              description: 'Navigate to profile',
+            },
+            success: true,
+            timestamp: new Date(),
+          },
+          {
+            action: {
+              type: 'click',
+              elementId: 'btn-1',
+              description: 'Click connect',
+            },
+            success: false,
+            timestamp: new Date(),
+            error: 'Element not found',
+          },
+        ],
+      };
+
+      const mockResponse = createMockResponse({});
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => mockResponse,
+      } as unknown as globalThis.Response);
+
+      await client.generateActionPlan(mockDOM, contextWithHistory);
+
+      const body = JSON.parse(mockFetch.mock.calls[0][1].body as string);
+      const userMessage = body.messages[1].content;
+
+      expect(userMessage).toContain('Previous actions taken:');
+      expect(userMessage).toContain('navigate');
+      expect(userMessage).toContain('click');
+      expect(userMessage).toContain('Element not found');
+    });
+
+    it('should handle multiple actions in response', async () => {
+      const mockResponse = createMockResponse({
+        actions: [
+          { type: 'click', elementId: 'btn-1', description: 'Click connect' },
+          { type: 'wait', durationMs: 1000, description: 'Wait for modal' },
+          { type: 'type', elementId: 'input-1', text: 'Hello', description: 'Type note' },
+        ],
+      });
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => mockResponse,
+      } as unknown as globalThis.Response);
+
+      const plan = await client.generateActionPlan(mockDOM, mockContext);
+
+      expect(plan.actions).toHaveLength(3);
+      expect(plan.actions[0].type).toBe('click');
+      expect(plan.actions[1].type).toBe('wait');
+      expect(plan.actions[2].type).toBe('type');
+    });
+  });
+
+  describe('error handling', () => {
+    it('should throw ClaudeAPIError on network failure', async () => {
+      mockFetch.mockRejectedValue(new Error('Network error'));
+
+      await expect(client.generateActionPlan(mockDOM, mockContext)).rejects.toThrow(ClaudeAPIError);
+      await expect(client.generateActionPlan(mockDOM, mockContext)).rejects.toThrow(
+        'Failed to connect to Claude API'
+      );
+    });
+
+    it('should throw ClaudeAPIError on HTTP error status', async () => {
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 401,
+        statusText: 'Unauthorized',
+        text: async () => JSON.stringify({ error: 'Invalid API key' }),
+      });
+
+      await expect(client.generateActionPlan(mockDOM, mockContext)).rejects.toThrow(ClaudeAPIError);
+      await expect(client.generateActionPlan(mockDOM, mockContext)).rejects.toThrow('401');
+    });
+
+    it('should return error plan when response has no text content', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => ({
+          id: 'msg-123',
+          type: 'message',
+          role: 'assistant',
+          content: [
+            { type: 'image', source: { type: 'base64', media_type: 'image/png', data: '' } },
+          ],
+          model: 'qwen3.5-plus',
+          stop_reason: 'end_turn',
+          stop_sequence: null,
+          usage: { input_tokens: 100, output_tokens: 50 },
+        }),
+      });
+
+      const plan = await client.generateActionPlan(mockDOM, mockContext);
+
+      expect(plan.status).toBe('failed');
+      expect(plan.error).toContain('No text content');
+    });
+
+    it('should return error plan when JSON cannot be extracted', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => ({
+          id: 'msg-123',
+          type: 'message',
+          role: 'assistant',
+          content: [{ type: 'text', text: 'Plain text without JSON' }],
+          model: 'qwen3.5-plus',
+          stop_reason: 'end_turn',
+          stop_sequence: null,
+          usage: { input_tokens: 100, output_tokens: 50 },
+        }),
+      });
+
+      const plan = await client.generateActionPlan(mockDOM, mockContext);
+
+      expect(plan.status).toBe('failed');
+      expect(plan.error).toContain('Could not extract JSON');
+    });
+
+    it('should return error plan when JSON is malformed', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => ({
+          id: 'msg-123',
+          type: 'message',
+          role: 'assistant',
+          content: [{ type: 'text', text: '{"invalid json' }],
+          model: 'qwen3.5-plus',
+          stop_reason: 'end_turn',
+          stop_sequence: null,
+          usage: { input_tokens: 100, output_tokens: 50 },
+        }),
+      });
+
+      const plan = await client.generateActionPlan(mockDOM, mockContext);
+
+      expect(plan.status).toBe('failed');
+      expect(plan.error).toContain('Failed to parse');
+    });
+
+    it('should return error plan when response JSON is invalid', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => ({
+          id: 'msg-123',
+          type: 'message',
+          role: 'assistant',
+          content: [{ type: 'text', text: '{"not_a_valid_plan": true}' }],
+          model: 'qwen3.5-plus',
+          stop_reason: 'end_turn',
+          stop_sequence: null,
+          usage: { input_tokens: 100, output_tokens: 50 },
+        }),
+      } as unknown as globalThis.Response);
+
+      const plan = await client.generateActionPlan(mockDOM, mockContext);
+
+      expect(plan.status).toBe('pending');
+      expect(plan.actions).toEqual([]);
+      expect(plan.reasoning).toBe('No reasoning provided');
+    });
+  });
+
+  describe('JSON extraction', () => {
+    it('should extract JSON from markdown code blocks', async () => {
+      const actionPlan = {
+        reasoning: 'Test',
+        expectedOutcome: 'Test outcome',
+        actions: [{ type: 'click', elementId: 'btn-1', description: 'Click' }],
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => ({
+          id: 'msg-123',
+          type: 'message',
+          role: 'assistant',
+          content: [{ type: 'text', text: `\`\`\`json\n${JSON.stringify(actionPlan)}\n\`\`\`` }],
+          model: 'qwen3.5-plus',
+          stop_reason: 'end_turn',
+          stop_sequence: null,
+          usage: { input_tokens: 100, output_tokens: 50 },
+        }),
+      });
+
+      const plan = await client.generateActionPlan(mockDOM, mockContext);
+
+      expect(plan.reasoning).toBe('Test');
+      expect(plan.actions).toHaveLength(1);
+    });
+
+    it('should extract JSON without language specifier', async () => {
+      const actionPlan = {
+        reasoning: 'Test',
+        expectedOutcome: 'Test outcome',
+        actions: [{ type: 'click', elementId: 'btn-1', description: 'Click' }],
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => ({
+          id: 'msg-123',
+          type: 'message',
+          role: 'assistant',
+          content: [{ type: 'text', text: `\`\`\`\n${JSON.stringify(actionPlan)}\n\`\`\`` }],
+          model: 'qwen3.5-plus',
+          stop_reason: 'end_turn',
+          stop_sequence: null,
+          usage: { input_tokens: 100, output_tokens: 50 },
+        }),
+      });
+
+      const plan = await client.generateActionPlan(mockDOM, mockContext);
+
+      expect(plan.reasoning).toBe('Test');
+    });
+
+    it('should extract JSON from raw text starting with {', async () => {
+      const actionPlan = {
+        reasoning: 'Test',
+        expectedOutcome: 'Test outcome',
+        actions: [],
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => ({
+          id: 'msg-123',
+          type: 'message',
+          role: 'assistant',
+          content: [{ type: 'text', text: JSON.stringify(actionPlan) }],
+          model: 'qwen3.5-plus',
+          stop_reason: 'end_turn',
+          stop_sequence: null,
+          usage: { input_tokens: 100, output_tokens: 50 },
+        }),
+      });
+
+      const plan = await client.generateActionPlan(mockDOM, mockContext);
+
+      expect(plan.reasoning).toBe('Test');
+    });
+  });
+
+  describe('action transformation', () => {
+    it('should transform click actions correctly', async () => {
+      const mockResponse = createMockResponse({
+        actions: [{ type: 'click', elementId: 'btn-1', description: 'Click button' }],
+      });
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => mockResponse,
+      } as unknown as globalThis.Response);
+
+      const plan = await client.generateActionPlan(mockDOM, mockContext);
+
+      expect(plan.actions[0]).toEqual({
+        type: 'click',
+        elementId: 'btn-1',
+        description: 'Click button',
+      });
+    });
+
+    it('should transform type actions correctly', async () => {
+      const mockResponse = createMockResponse({
+        actions: [
+          { type: 'type', elementId: 'input-1', text: 'Hello', description: 'Type greeting' },
+        ],
+      });
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => mockResponse,
+      } as unknown as globalThis.Response);
+
+      const plan = await client.generateActionPlan(mockDOM, mockContext);
+
+      expect(plan.actions[0]).toEqual({
+        type: 'type',
+        elementId: 'input-1',
+        text: 'Hello',
+        description: 'Type greeting',
+      });
+    });
+
+    it('should transform wait actions correctly', async () => {
+      const mockResponse = createMockResponse({
+        actions: [{ type: 'wait', durationMs: 2000, description: 'Wait for load' }],
+      });
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => mockResponse,
+      } as unknown as globalThis.Response);
+
+      const plan = await client.generateActionPlan(mockDOM, mockContext);
+
+      expect(plan.actions[0]).toEqual({
+        type: 'wait',
+        durationMs: 2000,
+        description: 'Wait for load',
+      });
+    });
+
+    it('should transform navigate actions correctly', async () => {
+      const mockResponse = createMockResponse({
+        actions: [{ type: 'navigate', url: 'https://linkedin.com', description: 'Go to home' }],
+      });
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => mockResponse,
+      } as unknown as globalThis.Response);
+
+      const plan = await client.generateActionPlan(mockDOM, mockContext);
+
+      expect(plan.actions[0]).toEqual({
+        type: 'navigate',
+        url: 'https://linkedin.com',
+        description: 'Go to home',
+      });
+    });
+
+    it('should use default duration for wait actions without durationMs', async () => {
+      const mockResponse = createMockResponse({
+        actions: [{ type: 'wait', description: 'Wait' }],
+      });
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => mockResponse,
+      } as unknown as globalThis.Response);
+
+      const plan = await client.generateActionPlan(mockDOM, mockContext);
+
+      expect(plan.actions[0]).toEqual({
+        type: 'wait',
+        durationMs: 1000,
+        description: 'Wait',
+      });
+    });
+
+    it('should skip actions with missing required fields', async () => {
+      const mockResponse = createMockResponse({
+        actions: [
+          { type: 'click', description: 'Missing elementId' },
+          { type: 'type', elementId: 'input-1', description: 'Missing text' },
+          { type: 'navigate', description: 'Missing url' },
+          { type: 'click', elementId: 'btn-1', description: 'Valid click' },
+        ],
+      });
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => mockResponse,
+      } as unknown as globalThis.Response);
+
+      const plan = await client.generateActionPlan(mockDOM, mockContext);
+
+      expect(plan.actions).toHaveLength(1);
+      expect(plan.actions[0].type).toBe('click');
+      expect((plan.actions[0] as { elementId: string }).elementId).toBe('btn-1');
+    });
+
+    it('should skip unknown action types', async () => {
+      const mockResponse = createMockResponse({
+        actions: [
+          { type: 'unknown_action', description: 'Unknown' },
+          { type: 'click', elementId: 'btn-1', description: 'Valid click' },
+        ],
+      });
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => mockResponse,
+      } as unknown as globalThis.Response);
+
+      const plan = await client.generateActionPlan(mockDOM, mockContext);
+
+      expect(plan.actions).toHaveLength(1);
+      expect(plan.actions[0].type).toBe('click');
+    });
+  });
+
+  describe('status validation', () => {
+    it('should accept valid status values', async () => {
+      const statuses = ['pending', 'in_progress', 'completed', 'failed', 'cancelled'];
+
+      for (const status of statuses) {
+        mockFetch.mockResolvedValueOnce({
+          ok: true,
+          status: 200,
+          statusText: 'OK',
+          json: async () =>
+            createMockResponse({
+              status: status as ActionPlan['status'],
+            }),
+        });
+
+        const plan = await client.generateActionPlan(mockDOM, mockContext);
+        expect(plan.status).toBe(status);
+      }
+    });
+
+    it('should default to pending for invalid status values', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () =>
+          createMockResponse({
+            status: 'invalid_status' as ActionPlan['status'],
+          }),
+      });
+
+      const plan = await client.generateActionPlan(mockDOM, mockContext);
+
+      expect(plan.status).toBe('pending');
+    });
+
+    it('should default to pending when status is undefined', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () =>
+          createMockResponse({
+            status: undefined,
+          }),
+      });
+
+      const plan = await client.generateActionPlan(mockDOM, mockContext);
+
+      expect(plan.status).toBe('pending');
+    });
+  });
+
+  describe('system prompt', () => {
+    it('should include system prompt explaining agent role', async () => {
+      const mockResponse = createMockResponse({});
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => mockResponse,
+      } as unknown as globalThis.Response);
+
+      await client.generateActionPlan(mockDOM, mockContext);
+
+      const body = JSON.parse(mockFetch.mock.calls[0][1].body as string);
+      const systemMessage = body.messages[0].content;
+
+      expect(systemMessage).toContain('web automation agent');
+      expect(systemMessage).toContain('JSON');
+      expect(systemMessage).toContain('click');
+      expect(systemMessage).toContain('type');
+      expect(systemMessage).toContain('wait');
+      expect(systemMessage).toContain('navigate');
+    });
+  });
+});