@vibescope/mcp-server 0.5.0 → 0.5.2

package/src/handlers/cloud-agents.test.ts

@@ -1,438 +1,438 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import {
-	cleanupStaleCloudAgents,
-	listCloudAgents,
-} from './cloud-agents.js';
-import { ValidationError } from '../validators.js';
-import { createMockContext, testUUID } from './__test-utils__.js';
-import { mockApiClient } from './__test-setup__.js';
-
-// ============================================================================
-// cleanupStaleCloudAgents Tests
-// ============================================================================
-
-describe('cleanupStaleCloudAgents', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing project_id', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			cleanupStaleCloudAgents({}, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid project_id UUID', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			cleanupStaleCloudAgents({ project_id: 'invalid' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should cleanup stale agents successfully', async () => {
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: {
-				cleaned: 2,
-				failed: 0,
-				agents: [
-					{ id: 'agent-1', name: 'Agent 1', success: true },
-					{ id: 'agent-2', name: 'Agent 2', success: true },
-				],
-			},
-		});
-		const ctx = createMockContext();
-
-		const result = await cleanupStaleCloudAgents(
-			{ project_id: testUUID() },
-			ctx
-		);
-
-		expect(result.result).toMatchObject({
-			cleaned: 2,
-			failed: 0,
-			message: 'Cleaned up 2 stale agents',
-		});
-	});
-
-	it('should call API with correct parameters', async () => {
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: { cleaned: 0, agents: [] },
-		});
-		const ctx = createMockContext();
-
-		await cleanupStaleCloudAgents(
-			{
-				project_id: testUUID(),
-				stale_minutes: 10,
-				include_running: true,
-				dry_run: false,
-			},
-			ctx
-		);
-
-		expect(mockApiClient.proxy).toHaveBeenCalledWith(
-			'cleanup_stale_cloud_agents',
-			{
-				project_id: testUUID(),
-				staleMinutes: 10,
-				includeRunning: true,
-				dryRun: false,
-			}
-		);
-	});
-
-	it('should use default values for optional parameters', async () => {
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: { cleaned: 0, agents: [] },
-		});
-		const ctx = createMockContext();
-
-		await cleanupStaleCloudAgents(
-			{ project_id: testUUID() },
-			ctx
-		);
-
-		expect(mockApiClient.proxy).toHaveBeenCalledWith(
-			'cleanup_stale_cloud_agents',
-			{
-				project_id: testUUID(),
-				staleMinutes: 5, // default
-				includeRunning: false, // default
-				dryRun: false, // default
-			}
-		);
-	});
-
-	it('should return dry run preview when dry_run is true', async () => {
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: {
-				wouldClean: 3,
-				dryRun: true,
-				agents: [
-					{ id: 'agent-1', status: 'failed', createdAt: '2025-01-14T10:00:00Z' },
-					{ id: 'agent-2', status: 'starting', createdAt: '2025-01-14T10:05:00Z' },
-					{ id: 'agent-3', status: 'stopped', createdAt: '2025-01-14T10:10:00Z' },
-				],
-			},
-		});
-		const ctx = createMockContext();
-
-		const result = await cleanupStaleCloudAgents(
-			{ project_id: testUUID(), dry_run: true },
-			ctx
-		);
-
-		expect(result.result).toMatchObject({
-			dryRun: true,
-			wouldClean: 3,
-			message: 'Found 3 stale agents that would be cleaned up',
-		});
-		expect((result.result as { agents: unknown[] }).agents).toHaveLength(3);
-	});
-
-	it('should include failed count in response', async () => {
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: {
-				cleaned: 2,
-				failed: 1,
-				agents: [
-					{ id: 'agent-1', success: true },
-					{ id: 'agent-2', success: true },
-					{ id: 'agent-3', success: false, error: 'Agent still running' },
-				],
-			},
-		});
-		const ctx = createMockContext();
-
-		const result = await cleanupStaleCloudAgents(
-			{ project_id: testUUID() },
-			ctx
-		);
-
-		expect(result.result).toMatchObject({
-			cleaned: 2,
-			failed: 1,
-		});
-	});
-
-	it('should return error when API call fails', async () => {
-		mockApiClient.proxy.mockResolvedValue({
-			ok: false,
-			error: 'Failed to cleanup agents',
-		});
-		const ctx = createMockContext();
-
-		const result = await cleanupStaleCloudAgents(
-			{ project_id: testUUID() },
-			ctx
-		);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'Failed to cleanup agents',
-		});
-	});
-
-	it('should return error when API returns undefined data', async () => {
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: undefined,
-		});
-		const ctx = createMockContext();
-
-		const result = await cleanupStaleCloudAgents(
-			{ project_id: testUUID() },
-			ctx
-		);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'Failed to cleanup stale agents',
-		});
-	});
-});
-
-// ============================================================================
-// listCloudAgents Tests
-// ============================================================================
-
-describe('listCloudAgents', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing project_id', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			listCloudAgents({}, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid project_id UUID', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			listCloudAgents({ project_id: 'invalid' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid status value', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			listCloudAgents({ project_id: testUUID(), status: 'invalid_status' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should return empty list when no agents', async () => {
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: { agents: [] },
-		});
-		const ctx = createMockContext();
-
-		const result = await listCloudAgents(
-			{ project_id: testUUID() },
-			ctx
-		);
-
-		expect(result.result).toMatchObject({
-			agents: [],
-			count: 0,
-		});
-	});
-
-	it('should return agents list with count', async () => {
-		const mockAgents = [
-			{
-				id: 'agent-1',
-				name: 'Test Agent 1',
-				status: 'running',
-				created_at: '2025-01-14T10:00:00Z',
-				last_heartbeat: '2025-01-14T12:00:00Z',
-				public_ip: '10.0.0.1',
-				ecs_task_id: 'task-abc123',
-			},
-			{
-				id: 'agent-2',
-				name: 'Test Agent 2',
-				status: 'stopped',
-				created_at: '2025-01-14T09:00:00Z',
-			},
-		];
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: { agents: mockAgents },
-		});
-		const ctx = createMockContext();
-
-		const result = await listCloudAgents(
-			{ project_id: testUUID() },
-			ctx
-		);
-
-		expect(result.result).toMatchObject({
-			agents: mockAgents,
-			count: 2,
-		});
-	});
-
-	it('should call API with status filter', async () => {
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: { agents: [] },
-		});
-		const ctx = createMockContext();
-
-		await listCloudAgents(
-			{ project_id: testUUID(), status: 'running' },
-			ctx
-		);
-
-		expect(mockApiClient.proxy).toHaveBeenCalledWith(
-			'list_cloud_agents',
-			{
-				project_id: testUUID(),
-				status: 'running',
-			}
-		);
-	});
-
-	it('should not pass status when "all" is specified', async () => {
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: { agents: [] },
-		});
-		const ctx = createMockContext();
-
-		await listCloudAgents(
-			{ project_id: testUUID(), status: 'all' },
-			ctx
-		);
-
-		expect(mockApiClient.proxy).toHaveBeenCalledWith(
-			'list_cloud_agents',
-			{
-				project_id: testUUID(),
-				status: undefined,
-			}
-		);
-	});
-
-	it('should use default status of "all"', async () => {
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: { agents: [] },
-		});
-		const ctx = createMockContext();
-
-		await listCloudAgents(
-			{ project_id: testUUID() },
-			ctx
-		);
-
-		expect(mockApiClient.proxy).toHaveBeenCalledWith(
-			'list_cloud_agents',
-			{
-				project_id: testUUID(),
-				status: undefined, // 'all' becomes undefined
-			}
-		);
-	});
-
-	it('should filter by starting status', async () => {
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: { agents: [{ id: 'a1', status: 'starting', created_at: '2025-01-14T10:00:00Z' }] },
-		});
-		const ctx = createMockContext();
-
-		const result = await listCloudAgents(
-			{ project_id: testUUID(), status: 'starting' },
-			ctx
-		);
-
-		expect(mockApiClient.proxy).toHaveBeenCalledWith(
-			'list_cloud_agents',
-			{ project_id: testUUID(), status: 'starting' }
-		);
-		expect((result.result as { count: number }).count).toBe(1);
-	});
-
-	it('should filter by failed status', async () => {
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: { agents: [] },
-		});
-		const ctx = createMockContext();
-
-		await listCloudAgents(
-			{ project_id: testUUID(), status: 'failed' },
-			ctx
-		);
-
-		expect(mockApiClient.proxy).toHaveBeenCalledWith(
-			'list_cloud_agents',
-			{ project_id: testUUID(), status: 'failed' }
-		);
-	});
-
-	it('should filter by stopped status', async () => {
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: { agents: [] },
-		});
-		const ctx = createMockContext();
-
-		await listCloudAgents(
-			{ project_id: testUUID(), status: 'stopped' },
-			ctx
-		);
-
-		expect(mockApiClient.proxy).toHaveBeenCalledWith(
-			'list_cloud_agents',
-			{ project_id: testUUID(), status: 'stopped' }
-		);
-	});
-
-	it('should return error when API call fails', async () => {
-		mockApiClient.proxy.mockResolvedValue({
-			ok: false,
-			error: 'Database error',
-		});
-		const ctx = createMockContext();
-
-		const result = await listCloudAgents(
-			{ project_id: testUUID() },
-			ctx
-		);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'Database error',
-		});
-	});
-
-	it('should return error when API returns undefined data', async () => {
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: undefined,
-		});
-		const ctx = createMockContext();
-
-		const result = await listCloudAgents(
-			{ project_id: testUUID() },
-			ctx
-		);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'Failed to list cloud agents',
-		});
-	});
-});
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+	cleanupStaleCloudAgents,
+	listCloudAgents,
+} from './cloud-agents.js';
+import { ValidationError } from '../validators.js';
+import { createMockContext, testUUID } from './__test-utils__.js';
+import { mockApiClient } from './__test-setup__.js';
+
+// ============================================================================
+// cleanupStaleCloudAgents Tests
+// ============================================================================
+
+describe('cleanupStaleCloudAgents', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			cleanupStaleCloudAgents({}, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			cleanupStaleCloudAgents({ project_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should cleanup stale agents successfully', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: {
+				cleaned: 2,
+				failed: 0,
+				agents: [
+					{ id: 'agent-1', name: 'Agent 1', success: true },
+					{ id: 'agent-2', name: 'Agent 2', success: true },
+				],
+			},
+		});
+		const ctx = createMockContext();
+
+		const result = await cleanupStaleCloudAgents(
+			{ project_id: testUUID() },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			cleaned: 2,
+			failed: 0,
+			message: 'Cleaned up 2 stale agents',
+		});
+	});
+
+	it('should call API with correct parameters', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { cleaned: 0, agents: [] },
+		});
+		const ctx = createMockContext();
+
+		await cleanupStaleCloudAgents(
+			{
+				project_id: testUUID(),
+				stale_minutes: 10,
+				include_running: true,
+				dry_run: false,
+			},
+			ctx
+		);
+
+		expect(mockApiClient.proxy).toHaveBeenCalledWith(
+			'cleanup_stale_cloud_agents',
+			{
+				project_id: testUUID(),
+				staleMinutes: 10,
+				includeRunning: true,
+				dryRun: false,
+			}
+		);
+	});
+
+	it('should use default values for optional parameters', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { cleaned: 0, agents: [] },
+		});
+		const ctx = createMockContext();
+
+		await cleanupStaleCloudAgents(
+			{ project_id: testUUID() },
+			ctx
+		);
+
+		expect(mockApiClient.proxy).toHaveBeenCalledWith(
+			'cleanup_stale_cloud_agents',
+			{
+				project_id: testUUID(),
+				staleMinutes: 5, // default
+				includeRunning: false, // default
+				dryRun: false, // default
+			}
+		);
+	});
+
+	it('should return dry run preview when dry_run is true', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: {
+				wouldClean: 3,
+				dryRun: true,
+				agents: [
+					{ id: 'agent-1', status: 'failed', createdAt: '2025-01-14T10:00:00Z' },
+					{ id: 'agent-2', status: 'starting', createdAt: '2025-01-14T10:05:00Z' },
+					{ id: 'agent-3', status: 'stopped', createdAt: '2025-01-14T10:10:00Z' },
+				],
+			},
+		});
+		const ctx = createMockContext();
+
+		const result = await cleanupStaleCloudAgents(
+			{ project_id: testUUID(), dry_run: true },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			dryRun: true,
+			wouldClean: 3,
+			message: 'Found 3 stale agents that would be cleaned up',
+		});
+		expect((result.result as { agents: unknown[] }).agents).toHaveLength(3);
+	});
+
+	it('should include failed count in response', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: {
+				cleaned: 2,
+				failed: 1,
+				agents: [
+					{ id: 'agent-1', success: true },
+					{ id: 'agent-2', success: true },
+					{ id: 'agent-3', success: false, error: 'Agent still running' },
+				],
+			},
+		});
+		const ctx = createMockContext();
+
+		const result = await cleanupStaleCloudAgents(
+			{ project_id: testUUID() },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			cleaned: 2,
+			failed: 1,
+		});
+	});
+
+	it('should return error when API call fails', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: false,
+			error: 'Failed to cleanup agents',
+		});
+		const ctx = createMockContext();
+
+		const result = await cleanupStaleCloudAgents(
+			{ project_id: testUUID() },
+			ctx
+		);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Failed to cleanup agents',
+		});
+	});
+
+	it('should return error when API returns undefined data', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: undefined,
+		});
+		const ctx = createMockContext();
+
+		const result = await cleanupStaleCloudAgents(
+			{ project_id: testUUID() },
+			ctx
+		);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Failed to cleanup stale agents',
+		});
+	});
+});
+
+// ============================================================================
+// listCloudAgents Tests
+// ============================================================================
+
+describe('listCloudAgents', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			listCloudAgents({}, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			listCloudAgents({ project_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid status value', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			listCloudAgents({ project_id: testUUID(), status: 'invalid_status' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return empty list when no agents', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { agents: [] },
+		});
+		const ctx = createMockContext();
+
+		const result = await listCloudAgents(
+			{ project_id: testUUID() },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			agents: [],
+			count: 0,
+		});
+	});
+
+	it('should return agents list with count', async () => {
+		const mockAgents = [
+			{
+				id: 'agent-1',
+				name: 'Test Agent 1',
+				status: 'running',
+				created_at: '2025-01-14T10:00:00Z',
+				last_heartbeat: '2025-01-14T12:00:00Z',
+				public_ip: '10.0.0.1',
+				ecs_task_id: 'task-abc123',
+			},
+			{
+				id: 'agent-2',
+				name: 'Test Agent 2',
+				status: 'stopped',
+				created_at: '2025-01-14T09:00:00Z',
+			},
+		];
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { agents: mockAgents },
+		});
+		const ctx = createMockContext();
+
+		const result = await listCloudAgents(
+			{ project_id: testUUID() },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			agents: mockAgents,
+			count: 2,
+		});
+	});
+
+	it('should call API with status filter', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { agents: [] },
+		});
+		const ctx = createMockContext();
+
+		await listCloudAgents(
+			{ project_id: testUUID(), status: 'running' },
+			ctx
+		);
+
+		expect(mockApiClient.proxy).toHaveBeenCalledWith(
+			'list_cloud_agents',
+			{
+				project_id: testUUID(),
+				status: 'running',
+			}
+		);
+	});
+
+	it('should not pass status when "all" is specified', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { agents: [] },
+		});
+		const ctx = createMockContext();
+
+		await listCloudAgents(
+			{ project_id: testUUID(), status: 'all' },
+			ctx
+		);
+
+		expect(mockApiClient.proxy).toHaveBeenCalledWith(
+			'list_cloud_agents',
+			{
+				project_id: testUUID(),
+				status: undefined,
+			}
+		);
+	});
+
+	it('should use default status of "all"', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { agents: [] },
+		});
+		const ctx = createMockContext();
+
+		await listCloudAgents(
+			{ project_id: testUUID() },
+			ctx
+		);
+
+		expect(mockApiClient.proxy).toHaveBeenCalledWith(
+			'list_cloud_agents',
+			{
+				project_id: testUUID(),
+				status: undefined, // 'all' becomes undefined
+			}
+		);
+	});
+
+	it('should filter by starting status', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { agents: [{ id: 'a1', status: 'starting', created_at: '2025-01-14T10:00:00Z' }] },
+		});
+		const ctx = createMockContext();
+
+		const result = await listCloudAgents(
+			{ project_id: testUUID(), status: 'starting' },
+			ctx
+		);
+
+		expect(mockApiClient.proxy).toHaveBeenCalledWith(
+			'list_cloud_agents',
+			{ project_id: testUUID(), status: 'starting' }
+		);
+		expect((result.result as { count: number }).count).toBe(1);
+	});
+
+	it('should filter by failed status', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { agents: [] },
+		});
+		const ctx = createMockContext();
+
+		await listCloudAgents(
+			{ project_id: testUUID(), status: 'failed' },
+			ctx
+		);
+
+		expect(mockApiClient.proxy).toHaveBeenCalledWith(
+			'list_cloud_agents',
+			{ project_id: testUUID(), status: 'failed' }
+		);
+	});
+
+	it('should filter by stopped status', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { agents: [] },
+		});
+		const ctx = createMockContext();
+
+		await listCloudAgents(
+			{ project_id: testUUID(), status: 'stopped' },
+			ctx
+		);
+
+		expect(mockApiClient.proxy).toHaveBeenCalledWith(
+			'list_cloud_agents',
+			{ project_id: testUUID(), status: 'stopped' }
+		);
+	});
+
+	it('should return error when API call fails', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: false,
+			error: 'Database error',
+		});
+		const ctx = createMockContext();
+
+		const result = await listCloudAgents(
+			{ project_id: testUUID() },
+			ctx
+		);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Database error',
+		});
+	});
+
+	it('should return error when API returns undefined data', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: undefined,
+		});
+		const ctx = createMockContext();
+
+		const result = await listCloudAgents(
+			{ project_id: testUUID() },
+			ctx
+		);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Failed to list cloud agents',
+		});
+	});
+});