@vibescope/mcp-server 0.0.1

package/src/handlers/requests.test.ts

@@ -0,0 +1,531 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type { HandlerContext, TokenUsage } from './types.js';
+import { getPendingRequests, acknowledgeRequest, answerQuestion } from './requests.js';
+import { ValidationError } from '../validators.js';
+
+// ============================================================================
+// Test Utilities
+// ============================================================================
+
+function createMockSupabase(overrides: {
+	selectResult?: { data: unknown; error: unknown };
+	updateResult?: { data: unknown; error: unknown };
+	sessionsResult?: { data: unknown; error: unknown };
+} = {}) {
+	const defaultResult = { data: null, error: null };
+	// Use an object to track state so it persists across all mock function calls
+	const state = {
+		currentOperation: 'select' as string,
+		currentTable: '' as string,
+		updateCalled: false,
+	};
+
+	const mock = {
+		from: vi.fn((table: string) => {
+			state.currentTable = table;
+			// Reset state for new query chain
+			state.currentOperation = 'select';
+			state.updateCalled = false;
+			return mock;
+		}),
+		select: vi.fn(() => {
+			// Don't reset updateCalled - we need to know if update was in this chain
+			if (!state.updateCalled) {
+				state.currentOperation = 'select';
+			}
+			return mock;
+		}),
+		update: vi.fn(() => {
+			state.currentOperation = 'update';
+			state.updateCalled = true;
+			return mock;
+		}),
+		eq: vi.fn().mockReturnThis(),
+		or: vi.fn().mockReturnThis(),
+		order: vi.fn().mockReturnThis(),
+		single: vi.fn(() => {
+			// If update was called in this chain, return updateResult
+			if (state.updateCalled) {
+				return Promise.resolve(overrides.updateResult ?? defaultResult);
+			}
+			return Promise.resolve(overrides.selectResult ?? defaultResult);
+		}),
+		then: vi.fn((resolve: (value: unknown) => void) => {
+			if (state.currentTable === 'agent_sessions') {
+				return Promise.resolve(overrides.sessionsResult ?? { data: [], error: null }).then(resolve);
+			}
+			if (state.updateCalled) {
+				return Promise.resolve(overrides.updateResult ?? defaultResult).then(resolve);
+			}
+			if (state.currentOperation === 'select') {
+				return Promise.resolve(overrides.selectResult ?? defaultResult).then(resolve);
+			}
+			return Promise.resolve(defaultResult).then(resolve);
+		}),
+	};
+
+	return mock as unknown as SupabaseClient;
+}
+
+function createMockContext(
+	supabase: SupabaseClient,
+	options: { sessionId?: string | null } = {}
+): HandlerContext {
+	const defaultTokenUsage: TokenUsage = {
+		callCount: 5,
+		totalTokens: 2500,
+		byTool: {},
+	};
+
+	const sessionId = 'sessionId' in options ? options.sessionId : 'session-123';
+
+	return {
+		supabase,
+		auth: { userId: 'user-123', apiKeyId: 'api-key-123' },
+		session: {
+			instanceId: 'instance-abc',
+			currentSessionId: sessionId,
+			currentPersona: 'Wave',
+			tokenUsage: defaultTokenUsage,
+		},
+		updateSession: vi.fn(),
+	};
+}
+
+// ============================================================================
+// getPendingRequests Tests
+// ============================================================================
+
+describe('getPendingRequests', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(getPendingRequests({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			getPendingRequests({ project_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return empty list when no requests', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+			sessionsResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await getPendingRequests(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			requests: [],
+			count: 0,
+			questions_count: 0,
+		});
+	});
+
+	it('should return pending requests', async () => {
+		const mockRequests = [
+			{
+				id: 'r1',
+				request_type: 'task',
+				content: 'Please do this',
+				session_id: null, // broadcast
+				acknowledged_at: null,
+				created_at: '2025-01-14T10:00:00Z',
+			},
+		];
+
+		const supabase = createMockSupabase({
+			selectResult: { data: mockRequests, error: null },
+			sessionsResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await getPendingRequests(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect((result.result as { count: number }).count).toBe(1);
+	});
+
+	it('should filter broadcast requests (session_id is null)', async () => {
+		const mockRequests = [
+			{
+				id: 'r1',
+				request_type: 'task',
+				content: 'Broadcast request',
+				session_id: null,
+				acknowledged_at: null,
+				created_at: '2025-01-14T10:00:00Z',
+			},
+		];
+
+		const supabase = createMockSupabase({
+			selectResult: { data: mockRequests, error: null },
+			sessionsResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await getPendingRequests(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		// Broadcast request should be included
+		expect((result.result as { count: number }).count).toBe(1);
+	});
+
+	it('should include requests targeted to current session', async () => {
+		const mockRequests = [
+			{
+				id: 'r1',
+				request_type: 'task',
+				content: 'Targeted request',
+				session_id: 'session-123',
+				acknowledged_at: null,
+				created_at: '2025-01-14T10:00:00Z',
+			},
+		];
+
+		const supabase = createMockSupabase({
+			selectResult: { data: mockRequests, error: null },
+			sessionsResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase, { sessionId: 'session-123' });
+
+		const result = await getPendingRequests(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect((result.result as { count: number }).count).toBe(1);
+	});
+
+	it('should exclude requests targeted to other sessions', async () => {
+		const mockRequests = [
+			{
+				id: 'r1',
+				request_type: 'task',
+				content: 'Other session request',
+				session_id: 'other-session',
+				acknowledged_at: null,
+				created_at: '2025-01-14T10:00:00Z',
+			},
+		];
+
+		const supabase = createMockSupabase({
+			selectResult: { data: mockRequests, error: null },
+			sessionsResult: { data: [{ id: 'other-session' }], error: null },
+		});
+		const ctx = createMockContext(supabase, { sessionId: 'session-123' });
+
+		const result = await getPendingRequests(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		// Should be excluded because targeted to an active other session
+		expect((result.result as { count: number }).count).toBe(0);
+	});
+
+	it('should count unanswered questions', async () => {
+		const mockRequests = [
+			{
+				id: 'r1',
+				request_type: 'question',
+				content: 'What is this?',
+				session_id: null,
+				acknowledged_at: null,
+				answered_at: null,
+				created_at: '2025-01-14T10:00:00Z',
+			},
+			{
+				id: 'r2',
+				request_type: 'task',
+				content: 'Do this',
+				session_id: null,
+				acknowledged_at: null,
+				created_at: '2025-01-14T11:00:00Z',
+			},
+		];
+
+		const supabase = createMockSupabase({
+			selectResult: { data: mockRequests, error: null },
+			sessionsResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await getPendingRequests(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect((result.result as { questions_count: number }).questions_count).toBe(1);
+	});
+
+	it('should add wait_minutes to requests', async () => {
+		const mockRequests = [
+			{
+				id: 'r1',
+				request_type: 'task',
+				content: 'Request',
+				session_id: null,
+				acknowledged_at: null,
+				created_at: new Date(Date.now() - 5 * 60000).toISOString(), // 5 minutes ago
+			},
+		];
+
+		const supabase = createMockSupabase({
+			selectResult: { data: mockRequests, error: null },
+			sessionsResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await getPendingRequests(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		const requests = (result.result as { requests: { wait_minutes: number }[] }).requests;
+		expect(requests[0].wait_minutes).toBeGreaterThanOrEqual(4); // Allow some margin
+	});
+
+	it('should query agent_requests table', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+			sessionsResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await getPendingRequests(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(supabase.from).toHaveBeenCalledWith('agent_requests');
+	});
+});
+
+// ============================================================================
+// acknowledgeRequest Tests
+// ============================================================================
+
+describe('acknowledgeRequest', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing request_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(acknowledgeRequest({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid request_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			acknowledgeRequest({ request_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should acknowledge request successfully', async () => {
+		const mockRequest = {
+			id: 'r1',
+			request_type: 'task',
+			content: 'Do this',
+			acknowledged_at: '2025-01-14T12:00:00Z',
+		};
+
+		const supabase = createMockSupabase({
+			updateResult: { data: mockRequest, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await acknowledgeRequest(
+			{ request_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			request: mockRequest,
+		});
+	});
+
+	it('should set acknowledged_at and acknowledged_by_session_id', async () => {
+		const supabase = createMockSupabase({
+			updateResult: { data: { id: 'r1' }, error: null },
+		});
+		const ctx = createMockContext(supabase, { sessionId: 'my-session' });
+
+		await acknowledgeRequest(
+			{ request_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(supabase.update).toHaveBeenCalledWith(
+			expect.objectContaining({
+				acknowledged_at: expect.any(String),
+				acknowledged_by_session_id: 'my-session',
+			})
+		);
+	});
+
+	it('should query agent_requests table', async () => {
+		const supabase = createMockSupabase({
+			updateResult: { data: { id: 'r1' }, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await acknowledgeRequest(
+			{ request_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(supabase.from).toHaveBeenCalledWith('agent_requests');
+	});
+
+	it('should throw error when update fails', async () => {
+		const supabase = createMockSupabase({
+			updateResult: { data: null, error: { message: 'Update failed' } },
+		});
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			acknowledgeRequest({ request_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow();
+	});
+});
+
+// ============================================================================
+// answerQuestion Tests
+// ============================================================================
+
+describe('answerQuestion', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing request_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			answerQuestion({ answer: 'The answer' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for missing answer', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			answerQuestion({ request_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid request_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			answerQuestion({ request_id: 'invalid', answer: 'The answer' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should answer question successfully', async () => {
+		const mockRequest = {
+			id: 'r1',
+			request_type: 'question',
+			content: 'What is this?',
+			answer: 'This is the answer',
+			answered_at: '2025-01-14T12:00:00Z',
+		};
+
+		const supabase = createMockSupabase({
+			updateResult: { data: mockRequest, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await answerQuestion(
+			{
+				request_id: '123e4567-e89b-12d3-a456-426614174000',
+				answer: 'This is the answer',
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			message: 'Question answered successfully',
+			request: mockRequest,
+		});
+	});
+
+	it('should set answer, answered_at, and acknowledgment fields', async () => {
+		const supabase = createMockSupabase({
+			updateResult: { data: { id: 'r1' }, error: null },
+		});
+		const ctx = createMockContext(supabase, { sessionId: 'my-session' });
+
+		await answerQuestion(
+			{
+				request_id: '123e4567-e89b-12d3-a456-426614174000',
+				answer: 'The answer to the question',
+			},
+			ctx
+		);
+
+		expect(supabase.update).toHaveBeenCalledWith(
+			expect.objectContaining({
+				answer: 'The answer to the question',
+				answered_at: expect.any(String),
+				acknowledged_at: expect.any(String),
+				acknowledged_by_session_id: 'my-session',
+			})
+		);
+	});
+
+	it('should query agent_requests table', async () => {
+		const supabase = createMockSupabase({
+			updateResult: { data: { id: 'r1' }, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await answerQuestion(
+			{
+				request_id: '123e4567-e89b-12d3-a456-426614174000',
+				answer: 'Answer',
+			},
+			ctx
+		);
+
+		expect(supabase.from).toHaveBeenCalledWith('agent_requests');
+	});
+
+	it('should throw error when update fails', async () => {
+		const supabase = createMockSupabase({
+			updateResult: { data: null, error: { message: 'Update failed' } },
+		});
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			answerQuestion({
+				request_id: '123e4567-e89b-12d3-a456-426614174000',
+				answer: 'Answer',
+			}, ctx)
+		).rejects.toThrow();
+	});
+});

package/src/handlers/requests.ts

@@ -0,0 +1,150 @@
+/**
+ * Requests Handlers
+ *
+ * Handles user request handling:
+ * - get_pending_requests
+ * - acknowledge_request
+ * - answer_question
+ */
+
+import type { Handler, HandlerRegistry } from './types.js';
+import { validateRequired, validateUUID } from '../validators.js';
+
+export const getPendingRequests: Handler = async (args, ctx) => {
+	const { project_id } = args as { project_id: string };
+
+	validateRequired(project_id, 'project_id');
+	validateUUID(project_id, 'project_id');
+
+	const { supabase, session } = ctx;
+	const currentSessionId = session.currentSessionId;
+
+	// Get active session IDs to identify orphaned questions
+	const { data: activeSessions } = await supabase
+		.from('agent_sessions')
+		.select('id')
+		.eq('project_id', project_id)
+		.eq('status', 'active');
+	const activeSessionIds = new Set((activeSessions || []).map((s) => s.id));
+
+	// Get pending requests for this project:
+	// - Unacknowledged requests OR unanswered questions (questions need answers, not just acknowledgment)
+	const { data: requests, error } = await supabase
+		.from('agent_requests')
+		.select('*')
+		.eq('project_id', project_id)
+		.or('acknowledged_at.is.null,and(request_type.eq.question,answered_at.is.null)')
+		.order('created_at', { ascending: false });
+
+	if (error) throw error;
+
+	// Filter to requests this agent can handle
+	const filteredRequests = (requests || []).filter((r) => {
+		// Broadcast requests (session_id is null) - anyone can handle
+		if (!r.session_id) return true;
+		// Targeted to this session
+		if (r.session_id === currentSessionId) return true;
+		// Orphaned questions (targeted session is disconnected) - any agent can answer
+		if (r.request_type === 'question' && !activeSessionIds.has(r.session_id)) return true;
+		return false;
+	});
+
+	// Sort questions first (highest priority) and add wait times
+	const now = new Date();
+	const sortedRequests = filteredRequests
+		.map((r) => ({
+			...r,
+			wait_minutes: Math.floor((now.getTime() - new Date(r.created_at).getTime()) / 60000),
+		}))
+		.sort((a, b) => {
+			// Questions first, then by created_at (oldest first for urgency)
+			const aIsQuestion = a.request_type === 'question' && !a.answered_at;
+			const bIsQuestion = b.request_type === 'question' && !b.answered_at;
+			if (aIsQuestion && !bIsQuestion) return -1;
+			if (!aIsQuestion && bIsQuestion) return 1;
+			return new Date(a.created_at).getTime() - new Date(b.created_at).getTime();
+		});
+
+	// Count unanswered questions separately
+	const questionsCount = sortedRequests.filter(
+		(r) => r.request_type === 'question' && !r.answered_at
+	).length;
+
+	return {
+		result: {
+			requests: sortedRequests,
+			count: sortedRequests.length,
+			questions_count: questionsCount,
+		},
+	};
+};
+
+export const acknowledgeRequest: Handler = async (args, ctx) => {
+	const { request_id } = args as { request_id: string };
+
+	validateRequired(request_id, 'request_id');
+	validateUUID(request_id, 'request_id');
+
+	const { supabase, session } = ctx;
+
+	const { data: request, error } = await supabase
+		.from('agent_requests')
+		.update({
+			acknowledged_at: new Date().toISOString(),
+			acknowledged_by_session_id: session.currentSessionId,
+		})
+		.eq('id', request_id)
+		.select()
+		.single();
+
+	if (error) throw error;
+
+	return {
+		result: {
+			success: true,
+			request,
+		},
+	};
+};
+
+export const answerQuestion: Handler = async (args, ctx) => {
+	const { request_id, answer } = args as { request_id: string; answer: string };
+
+	validateRequired(request_id, 'request_id');
+	validateRequired(answer, 'answer');
+	validateUUID(request_id, 'request_id');
+
+	const { supabase, session } = ctx;
+
+	// Update the request with the answer
+	const { data: request, error } = await supabase
+		.from('agent_requests')
+		.update({
+			answer,
+			answered_at: new Date().toISOString(),
+			acknowledged_at: new Date().toISOString(),
+			acknowledged_by_session_id: session.currentSessionId,
+		})
+		.eq('id', request_id)
+		.select()
+		.single();
+
+	if (error) throw error;
+
+	return {
+		result: {
+			success: true,
+			message: 'Question answered successfully',
+			request,
+		},
+	};
+};
+
+/**
+ * Requests handlers registry
+ */
+export const requestHandlers: HandlerRegistry = {
+	get_pending_requests: getPendingRequests,
+	acknowledge_request: acknowledgeRequest,
+	answer_question: answerQuestion,
+};