claude-code-inspector 0.1.0

package/lib/proxy/forwarder.test.ts

@@ -0,0 +1,171 @@
+import { describe, it, expect } from 'vitest';
+import {
+  extractSessionId,
+  extractUsage,
+  buildForwardHeaders,
+  isSseResponse,
+} from './forwarder';
+
+describe('extractSessionId', () => {
+  it('should extract session id from headers (lowercase)', () => {
+    const headers = { 'x-session-id': 'session-123' };
+    const body = {};
+    expect(extractSessionId(headers, body)).toBe('session-123');
+  });
+
+  it('should extract session id from headers (uppercase)', () => {
+    const headers = { 'X-Session-Id': 'session-456' };
+    const body = {};
+    expect(extractSessionId(headers, body)).toBe('session-456');
+  });
+
+  it('should extract session id from body metadata', () => {
+    const headers = {};
+    const body = { metadata: { session_id: 'session-789' } };
+    expect(extractSessionId(headers, body)).toBe('session-789');
+  });
+
+  it('should prioritize headers over body', () => {
+    const headers = { 'x-session-id': 'header-session' };
+    const body = { metadata: { session_id: 'body-session' } };
+    expect(extractSessionId(headers, body)).toBe('header-session');
+  });
+
+  it('should return null when no session id found', () => {
+    const headers = {};
+    const body = {};
+    expect(extractSessionId(headers, body)).toBeNull();
+  });
+});
+
+describe('extractUsage', () => {
+  it('should extract usage from response', () => {
+    const response = {
+      usage: {
+        input_tokens: 100,
+        output_tokens: 50,
+        cache_read_input_tokens: 20,
+        cache_creation_input_tokens: 10,
+      },
+    };
+    const result = extractUsage(response);
+    expect(result).toEqual({
+      input_tokens: 100,
+      output_tokens: 50,
+      cache_read_tokens: 20,
+      cache_creation_tokens: 10,
+    });
+  });
+
+  it('should return zeros when no usage', () => {
+    const response = {};
+    const result = extractUsage(response);
+    expect(result).toEqual({
+      input_tokens: 0,
+      output_tokens: 0,
+      cache_read_tokens: 0,
+      cache_creation_tokens: 0,
+    });
+  });
+
+  it('should handle partial usage', () => {
+    const response = {
+      usage: {
+        input_tokens: 100,
+        output_tokens: 50,
+      },
+    };
+    const result = extractUsage(response);
+    expect(result).toEqual({
+      input_tokens: 100,
+      output_tokens: 50,
+      cache_read_tokens: 0,
+      cache_creation_tokens: 0,
+    });
+  });
+
+  it('should handle null response', () => {
+    const result = extractUsage(null);
+    expect(result).toEqual({
+      input_tokens: 0,
+      output_tokens: 0,
+      cache_read_tokens: 0,
+      cache_creation_tokens: 0,
+    });
+  });
+});
+
+describe('buildForwardHeaders', () => {
+  it('should build headers with api key', () => {
+    const originalHeaders = {};
+    const config = { baseUrl: 'https://api.example.com', apiKey: 'test-key' };
+    const result = buildForwardHeaders(originalHeaders, config);
+    expect(result).toEqual({
+      'Content-Type': 'application/json',
+      'Authorization': 'Bearer test-key',
+    });
+  });
+
+  it('should preserve specific headers', () => {
+    const originalHeaders = {
+      'x-api-key': 'original-key',
+      'x-request-id': 'req-123',
+      'user-agent': 'test-agent',
+      'other-header': 'should-not-preserve',
+    };
+    const config = { baseUrl: 'https://api.example.com', apiKey: 'test-key' };
+    const result = buildForwardHeaders(originalHeaders, config);
+    expect(result['x-api-key']).toBe('original-key');
+    expect(result['x-request-id']).toBe('req-123');
+    expect(result['user-agent']).toBe('test-agent');
+    expect(result['other-header']).toBeUndefined();
+  });
+
+  it('should not preserve headers that are not in the list', () => {
+    const originalHeaders = {
+      'some-random-header': 'value',
+    };
+    const config = { baseUrl: 'https://api.example.com', apiKey: 'test-key' };
+    const result = buildForwardHeaders(originalHeaders, config);
+    expect(result['some-random-header']).toBeUndefined();
+  });
+});
+
+describe('isSseResponse', () => {
+  it('should return true for text/event-stream content type', () => {
+    const response = {
+      headers: {
+        'content-type': 'text/event-stream',
+      },
+    };
+    expect(isSseResponse(response)).toBe(true);
+  });
+
+  it('should return true for text/event-stream with charset', () => {
+    const response = {
+      headers: {
+        'content-type': 'text/event-stream; charset=utf-8',
+      },
+    };
+    expect(isSseResponse(response)).toBe(true);
+  });
+
+  it('should return false for application/json', () => {
+    const response = {
+      headers: {
+        'content-type': 'application/json',
+      },
+    };
+    expect(isSseResponse(response)).toBe(false);
+  });
+
+  it('should return false when no content-type', () => {
+    const response = { headers: {} };
+    expect(isSseResponse(response)).toBe(false);
+  });
+
+  it('should return false when no headers', () => {
+    const response = {};
+    expect(isSseResponse(response)).toBe(false);
+  });
+});

package/lib/proxy/forwarder.ts

@@ -0,0 +1,96 @@
+import axios from 'axios';
+
+export interface UpstreamConfig {
+  baseUrl: string;
+  apiKey: string;
+}
+
+/**
+ * 提取 Session ID
+ */
+export function extractSessionId(headers: Record<string, string>, body: any): string | null {
+  return (
+    headers['x-session-id'] ||
+    headers['X-Session-Id'] ||
+    body?.metadata?.session_id ||
+    null
+  );
+}
+
+/**
+ * 提取 Token 使用量
+ */
+export function extractUsage(response: any): {
+  input_tokens: number;
+  output_tokens: number;
+  cache_read_tokens: number;
+  cache_creation_tokens: number;
+} {
+  const usage = response?.usage;
+  if (!usage) {
+    return {
+      input_tokens: 0,
+      output_tokens: 0,
+      cache_read_tokens: 0,
+      cache_creation_tokens: 0,
+    };
+  }
+
+  return {
+    input_tokens: usage.input_tokens || 0,
+    output_tokens: usage.output_tokens || 0,
+    cache_read_tokens: usage.cache_read_input_tokens || 0,
+    cache_creation_tokens: usage.cache_creation_input_tokens || 0,
+  };
+}
+
+/**
+ * 构建转发 Headers
+ */
+export function buildForwardHeaders(
+  originalHeaders: Record<string, string>,
+  config: UpstreamConfig
+): Record<string, string> {
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    'Authorization': `Bearer ${config.apiKey}`,
+  };
+
+  // 保留部分原始 headers
+  const preserveHeaders = ['x-api-key', 'x-request-id', 'user-agent'];
+  for (const key of preserveHeaders) {
+    if (originalHeaders[key]) {
+      headers[key] = originalHeaders[key];
+    }
+  }
+
+  return headers;
+}
+
+/**
+ * 判断是否为 SSE 响应
+ */
+export function isSseResponse(response: any): boolean {
+  const contentType = response?.headers?.['content-type'] || '';
+  return contentType.includes('text/event-stream');
+}
+
+/**
+ * 转发请求到上游 API
+ */
+export async function forwardRequest(
+  endpoint: string,
+  body: any,
+  headers: Record<string, string>,
+  config: UpstreamConfig
+): Promise<any> {
+  const url = `${config.baseUrl}${endpoint}`;
+
+
+  const forwardHeaders = buildForwardHeaders(headers, config);
+
+  return axios.post(url, body, {
+    headers: forwardHeaders,
+    responseType: 'stream',
+  });
+}

package/lib/proxy/handlers.test.ts

@@ -0,0 +1,276 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// Mock dependencies before importing
+vi.mock('../recorder', () => ({
+  recordRequest: vi.fn(),
+  updateRequestResponse: vi.fn(),
+  recordSseEvent: vi.fn(),
+}));
+
+vi.mock('./ws-server', () => ({
+  broadcastNewRequest: vi.fn(),
+  broadcastRequestUpdate: vi.fn(),
+  broadcastSseEvent: vi.fn(),
+}));
+
+vi.mock('uuid', () => ({
+  v4: () => 'test-uuid-1234',
+}));
+
+vi.mock('../../lib/env', () => ({
+  initEnv: vi.fn(),
+}));
+
+// Mock axios to avoid actual network requests
+vi.mock('axios', () => ({
+  default: {
+    post: vi.fn(),
+  },
+}));
+
+import axios from 'axios';
+import { recordRequest, updateRequestResponse } from '../recorder';
+import { broadcastNewRequest, broadcastRequestUpdate } from './ws-server';
+
+// Import after mocking
+const { handleMessages } = await import('./handlers');
+
+const mockAxios = vi.mocked(axios);
+const mockRecordRequest = vi.mocked(recordRequest);
+const mockUpdateRequestResponse = vi.mocked(updateRequestResponse);
+const mockBroadcastNewRequest = vi.mocked(broadcastNewRequest);
+const mockBroadcastRequestUpdate = vi.mocked(broadcastRequestUpdate);
+
+describe('handlers', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Set environment variables for testing
+    process.env.UPSTREAM_BASE_URL = 'https://api.anthropic.com';
+    process.env.UPSTREAM_API_KEY = 'test-api-key';
+    process.env.ANTHROPIC_API_KEY = 'test-api-key';
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('handleMessages - non-streaming response', () => {
+    it('should handle non-streaming response correctly', async () => {
+      // Create a simple mock response (not axios-like with circular refs)
+      const mockResponse = {
+        status: 200,
+        headers: {
+          'content-type': 'application/json',
+          'x-request-id': 'req-123',
+        },
+        data: {
+          id: 'msg-123',
+          type: 'message',
+          role: 'assistant',
+          content: [{ type: 'text', text: 'Hello!' }],
+          usage: {
+            input_tokens: 10,
+            output_tokens: 5,
+          },
+        },
+      };
+
+      // Mock axios.post to return a stream-like response that we convert
+      const mockStream = {
+        async *[Symbol.asyncIterator]() {
+          yield Buffer.from(JSON.stringify(mockResponse.data));
+        },
+      };
+
+      mockAxios.post.mockResolvedValueOnce({
+        ...mockResponse,
+        data: mockStream,
+        headers: mockResponse.headers,
+      });
+
+      const request = new Request('http://localhost:3000/v1/messages', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ model: 'claude-3-opus', messages: [] }),
+      });
+
+      const body = { model: 'claude-3-opus', messages: [] };
+      const headers = { 'content-type': 'application/json' };
+
+      const result = await handleMessages(request, body, headers);
+
+      // Verify request was recorded
+      expect(mockRecordRequest).toHaveBeenCalled();
+      expect(mockBroadcastNewRequest).toHaveBeenCalled();
+    });
+
+    it('should serialize headers without circular reference error', async () => {
+      // This test specifically addresses the bug we fixed:
+      // "TypeError: Converting circular structure to JSON"
+      // caused by axios response headers having circular references
+
+      // Simulate axios response with headers that would fail JSON.stringify
+      const mockResponse = {
+        status: 200,
+        // These headers simulate what axios returns (could have circular refs)
+        headers: {
+          'content-type': 'application/json',
+          'x-request-id': 'req-123',
+        },
+        data: {
+          usage: { input_tokens: 10, output_tokens: 5 },
+        },
+      };
+
+      const mockStream = {
+        async *[Symbol.asyncIterator]() {
+          yield Buffer.from(JSON.stringify(mockResponse.data));
+        },
+      };
+
+      mockAxios.post.mockResolvedValueOnce({
+        ...mockResponse,
+        data: mockStream,
+        headers: mockResponse.headers,
+      });
+
+      const body = { model: 'claude-3-opus' };
+      const headers = {};
+
+      await handleMessages(new Request('http://localhost:3000/v1/messages'), body, headers);
+
+      // The key test: updateRequestResponse should be called with serializable headers
+      expect(mockUpdateRequestResponse).toHaveBeenCalled();
+
+      // Get the headers passed to updateRequestResponse
+      const callArgs = mockUpdateRequestResponse.mock.calls[0][0];
+
+      // This should not throw "Converting circular structure to JSON"
+      expect(() => JSON.stringify(callArgs.headers)).not.toThrow();
+
+      // Headers should be a simple object
+      expect(typeof callArgs.headers).toBe('object');
+    });
+  });
+
+  describe('handleMessages - error handling', () => {
+    it('should handle request errors', async () => {
+      const error = new Error('Network error');
+      mockAxios.post.mockRejectedValueOnce(error);
+
+      const body = { model: 'claude-3-opus' };
+      const headers = {};
+
+      const result = await handleMessages(
+        new Request('http://localhost:3000/v1/messages'),
+        body,
+        headers
+      );
+
+      expect(result.status).toBe(500);
+      const responseBody = await result.json();
+      expect(responseBody.error).toBe('Network error');
+    });
+
+    it('should handle API errors with status code', async () => {
+      const apiError = {
+        response: {
+          status: 429,
+          data: { error: { message: 'Rate limit exceeded' } },
+        },
+      };
+      mockAxios.post.mockRejectedValueOnce(apiError);
+
+      const body = { model: 'claude-3-opus' };
+      const headers = {};
+
+      const result = await handleMessages(
+        new Request('http://localhost:3000/v1/messages'),
+        body,
+        headers
+      );
+
+      expect(result.status).toBe(429);
+      const responseBody = await result.json();
+      expect(responseBody.error).toBe('Rate limit exceeded');
+    });
+  });
+
+  describe('environment configuration', () => {
+    it('should use UPSTREAM_* variables for forwarding', async () => {
+      process.env.UPSTREAM_BASE_URL = 'https://custom-api.example.com';
+      process.env.UPSTREAM_API_KEY = 'custom-key';
+      process.env.ANTHROPIC_BASE_URL = 'http://localhost:3000'; // Should NOT be used
+
+      const mockResponse = {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+        data: { usage: { input_tokens: 10, output_tokens: 5 } },
+      };
+
+      const mockStream = {
+        async *[Symbol.asyncIterator]() {
+          yield Buffer.from(JSON.stringify(mockResponse.data));
+        },
+      };
+
+      mockAxios.post.mockResolvedValueOnce({
+        ...mockResponse,
+        data: mockStream,
+      });
+
+      const body = { model: 'claude-3-opus' };
+      const headers = {};
+
+      await handleMessages(new Request('http://localhost:3000/v1/messages'), body, headers);
+
+      // Verify axios was called with the correct URL
+      expect(mockAxios.post).toHaveBeenCalledWith(
+        'https://custom-api.example.com/v1/messages',
+        expect.anything(),
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer custom-key',
+          }),
+        })
+      );
+    });
+
+    it('should fallback to ANTHROPIC_API_KEY if UPSTREAM_API_KEY not set', async () => {
+      delete process.env.UPSTREAM_API_KEY;
+      process.env.ANTHROPIC_API_KEY = 'anthropic-key';
+
+      const mockResponse = {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+        data: { usage: { input_tokens: 10, output_tokens: 5 } },
+      };
+
+      const mockStream = {
+        async *[Symbol.asyncIterator]() {
+          yield Buffer.from(JSON.stringify(mockResponse.data));
+        },
+      };
+
+      mockAxios.post.mockResolvedValueOnce({
+        ...mockResponse,
+        data: mockStream,
+      });
+
+      const body = { model: 'claude-3-opus' };
+      const headers = {};
+
+      await handleMessages(new Request('http://localhost:3000/v1/messages'), body, headers);
+
+      expect(mockAxios.post).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.anything(),
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer anthropic-key',
+          }),
+        })
+      );
+    });
+  });
+});