@fleettools/server 0.1.0 → 0.1.1

package/e2e-integration.test.ts

@@ -1,290 +0,0 @@
-/**
- * End-to-End Integration Tests for FleetTools
- * Tests CLI → API → Database workflows
- */
-
-import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from 'bun:test';
-import { spawn } from 'node:child_process';
-import { setTimeout } from 'timers/promises';
-
-const API_BASE_URL = 'http://localhost:3001';
-const CLI_PATH = './cli/index.ts';
-
-describe('FleetTools End-to-End Integration', () => {
-  let serverProcess: any;
-  let apiPort: number;
-
-  beforeAll(async () => {
-    // Find available port
-    apiPort = 3001 + Math.floor(Math.random() * 100);
-    
-    // Start API server
-    serverProcess = spawn('bun', ['server/api/src/index.ts'], {
-      env: { ...process.env, PORT: apiPort.toString() },
-      stdio: 'pipe'
-    });
-
-    // Wait for server to start
-    await setTimeout(2000);
-    
-    // Verify server is running
-    const response = await fetch(`${API_BASE_URL.replace('3001', apiPort.toString())}/health`);
-    expect(response.status).toBe(200);
-  });
-
-  afterAll(async () => {
-    if (serverProcess) {
-      serverProcess.kill();
-      await setTimeout(1000);
-    }
-  });
-
-  beforeEach(() => {
-    // Clean up any test data
-  });
-
-  afterEach(() => {
-    // Clean up any test data
-  });
-
-  describe('CLI → API Integration', () => {
-    it('should spawn agent via CLI and verify in API', async () => {
-      // Skip if server not available
-      try {
-        await fetch(`${API_BASE_URL.replace('3001', apiPort.toString())}/health`);
-      } catch {
-        console.log('Skipping test - server not available');
-        return;
-      }
-
-      // Spawn agent via CLI
-      const cliResult = await runCLICommand(['agents', 'spawn', 'testing', 'test task'], {
-        FLEETTOOLS_API_URL: API_BASE_URL.replace('3001', apiPort.toString())
-      });
-
-      expect(cliResult.exitCode).toBe(0);
-      expect(cliResult.stdout).toContain('Agent spawned successfully');
-      
-      // Extract agent ID from CLI output
-      const agentIdMatch = cliResult.stdout.match(/Agent ID: (.+)/);
-      expect(agentIdMatch).toBeTruthy();
-      
-      const agentId = agentIdMatch?.[1]?.trim();
-      expect(agentId).toBeTruthy();
-
-      // Verify agent exists via API
-      const apiResponse = await fetch(`${API_BASE_URL.replace('3001', apiPort.toString())}/api/v1/agents`);
-      const apiData = await apiResponse.json();
-      
-      expect(apiData.success).toBe(true);
-      expect(apiData.data.agents).toBeDefined();
-      
-      const spawnedAgent = apiData.data.agents.find((agent: any) => agent.id === agentId);
-      expect(spawnedAgent).toBeTruthy();
-      expect(spawnedAgent.type).toBe('testing');
-      expect(spawnedAgent.status).toBe('running');
-    });
-
-    it('should list agents via CLI and match API data', async () => {
-      // List agents via CLI
-      const cliResult = await runCLICommand(['agents', 'status'], {
-        FLEETTOOLS_API_URL: API_BASE_URL.replace('3001', apiPort.toString())
-      });
-
-      expect(cliResult.exitCode).toBe(0);
-      expect(cliResult.stdout).toContain('Found');
-
-      // Get agents via API
-      const apiResponse = await fetch(`${API_BASE_URL.replace('3001', apiPort.toString())}/api/v1/agents`);
-      const apiData = await apiResponse.json();
-
-      expect(apiData.success).toBe(true);
-      
-      // Both should show same count
-      const cliAgentCount = (cliResult.stdout.match(/agent\(s\):/g) || [''])[0];
-      const apiAgentCount = apiData.data.agents?.length || 0;
-      
-      // At minimum, both should be valid responses
-      expect(cliResult.stdout).toBeDefined();
-      expect(apiData.data).toBeDefined();
-    });
-
-    it('should handle invalid agent type in CLI', async () => {
-      const cliResult = await runCLICommand(['agents', 'spawn', 'invalid-type'], {
-        FLEETTOOLS_API_URL: API_BASE_URL.replace('3001', apiPort.toString())
-      });
-
-      expect(cliResult.exitCode).toBe(1);
-      expect(cliResult.stderr).toContain('Invalid agent type');
-    });
-  });
-
-  describe('Task Management Integration', () => {
-    it('should create task via API and verify database operations', async () => {
-      const taskData = {
-        type: 'development',
-        title: 'Test Task',
-        description: 'Integration test task',
-        priority: 'medium'
-      };
-
-      // Create task via API
-      const createResponse = await fetch(`${API_BASE_URL.replace('3001', apiPort.toString())}/api/v1/tasks`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(taskData)
-      });
-
-      expect(createResponse.status).toBe(201);
-      const createData = await createResponse.json();
-      expect(createData.success).toBe(true);
-      expect(createData.data.title).toBe(taskData.title);
-
-      // Get task via API
-      const taskId = createData.data.id;
-      const getResponse = await fetch(`${API_BASE_URL.replace('3001', apiPort.toString())}/api/v1/tasks/${taskId}`);
-      const getData = await getResponse.json();
-
-      expect(getData.success).toBe(true);
-      expect(getData.data.title).toBe(taskData.title);
-      expect(getData.data.status).toBe('pending');
-    });
-
-    it('should update task status through workflow', async () => {
-      // Create task
-      const createResponse = await fetch(`${API_BASE_URL.replace('3001', apiPort.toString())}/api/v1/tasks`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          type: 'testing',
-          title: 'Workflow Test Task',
-          description: 'Test task for workflow'
-        })
-      });
-
-      const createData = await createResponse.json();
-      const taskId = createData.data.id;
-
-      // Start task
-      const startResponse = await fetch(`${API_BASE_URL.replace('3001', apiPort.toString())}/api/v1/tasks/${taskId}/start`, {
-        method: 'PATCH'
-      });
-
-      expect(startResponse.status).toBe(200);
-      const startData = await startResponse.json();
-      expect(startData.data.status).toBe('in_progress');
-
-      // Complete task
-      const completeResponse = await fetch(`${API_BASE_URL.replace('3001', apiPort.toString())}/api/v1/tasks/${taskId}/complete`, {
-        method: 'PATCH',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ result: 'Task completed successfully' })
-      });
-
-      expect(completeResponse.status).toBe(200);
-      const completeData = await completeResponse.json();
-      expect(completeData.data.status).toBe('completed');
-    });
-  });
-
-  describe('Checkpoint Integration', () => {
-    it('should create checkpoint through CLI workflow', async () => {
-      // This will test the unstubbed checkpoint command
-      const cliResult = await runCLICommand(['checkpoint', '--note', 'Integration test checkpoint'], {
-        FLEETTOOLS_API_URL: API_BASE_URL.replace('3001', apiPort.toString())
-      });
-
-      // For now, expect the stubbed response
-      // After implementation, expect success
-      expect(cliResult.exitCode).toBeDefined();
-    });
-
-    it('should handle resume command', async () => {
-      const cliResult = await runCLICommand(['resume'], {
-        FLEETTOOLS_API_URL: API_BASE_URL.replace('3001', apiPort.toString())
-      });
-
-      // For now, expect the stubbed response  
-      // After implementation, expect success
-      expect(cliResult.exitCode).toBeDefined();
-    });
-  });
-
-  describe('Error Handling Integration', () => {
-    it('should handle API server unavailable gracefully', async () => {
-      const cliResult = await runCLICommand(['agents', 'status'], {
-        FLEETTOOLS_API_URL: 'http://localhost:9999' // Unavailable port
-      });
-
-      expect(cliResult.exitCode).toBe(1);
-      expect(cliResult.stderr).toContain('Error');
-    });
-
-    it('should handle malformed API responses', async () => {
-      // This would test API error handling
-      const response = await fetch(`${API_BASE_URL.replace('3001', apiPort.toString())}/api/v1/agents/invalid-id`);
-      
-      expect([404, 500]).toContain(response.status);
-      
-      const data = await response.json();
-      expect(data.error).toBeDefined();
-    });
-  });
-
-  describe('Database Persistence', () => {
-    it('should persist agent data across server restarts', async () => {
-      // This test would require server restart capability
-      // For now, test basic data persistence
-      const response = await fetch(`${API_BASE_URL.replace('3001', apiPort.toString())}/api/v1/agents`);
-      const data = await response.json();
-      
-      expect(data.success).toBe(true);
-      expect(data.data).toBeDefined();
-    });
-  });
-});
-
-/**
- * Helper function to run CLI commands
- */
-async function runCLICommand(args: string[], env: Record<string, string> = {}): Promise<{
-  exitCode: number;
-  stdout: string;
-  stderr: string;
-}> {
-  return new Promise((resolve) => {
-    const cliProcess = spawn('bun', [CLI_PATH, ...args], {
-      env: { ...process.env, ...env },
-      stdio: 'pipe'
-    });
-
-    let stdout = '';
-    let stderr = '';
-
-    cliProcess.stdout?.on('data', (data) => {
-      stdout += data.toString();
-    });
-
-    cliProcess.stderr?.on('data', (data) => {
-      stderr += data.toString();
-    });
-
-    cliProcess.on('close', (code) => {
-      resolve({
-        exitCode: code || 0,
-        stdout,
-        stderr
-      });
-    });
-
-    // Timeout after 10 seconds
-    global.setTimeout(() => {
-      cliProcess.kill();
-      resolve({
-        exitCode: 1,
-        stdout,
-        stderr: 'Command timed out'
-      });
-    }, 10000);
-  });
-}

package/integration.test.ts

@@ -1,186 +0,0 @@
-/**
- * Integration Tests for Critical Infrastructure
- * Tests API registration, database integration, and CLI connectivity
- */
-
-import { describe, it, expect, beforeAll, afterAll } from 'bun:test';
-
-describe('Critical Infrastructure Integration', () => {
-  let server: any;
-  let baseUrl: string;
-
-  beforeAll(async () => {
-    // Start the server
-    server = await import('../src/index.js');
-    baseUrl = `http://localhost:${process.env.PORT || 3001}`;
-    
-    // Give server time to start
-    await new Promise(resolve => setTimeout(resolve, 1000));
-  });
-
-  afterAll(async () => {
-    if (server?.server?.stop) {
-      server.server.stop();
-    }
-  });
-
-  describe('API Registration Tests', () => {
-    it('should have health endpoint working', async () => {
-      const response = await fetch(`${baseUrl}/health`);
-      expect(response.status).toBe(200);
-      
-      const data = await response.json();
-      expect(data).toHaveProperty('status', 'healthy');
-      expect(data).toHaveProperty('service', 'fleettools-consolidated');
-    });
-
-    it('should have all Flightline endpoints registered', async () => {
-      // Test work orders endpoint
-      const workOrdersResponse = await fetch(`${baseUrl}/api/v1/work-orders`);
-      expect([200, 404, 405]).toContain(workOrdersResponse.status); // 404 is ok if no data, 405 if method not allowed
-
-      // Test tech orders endpoint  
-      const techOrdersResponse = await fetch(`${baseUrl}/api/v1/tech-orders`);
-      expect([200, 404, 405]).toContain(techOrdersResponse.status);
-
-      // Test CTK endpoints
-      const ctkResponse = await fetch(`${baseUrl}/api/v1/ctk/reservations`);
-      expect([200, 404, 405]).toContain(ctkResponse.status);
-    });
-
-    it('should have all Squawk endpoints registered', async () => {
-      // Test mailbox endpoint
-      const mailboxResponse = await fetch(`${baseUrl}/api/v1/mailbox/test-stream`, {
-        method: 'GET'
-      });
-      expect([200, 404, 405]).toContain(mailboxResponse.status);
-
-      // Test cursor endpoint
-      const cursorResponse = await fetch(`${baseUrl}/api/v1/cursor/test-cursor`);
-      expect([200, 404, 405]).toContain(cursorResponse.status);
-
-      // Test lock endpoint
-      const locksResponse = await fetch(`${baseUrl}/api/v1/locks`);
-      expect([200, 404, 405]).toContain(locksResponse.status);
-
-      // Test coordinator endpoint
-      const coordinatorResponse = await fetch(`${baseUrl}/api/v1/coordinator/status`);
-      expect([200, 404, 405]).toContain(coordinatorResponse.status);
-    });
-
-    it('should have all Coordination endpoints registered', async () => {
-      // Test agents endpoint
-      const agentsResponse = await fetch(`${baseUrl}/api/v1/agents`);
-      expect([200, 404, 405]).toContain(agentsResponse.status);
-
-      // Test missions endpoint
-      const missionsResponse = await fetch(`${baseUrl}/api/v1/missions`);
-      expect([200, 404, 405]).toContain(missionsResponse.status);
-
-      // Test tasks endpoint
-      const tasksResponse = await fetch(`${baseUrl}/api/v1/tasks/decompose`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ mission: 'test' })
-      });
-      expect([200, 400, 404, 405]).toContain(tasksResponse.status);
-    });
-  });
-
-  describe('Database Integration Tests', () => {
-    it('should have database operations working', async () => {
-      // Test that database is accessible through operations
-      const { initializeDatabase, closeDatabase } = await import('../../squawk/src/db/index.js');
-      
-      expect(async () => {
-        await initializeDatabase();
-      }).not.toThrow();
-      
-      closeDatabase();
-    });
-
-    it('should have checkpoint operations exposed', async () => {
-      // Test checkpoint functionality through progress tracker
-      const { ProgressTracker } = await import('../src/coordination/progress-tracker.js');
-      
-      const progressTracker = new ProgressTracker({
-        dbPath: './test-progress.db'
-      });
-
-      expect(async () => {
-        await progressTracker.checkpoint('test-mission', 'task1', 50, 'Test progress');
-      }).not.toThrow();
-
-      expect(async () => {
-        const progress = await progressTracker.getProgress('test-mission');
-        expect(progress).toBeDefined();
-      }).not.toThrow();
-    });
-  });
-
-  describe('End-to-End Workflow Tests', () => {
-    it('should support agent spawning workflow', async () => {
-      // Test agent spawning endpoint
-      const spawnResponse = await fetch(`${baseUrl}/api/v1/agents/spawn`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          type: 'testing',
-          task: 'Test task',
-          config: { timeout: 5000 }
-        })
-      });
-
-      expect([200, 201, 400, 500]).toContain(spawnResponse.status);
-    });
-
-    it('should support task decomposition workflow', async () => {
-      // Test task decomposition endpoint
-      const decomposeResponse = await fetch(`${baseUrl}/api/v1/tasks/decompose`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          mission: {
-            title: 'Test Mission',
-            description: 'Test description',
-            type: 'development'
-          }
-        })
-      });
-
-      expect([200, 400, 404]).toContain(decomposeResponse.status);
-    });
-
-    it('should support mission management workflow', async () => {
-      // Test mission creation endpoint
-      const createMissionResponse = await fetch(`${baseUrl}/api/v1/missions`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          title: 'Test Mission',
-          description: 'Test mission description',
-          type: 'development'
-        })
-      });
-
-      expect([200, 201, 400, 404]).toContain(createMissionResponse.status);
-    });
-  });
-
-  describe('Error Handling Tests', () => {
-    it('should handle 404 for unknown routes', async () => {
-      const response = await fetch(`${baseUrl}/api/v1/unknown-endpoint`);
-      expect(response.status).toBe(404);
-      
-      const data = await response.json();
-      expect(data).toHaveProperty('error');
-    });
-
-    it('should handle OPTIONS requests for CORS', async () => {
-      const response = await fetch(`${baseUrl}/api/v1/test`, {
-        method: 'OPTIONS'
-      });
-      expect([200, 204]).toContain(response.status);
-    });
-  });
-});