@vibescope/mcp-server 0.3.13 → 0.3.14

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

@@ -0,0 +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',
+		});
+	});
+});

package/src/handlers/cloud-agents.ts

@@ -60,16 +60,11 @@ interface ListAgentsResponse {
  * Clean up stale cloud agents that failed to start or lost connection.
  * Only operates on agents in the specified project (security scoped).
  */
-export const cleanupStaleCloudAgents: Handler = async (args, ctx) => {
+export const cleanupStaleCloudAgents: Handler = async (args, _ctx) => {
 	const { project_id, stale_minutes, include_running, dry_run } = parseArgs(args, cleanupStaleAgentsSchema);
 
-	// Ensure user has an active session with this project (security check)
-	if (ctx.session.currentProjectId && ctx.session.currentProjectId !== project_id) {
-		return error('Cannot cleanup agents for a different project than your current session');
-	}
-
 	const apiClient = getApiClient();
-	
+
 	// Call the cleanup endpoint via fetch (since it's a new endpoint not in the client)
 	const response = await apiClient.proxy<CleanupResponse>('cleanup_stale_cloud_agents', {
 		project_id,
@@ -78,12 +73,12 @@ export const cleanupStaleCloudAgents: Handler = async (args, ctx) => {
 		dryRun: dry_run,
 	});
 
-	if (!response.ok) {
+	if (!response.ok || !response.data) {
 		return error(response.error || 'Failed to cleanup stale agents');
 	}
 
 	const data = response.data!;
-	
+
 	if (dry_run) {
 		return success({
 			dryRun: true,
@@ -104,22 +99,17 @@ export const cleanupStaleCloudAgents: Handler = async (args, ctx) => {
 /**
  * List cloud agents for a project with optional status filter.
  */
-export const listCloudAgents: Handler = async (args, ctx) => {
+export const listCloudAgents: Handler = async (args, _ctx) => {
 	const { project_id, status } = parseArgs(args, listCloudAgentsSchema);
 
-	// Ensure user has an active session with this project (security check)
-	if (ctx.session.currentProjectId && ctx.session.currentProjectId !== project_id) {
-		return error('Cannot list agents for a different project than your current session');
-	}
-
 	const apiClient = getApiClient();
-	
+
 	const response = await apiClient.proxy<ListAgentsResponse>('list_cloud_agents', {
 		project_id,
 		status: status === 'all' ? undefined : status,
 	});
 
-	if (!response.ok) {
+	if (!response.ok || !response.data) {
 		return error(response.error || 'Failed to list cloud agents');
 	}
 

package/src/handlers/discovery.ts

@@ -327,6 +327,7 @@ export const TOOL_CATEGORIES: Record<string, { description: string; tools: Array
 	cloud_agents: {
 		description: 'Cloud agent management and cleanup',
 		tools: [
+			{ name: 'update_agent_status', brief: 'Update agent dashboard status message' },
 			{ name: 'cleanup_stale_cloud_agents', brief: 'Clean up stale cloud agents' },
 			{ name: 'list_cloud_agents', brief: 'List cloud agents for project' },
 		],

package/src/handlers/findings.ts

@@ -16,7 +16,7 @@ import { getApiClient } from '../api-client.js';
 
 const VALID_FINDING_CATEGORIES = ['performance', 'security', 'code_quality', 'accessibility', 'documentation', 'architecture', 'testing', 'other'] as const;
 const VALID_FINDING_SEVERITIES = ['info', 'low', 'medium', 'high', 'critical'] as const;
-const VALID_FINDING_STATUSES = ['open', 'addressed', 'dismissed', 'wontfix'] as const;
+const VALID_FINDING_STATUSES = ['open', 'in_development', 'implemented', 'addressed', 'dismissed', 'wontfix'] as const;
 
 type FindingCategory = typeof VALID_FINDING_CATEGORIES[number];
 type FindingSeverity = typeof VALID_FINDING_SEVERITIES[number];

package/src/handlers/ideas.ts

@@ -21,7 +21,7 @@ import {
 } from '../validators.js';
 import { getApiClient } from '../api-client.js';
 
-const VALID_IDEA_STATUSES = ['raw', 'exploring', 'planned', 'in_development', 'shipped'] as const;
+const VALID_IDEA_STATUSES = ['raw', 'exploring', 'planned', 'in_development', 'implemented', 'shipped'] as const;
 type IdeaStatus = typeof VALID_IDEA_STATUSES[number];
 
 // Argument schemas for type-safe parsing

package/src/handlers/session.ts

@@ -337,6 +337,7 @@ export const startWorkSession: Handler = async (args, ctx) => {
 	}
 	agentRules.push('COMPLETE TASKS: Always call complete_task() after creating a PR. This is mandatory.');
 	agentRules.push('REVIEW REQUIRED: All tasks must be reviewed by another agent before merging.');
+	agentRules.push('STATUS UPDATES: Call update_agent_status(status_message: "Working on: TASK_TITLE") whenever you start a new task, and update_task(task_id, status: "in_progress") to claim it.');
 
 	result.AGENT_RULES = agentRules;