onbuzz 3.3.0

package/src/interfaces/terminal/__tests__/smoke/tools.test.js

@@ -0,0 +1,388 @@
+/**
+ * Tools Management - Smoke Tests
+ * Verifies that tools management modules can be imported and basic functionality works
+ */
+
+import { describe, test, expect } from '@jest/globals';
+
+describe('Tools Management - Imports', () => {
+  test('useTools hook can be imported', async () => {
+    const { useTools } = await import('../../state/useTools.js');
+
+    expect(useTools).toBeDefined();
+    expect(typeof useTools).toBe('function');
+  });
+
+  test('useTools is default export', async () => {
+    const module = await import('../../state/useTools.js');
+
+    expect(module.default).toBeDefined();
+    expect(typeof module.default).toBe('function');
+    expect(module.default).toBe(module.useTools);
+  });
+});
+
+describe('Tools Management - Constants', () => {
+  test('TOOL_CATEGORY constants are defined', async () => {
+    const { TOOL_CATEGORY } = await import('../../config/constants.js');
+
+    expect(TOOL_CATEGORY).toBeDefined();
+    expect(TOOL_CATEGORY.SYSTEM).toBeDefined();
+    expect(TOOL_CATEGORY.AUTOMATION).toBeDefined();
+    expect(TOOL_CATEGORY.ANALYSIS).toBeDefined();
+    expect(TOOL_CATEGORY.UTILITY).toBeDefined();
+    expect(TOOL_CATEGORY.COLLABORATION).toBeDefined();
+    expect(TOOL_CATEGORY.AI).toBeDefined();
+  });
+
+  test('TOOL_CATEGORY values are lowercase', async () => {
+    const { TOOL_CATEGORY } = await import('../../config/constants.js');
+
+    expect(TOOL_CATEGORY.SYSTEM).toBe(TOOL_CATEGORY.SYSTEM.toLowerCase());
+    expect(TOOL_CATEGORY.AUTOMATION).toBe(TOOL_CATEGORY.AUTOMATION.toLowerCase());
+    expect(TOOL_CATEGORY.ANALYSIS).toBe(TOOL_CATEGORY.ANALYSIS.toLowerCase());
+    expect(TOOL_CATEGORY.UTILITY).toBe(TOOL_CATEGORY.UTILITY.toLowerCase());
+  });
+
+  test('Tools API endpoint is defined', async () => {
+    const { API_ENDPOINTS } = await import('../../config/constants.js');
+
+    expect(API_ENDPOINTS.TOOLS).toBeDefined();
+    expect(API_ENDPOINTS.TOOLS).toBe('/api/tools');
+  });
+
+  test('Orchestrator endpoint is used for tool operations', async () => {
+    const { API_ENDPOINTS } = await import('../../config/constants.js');
+
+    expect(API_ENDPOINTS.ORCHESTRATOR).toBeDefined();
+    expect(API_ENDPOINTS.ORCHESTRATOR).toBe('/api/orchestrator');
+  });
+});
+
+describe('Tools Management - Integration', () => {
+  test('useTools hook integrates with Session and MessageRouter', async () => {
+    const { useTools } = await import('../../state/useTools.js');
+    const { SessionManager } = await import('../../api/session.js');
+    const { MessageRouter } = await import('../../api/messageRouter.js');
+    const { WebSocketManager } = await import('../../api/websocket.js');
+
+    // Create dependencies
+    const sessionManager = new SessionManager('localhost', 8080);
+    const wsManager = new WebSocketManager('localhost', 8080);
+    const messageRouter = new MessageRouter(wsManager);
+
+    // Verify all components exist
+    expect(sessionManager).toBeDefined();
+    expect(messageRouter).toBeDefined();
+
+    // useTools expects these as parameters (including currentAgentId)
+    // (we can't actually call the hook outside React, but we verify the interface)
+    expect(typeof useTools).toBe('function');
+  });
+
+  test('Full tools management stack can be imported together', async () => {
+    const [
+      constantsModule,
+      sessionModule,
+      websocketModule,
+      routerModule,
+      toolsModule,
+    ] = await Promise.all([
+      import('../../config/constants.js'),
+      import('../../api/session.js'),
+      import('../../api/websocket.js'),
+      import('../../api/messageRouter.js'),
+      import('../../state/useTools.js'),
+    ]);
+
+    // Verify all modules loaded
+    expect(constantsModule.TOOL_CATEGORY).toBeDefined();
+    expect(constantsModule.API_ENDPOINTS).toBeDefined();
+    expect(sessionModule.SessionManager).toBeDefined();
+    expect(websocketModule.WebSocketManager).toBeDefined();
+    expect(routerModule.MessageRouter).toBeDefined();
+    expect(toolsModule.useTools).toBeDefined();
+  });
+});
+
+describe('Tools Management - API Endpoints Validation', () => {
+  test('Tools endpoint follows RESTful pattern', async () => {
+    const { API_ENDPOINTS } = await import('../../config/constants.js');
+
+    // Verify endpoint path
+    expect(API_ENDPOINTS.TOOLS).toMatch(/^\/api\//);
+    expect(API_ENDPOINTS.TOOLS).toBe('/api/tools');
+  });
+
+  test('Tool operations use orchestrator endpoint', async () => {
+    const { API_ENDPOINTS } = await import('../../config/constants.js');
+
+    // Tool execution, enable/disable use orchestrator
+    expect(API_ENDPOINTS.ORCHESTRATOR).toBeDefined();
+    expect(API_ENDPOINTS.ORCHESTRATOR).toBe('/api/orchestrator');
+  });
+});
+
+describe('Tools Management - Hook Interface Verification', () => {
+  test('useTools returns expected interface shape', async () => {
+    const { useTools } = await import('../../state/useTools.js');
+
+    // We can verify the function signature
+    expect(useTools.length).toBe(3); // sessionManager, messageRouter, currentAgentId
+  });
+});
+
+describe('Tools Management - Constants Validation', () => {
+  test('TOOL_CATEGORY includes all major categories', async () => {
+    const { TOOL_CATEGORY } = await import('../../config/constants.js');
+
+    const categories = Object.keys(TOOL_CATEGORY);
+    expect(categories).toContain('SYSTEM');
+    expect(categories).toContain('AUTOMATION');
+    expect(categories).toContain('ANALYSIS');
+    expect(categories).toContain('UTILITY');
+    expect(categories).toContain('COLLABORATION');
+    expect(categories).toContain('AI');
+  });
+
+  test('TOOL_CATEGORY values match expected format', async () => {
+    const { TOOL_CATEGORY } = await import('../../config/constants.js');
+
+    // Values should be lowercase
+    expect(TOOL_CATEGORY.SYSTEM).toMatch(/^[a-z_]+$/);
+    expect(TOOL_CATEGORY.AUTOMATION).toMatch(/^[a-z_]+$/);
+    expect(TOOL_CATEGORY.ANALYSIS).toMatch(/^[a-z_]+$/);
+    expect(TOOL_CATEGORY.UTILITY).toMatch(/^[a-z_]+$/);
+  });
+});
+
+describe('Tools Management - WebSocket Event Handlers', () => {
+  test('MessageRouter has tool event handlers registered', async () => {
+    const { MessageRouter } = await import('../../api/messageRouter.js');
+    const { WebSocketManager } = await import('../../api/websocket.js');
+
+    const wsManager = new WebSocketManager('localhost', 8080);
+    const router = new MessageRouter(wsManager);
+
+    // Verify tool event handlers are registered
+    // These would be registered by the useTools hook when mounted
+    expect(router.hasHandler).toBeDefined();
+    expect(typeof router.hasHandler).toBe('function');
+  });
+});
+
+describe('Tools Management - Tool Categorization', () => {
+  test('TOOL_CATEGORY can be used to filter tools by category', async () => {
+    const { TOOL_CATEGORY } = await import('../../config/constants.js');
+
+    // Mock tool list
+    const mockTools = [
+      { name: 'execute_command', category: TOOL_CATEGORY.SYSTEM },
+      { name: 'terminal', category: TOOL_CATEGORY.SYSTEM },
+      { name: 'analyze_code', category: TOOL_CATEGORY.ANALYSIS },
+      { name: 'web_search', category: TOOL_CATEGORY.UTILITY },
+      { name: 'ai_assistant', category: TOOL_CATEGORY.AI },
+    ];
+
+    // Filter by category
+    const systemTools = mockTools.filter(t => t.category === TOOL_CATEGORY.SYSTEM);
+    const analysisTools = mockTools.filter(t => t.category === TOOL_CATEGORY.ANALYSIS);
+    const utilityTools = mockTools.filter(t => t.category === TOOL_CATEGORY.UTILITY);
+    const aiTools = mockTools.filter(t => t.category === TOOL_CATEGORY.AI);
+
+    expect(systemTools.length).toBe(2);
+    expect(analysisTools.length).toBe(1);
+    expect(utilityTools.length).toBe(1);
+    expect(aiTools.length).toBe(1);
+
+    expect(systemTools[0].name).toBe('execute_command');
+    expect(analysisTools[0].name).toBe('analyze_code');
+  });
+});
+
+describe('Tools Management - Tool Search', () => {
+  test('Tool search should work with name and description', async () => {
+    // Mock tool list
+    const mockTools = [
+      { name: 'read_file', description: 'Read contents of a file' },
+      { name: 'write_file', description: 'Write data to a file' },
+      { name: 'analyze_code', description: 'Perform static code analysis' },
+    ];
+
+    // Search by name
+    const searchByName = (query) => {
+      const lowerQuery = query.toLowerCase();
+      return mockTools.filter(t =>
+        t.name?.toLowerCase().includes(lowerQuery) ||
+        t.description?.toLowerCase().includes(lowerQuery)
+      );
+    };
+
+    const fileTools = searchByName('file');
+    expect(fileTools.length).toBe(2);
+    expect(fileTools.map(t => t.name)).toContain('read_file');
+    expect(fileTools.map(t => t.name)).toContain('write_file');
+
+    const analyzeTools = searchByName('analyze');
+    expect(analyzeTools.length).toBe(1);
+    expect(analyzeTools[0].name).toBe('analyze_code');
+  });
+});
+
+describe('Tools Management - Execution State Tracking', () => {
+  test('Execution state can track multiple tools', async () => {
+    // Mock execution tracking
+    const executingTools = new Set();
+
+    // Start execution
+    executingTools.add('read_file');
+    executingTools.add('analyze_code');
+
+    expect(executingTools.has('read_file')).toBe(true);
+    expect(executingTools.has('analyze_code')).toBe(true);
+    expect(executingTools.size).toBe(2);
+
+    // Complete execution
+    executingTools.delete('read_file');
+
+    expect(executingTools.has('read_file')).toBe(false);
+    expect(executingTools.has('analyze_code')).toBe(true);
+    expect(executingTools.size).toBe(1);
+  });
+
+  test('Tool results can be stored by execution ID', async () => {
+    // Mock tool results storage
+    const toolResults = new Map();
+
+    // Store results
+    toolResults.set('exec-1', { success: true, data: 'file contents' });
+    toolResults.set('exec-2', { success: true, data: { issues: [] } });
+
+    expect(toolResults.get('exec-1')).toBeDefined();
+    expect(toolResults.get('exec-1').success).toBe(true);
+    expect(toolResults.get('exec-1').data).toBe('file contents');
+
+    expect(toolResults.get('exec-2')).toBeDefined();
+    expect(toolResults.get('exec-2').data.issues).toEqual([]);
+
+    expect(toolResults.size).toBe(2);
+  });
+});
+
+describe('Tools Management - Tool Caching', () => {
+  test('Tool cache supports TTL-based caching', async () => {
+    const CACHE_TTL = 600000; // 10 minutes
+
+    // Mock cache
+    let toolsCache = null;
+    let toolsCacheTimestamp = 0;
+
+    // Initial fetch
+    const mockTools = [{ name: 'read_file' }];
+    toolsCache = mockTools;
+    toolsCacheTimestamp = Date.now();
+
+    // Check cache validity
+    const now = Date.now();
+    const isCacheValid = (now - toolsCacheTimestamp) < CACHE_TTL;
+
+    expect(isCacheValid).toBe(true);
+    expect(toolsCache).toBe(mockTools);
+  });
+
+  test('Tool cache expires after TTL', async () => {
+    const CACHE_TTL = 100; // 100ms for testing
+
+    // Mock cache
+    let toolsCache = null;
+    let toolsCacheTimestamp = 0;
+
+    // Initial fetch
+    const mockTools = [{ name: 'read_file' }];
+    toolsCache = mockTools;
+    toolsCacheTimestamp = Date.now();
+
+    // Wait for cache to expire
+    await new Promise(resolve => setTimeout(resolve, 150));
+
+    // Check cache validity
+    const now = Date.now();
+    const isCacheValid = (now - toolsCacheTimestamp) < CACHE_TTL;
+
+    expect(isCacheValid).toBe(false);
+  });
+});
+
+describe('Tools Management - Tool Filtering', () => {
+  test('Tools can be filtered by multiple criteria', async () => {
+    const { TOOL_CATEGORY } = await import('../../config/constants.js');
+
+    // Mock tool list
+    const mockTools = [
+      { name: 'execute_command', category: TOOL_CATEGORY.SYSTEM, enabled: true },
+      { name: 'terminal', category: TOOL_CATEGORY.SYSTEM, enabled: false },
+      { name: 'analyze_code', category: TOOL_CATEGORY.ANALYSIS, enabled: true },
+    ];
+
+    // Filter by category and enabled status
+    const filterTools = (criteria) => {
+      let filtered = [...mockTools];
+
+      if (criteria.category) {
+        filtered = filtered.filter(t => t.category === criteria.category);
+      }
+
+      if (criteria.enabled !== undefined) {
+        filtered = filtered.filter(t => t.enabled === criteria.enabled);
+      }
+
+      return filtered;
+    };
+
+    // Filter: system tools only
+    const systemTools = filterTools({ category: TOOL_CATEGORY.SYSTEM });
+    expect(systemTools.length).toBe(2);
+
+    // Filter: enabled tools only
+    const enabledTools = filterTools({ enabled: true });
+    expect(enabledTools.length).toBe(2);
+
+    // Filter: enabled system tools
+    const enabledSystemTools = filterTools({
+      category: TOOL_CATEGORY.SYSTEM,
+      enabled: true,
+    });
+    expect(enabledSystemTools.length).toBe(1);
+    expect(enabledSystemTools[0].name).toBe('execute_command');
+  });
+});
+
+describe('Tools Management - Category Counts', () => {
+  test('Category counts can be calculated', async () => {
+    const { TOOL_CATEGORY } = await import('../../config/constants.js');
+
+    // Mock tool list
+    const mockTools = [
+      { name: 'execute_command', category: TOOL_CATEGORY.SYSTEM },
+      { name: 'terminal', category: TOOL_CATEGORY.SYSTEM },
+      { name: 'analyze_code', category: TOOL_CATEGORY.ANALYSIS },
+      { name: 'web_search', category: TOOL_CATEGORY.UTILITY },
+    ];
+
+    // Calculate counts
+    const getCategoryCounts = (tools) => {
+      const counts = {};
+      for (const category of Object.values(TOOL_CATEGORY)) {
+        counts[category] = tools.filter(t => t.category === category).length;
+      }
+      return counts;
+    };
+
+    const counts = getCategoryCounts(mockTools);
+
+    expect(counts[TOOL_CATEGORY.SYSTEM]).toBe(2);
+    expect(counts[TOOL_CATEGORY.ANALYSIS]).toBe(1);
+    expect(counts[TOOL_CATEGORY.UTILITY]).toBe(1);
+    expect(counts[TOOL_CATEGORY.AUTOMATION]).toBe(0);
+  });
+});

package/src/interfaces/terminal/api/apiClient.js

@@ -0,0 +1,299 @@
+/**
+ * API Client
+ * Unified HTTP request mechanism for all backend communication
+ * Handles authentication, headers, and error handling consistently
+ */
+
+import { ERROR_MESSAGE } from '../config/constants.js';
+
+/**
+ * API Client Class
+ * Centralized HTTP client with automatic authentication
+ */
+export class ApiClient {
+  constructor(baseUrl, apiKey = null) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+  }
+
+  /**
+   * Set or update the API key
+   */
+  setApiKey(apiKey) {
+    this.apiKey = apiKey;
+  }
+
+  /**
+   * Get the current API key
+   */
+  getApiKey() {
+    return this.apiKey;
+  }
+
+  /**
+   * Clear the API key
+   */
+  clearApiKey() {
+    this.apiKey = null;
+  }
+
+  /**
+   * Build request headers
+   * Automatically includes Authorization header if API key is set
+   */
+  buildHeaders(additionalHeaders = {}) {
+    const headers = {
+      'Content-Type': 'application/json',
+      ...additionalHeaders,
+    };
+
+    // Add Authorization header if API key is available
+    if (this.apiKey) {
+      headers['Authorization'] = `Bearer ${this.apiKey}`;
+    }
+
+    return headers;
+  }
+
+  /**
+   * Make HTTP request
+   * @param {string} method - HTTP method (GET, POST, PUT, DELETE, etc.)
+   * @param {string} endpoint - API endpoint path
+   * @param {object} options - Request options
+   * @param {object} options.body - Request body (for POST, PUT, PATCH)
+   * @param {object} options.headers - Additional headers
+   * @param {object} options.query - Query parameters
+   * @returns {Promise<object>} Response data
+   */
+  async request(method, endpoint, options = {}) {
+    const { body = null, headers = {}, query = null } = options;
+
+    // Build URL with query parameters
+    let url = `${this.baseUrl}${endpoint}`;
+    if (query) {
+      const queryString = new URLSearchParams(query).toString();
+      url += `?${queryString}`;
+    }
+
+    // Build request options
+    const requestOptions = {
+      method,
+      headers: this.buildHeaders(headers),
+    };
+
+    // Add body for POST, PUT, PATCH
+    if (body && ['POST', 'PUT', 'PATCH'].includes(method.toUpperCase())) {
+      requestOptions.body = JSON.stringify(body);
+    }
+
+    try {
+      const response = await fetch(url, requestOptions);
+
+      // Parse JSON response
+      const data = await response.json().catch(() => ({}));
+
+      // Check if response is OK
+      if (!response.ok) {
+        const error = new Error(data.error || `HTTP ${response.status}: ${response.statusText}`);
+        error.status = response.status;
+        error.response = data;
+        throw error;
+      }
+
+      return data;
+    } catch (error) {
+      // Network errors
+      if (error.message.includes('fetch') || error.name === 'TypeError') {
+        const networkError = new Error(`${ERROR_MESSAGE.NETWORK_ERROR}: ${error.message}`);
+        networkError.originalError = error;
+        throw networkError;
+      }
+      // Re-throw API errors
+      throw error;
+    }
+  }
+
+  /**
+   * GET request
+   */
+  async get(endpoint, options = {}) {
+    return this.request('GET', endpoint, options);
+  }
+
+  /**
+   * POST request
+   */
+  async post(endpoint, body = null, options = {}) {
+    return this.request('POST', endpoint, { ...options, body });
+  }
+
+  /**
+   * PUT request
+   */
+  async put(endpoint, body = null, options = {}) {
+    return this.request('PUT', endpoint, { ...options, body });
+  }
+
+  /**
+   * PATCH request
+   */
+  async patch(endpoint, body = null, options = {}) {
+    return this.request('PATCH', endpoint, { ...options, body });
+  }
+
+  /**
+   * DELETE request
+   */
+  async delete(endpoint, options = {}) {
+    return this.request('DELETE', endpoint, options);
+  }
+
+  /**
+   * Make streaming HTTP request (Server-Sent Events)
+   * @param {string} endpoint - API endpoint path
+   * @param {object} body - Request body
+   * @param {object} options - Request options
+   * @param {function} options.onChunk - Callback for each text chunk
+   * @param {function} options.onDone - Callback when stream completes
+   * @param {function} options.onError - Callback for errors
+   * @returns {Promise<object>} Final response data
+   */
+  async streamRequest(endpoint, body = {}, options = {}) {
+    const { onChunk, onDone, onError, headers = {} } = options;
+
+    let url = `${this.baseUrl}${endpoint}`;
+
+    const requestOptions = {
+      method: 'POST',
+      headers: {
+        ...this.buildHeaders(headers),
+        'Accept': 'text/event-stream'
+      },
+      body: JSON.stringify({ ...body, stream: true })
+    };
+
+    try {
+      const response = await fetch(url, requestOptions);
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        const error = new Error(`HTTP ${response.status}: ${errorText}`);
+        error.status = response.status;
+        if (onError) onError(error);
+        throw error;
+      }
+
+      // Check if we actually got a stream
+      const contentType = response.headers.get('content-type');
+      if (!contentType?.includes('text/event-stream')) {
+        // Not a stream, parse as regular JSON
+        const data = await response.json();
+        if (onChunk && data.content) {
+          onChunk(data.content);
+        }
+        if (onDone) onDone(data);
+        return data;
+      }
+
+      // Validate response body before reading stream
+      if (!response.body) {
+        const textContent = await response.text().catch(() => '');
+        if (onChunk && textContent) onChunk(textContent);
+        const fallbackResult = { content: textContent, model: body?.model, finishReason: 'stop' };
+        if (onDone) onDone(fallbackResult);
+        return fallbackResult;
+      }
+
+      // Process SSE stream
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let fullContent = '';
+      let finalData = null;
+
+      while (true) {
+        const { done, value } = await reader.read();
+
+        if (done) {
+          break;
+        }
+
+        const text = decoder.decode(value, { stream: true });
+        const lines = text.split('\n');
+
+        for (const line of lines) {
+          if (line.startsWith('data: ')) {
+            const data = line.slice(6).trim();
+
+            if (data === '[DONE]') {
+              continue;
+            }
+
+            try {
+              const parsed = JSON.parse(data);
+
+              if (parsed.type === 'chunk' && parsed.content) {
+                fullContent += parsed.content;
+                if (onChunk) {
+                  onChunk(parsed.content);
+                }
+              } else if (parsed.type === 'done') {
+                finalData = {
+                  content: parsed.content || fullContent,
+                  usage: parsed.usage,
+                  model: parsed.model,
+                  finishReason: parsed.finishReason
+                };
+              } else if (parsed.type === 'error') {
+                const error = new Error(parsed.error);
+                error.code = parsed.code;
+                if (onError) onError(error);
+                throw error;
+              }
+            } catch (parseError) {
+              // Skip unparseable lines, but don't throw
+              if (parseError.message && !parseError.code) {
+                // Only skip JSON parse errors, not our custom errors
+                continue;
+              }
+              throw parseError;
+            }
+          }
+        }
+      }
+
+      // Final callback with complete data
+      if (onDone) {
+        onDone(finalData || { content: fullContent });
+      }
+
+      return finalData || { content: fullContent };
+
+    } catch (error) {
+      if (error.message.includes('fetch') || error.name === 'TypeError') {
+        const networkError = new Error(`${ERROR_MESSAGE.NETWORK_ERROR}: ${error.message}`);
+        networkError.originalError = error;
+        if (onError) onError(networkError);
+        throw networkError;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * POST request with streaming response
+   * Convenience method for streaming chat completions
+   */
+  async postStream(endpoint, body = null, options = {}) {
+    return this.streamRequest(endpoint, body, options);
+  }
+}
+
+/**
+ * Create an API client instance
+ */
+export function createApiClient(host = 'localhost', port = 8080, apiKey = null) {
+  const baseUrl = `http://${host}:${port}`;
+  return new ApiClient(baseUrl, apiKey);
+}
+
+export default ApiClient;