@vibescope/mcp-server 0.0.1

package/src/handlers/session.test.ts

@@ -0,0 +1,459 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type { HandlerContext, TokenUsage } from './types.js';
+import {
+	heartbeat,
+	endWorkSession,
+	getHelp,
+	getTokenUsage,
+} from './session.js';
+
+// ============================================================================
+// Test Utilities
+// ============================================================================
+
+/**
+ * Creates a mock Supabase client with chainable methods
+ */
+function createMockSupabase(overrides: {
+	selectResult?: { data: unknown; error: unknown };
+	insertResult?: { data: unknown; error: unknown };
+	updateResult?: { data: unknown; error: unknown };
+} = {}) {
+	const defaultResult = { data: null, error: null };
+
+	let currentOperation = 'select';
+	let insertThenSelect = false;
+
+	const mock = {
+		from: vi.fn().mockReturnThis(),
+		select: vi.fn(() => {
+			if (currentOperation === 'insert') {
+				insertThenSelect = true;
+			} else {
+				currentOperation = 'select';
+				insertThenSelect = false;
+			}
+			return mock;
+		}),
+		insert: vi.fn(() => {
+			currentOperation = 'insert';
+			insertThenSelect = false;
+			return mock;
+		}),
+		update: vi.fn(() => {
+			currentOperation = 'update';
+			insertThenSelect = false;
+			return mock;
+		}),
+		delete: vi.fn(() => {
+			currentOperation = 'delete';
+			insertThenSelect = false;
+			return mock;
+		}),
+		eq: vi.fn().mockReturnThis(),
+		neq: vi.fn().mockReturnThis(),
+		in: vi.fn().mockReturnThis(),
+		is: vi.fn().mockReturnThis(),
+		not: vi.fn().mockReturnThis(),
+		or: vi.fn().mockReturnThis(),
+		gte: vi.fn().mockReturnThis(),
+		lt: vi.fn().mockReturnThis(),
+		order: vi.fn().mockReturnThis(),
+		limit: vi.fn().mockReturnThis(),
+		single: vi.fn(() => {
+			if (currentOperation === 'insert' || insertThenSelect) {
+				return Promise.resolve(overrides.insertResult ?? defaultResult);
+			}
+			if (currentOperation === 'select') {
+				return Promise.resolve(overrides.selectResult ?? defaultResult);
+			}
+			if (currentOperation === 'update') {
+				return Promise.resolve(overrides.updateResult ?? defaultResult);
+			}
+			return Promise.resolve(defaultResult);
+		}),
+		maybeSingle: vi.fn(() => {
+			return Promise.resolve(overrides.selectResult ?? defaultResult);
+		}),
+		then: vi.fn((resolve: (value: unknown) => void) => {
+			if (currentOperation === 'insert' || insertThenSelect) {
+				return Promise.resolve(overrides.insertResult ?? defaultResult).then(resolve);
+			}
+			if (currentOperation === 'select') {
+				return Promise.resolve(overrides.selectResult ?? defaultResult).then(resolve);
+			}
+			if (currentOperation === 'update') {
+				return Promise.resolve(overrides.updateResult ?? defaultResult).then(resolve);
+			}
+			return Promise.resolve(defaultResult).then(resolve);
+		}),
+	};
+
+	return mock as unknown as SupabaseClient;
+}
+
+/**
+ * Creates a mock handler context with full session state
+ */
+function createMockContext(
+	supabase: SupabaseClient,
+	options: {
+		sessionId?: string | null;
+		tokenUsage?: TokenUsage;
+	} = {}
+): HandlerContext {
+	const defaultTokenUsage: TokenUsage = {
+		callCount: 10,
+		totalTokens: 5000,
+		byTool: {
+			get_tasks: { calls: 3, tokens: 1500 },
+			update_task: { calls: 4, tokens: 2000 },
+			complete_task: { calls: 3, tokens: 1500 },
+		},
+	};
+
+	// Use 'in' check to allow explicit null values for sessionId
+	const sessionId = 'sessionId' in options ? options.sessionId : 'session-123';
+
+	return {
+		supabase,
+		auth: {
+			userId: 'user-123',
+			apiKeyId: 'api-key-123',
+		},
+		session: {
+			instanceId: 'instance-abc123',
+			currentSessionId: sessionId,
+			currentPersona: 'Wave',
+			tokenUsage: options.tokenUsage ?? defaultTokenUsage,
+		},
+		updateSession: vi.fn(),
+	};
+}
+
+// ============================================================================
+// heartbeat Tests
+// ============================================================================
+
+describe('heartbeat', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('should record heartbeat successfully', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: null, error: null },
+			updateResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await heartbeat({}, ctx);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			session_id: 'session-123',
+		});
+		expect(result.result).toHaveProperty('timestamp');
+		expect(supabase.from).toHaveBeenCalledWith('agent_heartbeats');
+		expect(supabase.insert).toHaveBeenCalled();
+	});
+
+	it('should use provided session_id over current session', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: null, error: null },
+			updateResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await heartbeat({ session_id: 'other-session-456' }, ctx);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			session_id: 'other-session-456',
+		});
+	});
+
+	it('should return error when no active session', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase, { sessionId: null });
+
+		const result = await heartbeat({}, ctx);
+
+		expect(result.result).toMatchObject({
+			error: 'No active session. Call start_work_session first.',
+		});
+	});
+
+	it('should update session with token usage', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: null, error: null },
+			updateResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await heartbeat({}, ctx);
+
+		expect(supabase.from).toHaveBeenCalledWith('agent_sessions');
+		expect(supabase.update).toHaveBeenCalledWith(
+			expect.objectContaining({
+				status: 'active',
+				total_tokens: 5000,
+			})
+		);
+	});
+});
+
+// ============================================================================
+// getHelp Tests
+// ============================================================================
+
+describe('getHelp', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('should return help content for valid topic', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await getHelp({ topic: 'tasks' }, ctx);
+
+		expect(result.result).toHaveProperty('topic', 'tasks');
+		expect(result.result).toHaveProperty('content');
+	});
+
+	it('should return getting_started help', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await getHelp({ topic: 'getting_started' }, ctx);
+
+		expect(result.result).toHaveProperty('topic', 'getting_started');
+		expect(result.result).toHaveProperty('content');
+	});
+
+	it('should return error for unknown topic', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await getHelp({ topic: 'unknown_topic' }, ctx);
+
+		expect(result.result).toMatchObject({
+			error: 'Unknown topic: unknown_topic',
+		});
+		expect(result.result).toHaveProperty('available');
+	});
+
+	it('should list available topics for unknown topic', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await getHelp({ topic: 'nonexistent' }, ctx);
+
+		const available = (result.result as { available: string[] }).available;
+		expect(Array.isArray(available)).toBe(true);
+		expect(available.length).toBeGreaterThan(0);
+	});
+});
+
+// ============================================================================
+// getTokenUsage Tests
+// ============================================================================
+
+describe('getTokenUsage', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('should return token usage stats', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await getTokenUsage({}, ctx);
+
+		expect(result.result).toHaveProperty('session');
+		expect(result.result).toHaveProperty('top_tools');
+		expect(result.result).toHaveProperty('note');
+	});
+
+	it('should return correct session stats', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase, {
+			tokenUsage: {
+				callCount: 10,
+				totalTokens: 5000,
+				byTool: {},
+			},
+		});
+
+		const result = await getTokenUsage({}, ctx);
+		const session = (result.result as { session: { calls: number; tokens: number; avg_per_call: number } }).session;
+
+		expect(session.calls).toBe(10);
+		expect(session.tokens).toBe(5000);
+		expect(session.avg_per_call).toBe(500);
+	});
+
+	it('should return top tools sorted by tokens', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase, {
+			tokenUsage: {
+				callCount: 10,
+				totalTokens: 5000,
+				byTool: {
+					tool_a: { calls: 2, tokens: 1000 },
+					tool_b: { calls: 5, tokens: 3000 },
+					tool_c: { calls: 3, tokens: 1000 },
+				},
+			},
+		});
+
+		const result = await getTokenUsage({}, ctx);
+		const topTools = (result.result as { top_tools: Array<{ tool: string; tokens: number }> }).top_tools;
+
+		// Should be sorted by tokens descending
+		expect(topTools[0].tool).toBe('tool_b');
+		expect(topTools[0].tokens).toBe(3000);
+	});
+
+	it('should handle zero calls gracefully', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase, {
+			tokenUsage: {
+				callCount: 0,
+				totalTokens: 0,
+				byTool: {},
+			},
+		});
+
+		const result = await getTokenUsage({}, ctx);
+		const session = (result.result as { session: { calls: number; tokens: number; avg_per_call: number } }).session;
+
+		expect(session.calls).toBe(0);
+		expect(session.tokens).toBe(0);
+		expect(session.avg_per_call).toBe(0);
+	});
+
+	it('should limit top_tools to 5', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase, {
+			tokenUsage: {
+				callCount: 20,
+				totalTokens: 10000,
+				byTool: {
+					tool_1: { calls: 1, tokens: 100 },
+					tool_2: { calls: 2, tokens: 200 },
+					tool_3: { calls: 3, tokens: 300 },
+					tool_4: { calls: 4, tokens: 400 },
+					tool_5: { calls: 5, tokens: 500 },
+					tool_6: { calls: 6, tokens: 600 },
+					tool_7: { calls: 7, tokens: 700 },
+				},
+			},
+		});
+
+		const result = await getTokenUsage({}, ctx);
+		const topTools = (result.result as { top_tools: Array<{ tool: string }> }).top_tools;
+
+		expect(topTools.length).toBe(5);
+	});
+});
+
+// ============================================================================
+// endWorkSession Tests
+// ============================================================================
+
+describe('endWorkSession', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('should handle no active session gracefully', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase, { sessionId: null });
+
+		const result = await endWorkSession({}, ctx);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			message: 'No active session to end',
+		});
+	});
+
+	it('should use provided session_id over current session', async () => {
+		const supabase = createMockSupabase({
+			selectResult: {
+				data: {
+					project_id: 'project-123',
+					agent_name: 'Wave',
+					started_at: new Date().toISOString()
+				},
+				error: null
+			},
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await endWorkSession({ session_id: 'other-session-456' }, ctx);
+
+		expect(result.result).toHaveProperty('ended_session_id', 'other-session-456');
+	});
+
+	it('should call updateSession to clear current session', async () => {
+		const supabase = createMockSupabase({
+			selectResult: {
+				data: {
+					project_id: 'project-123',
+					agent_name: 'Wave',
+					started_at: new Date().toISOString()
+				},
+				error: null
+			},
+		});
+		const ctx = createMockContext(supabase);
+
+		await endWorkSession({}, ctx);
+
+		expect(ctx.updateSession).toHaveBeenCalledWith({ currentSessionId: null });
+	});
+
+	it('should return session summary', async () => {
+		const supabase = createMockSupabase({
+			selectResult: {
+				data: {
+					project_id: 'project-123',
+					agent_name: 'Wave',
+					started_at: new Date().toISOString()
+				},
+				error: null
+			},
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await endWorkSession({}, ctx);
+
+		expect(result.result).toHaveProperty('session_summary');
+		const summary = (result.result as { session_summary: { agent_name: string; token_usage: unknown } }).session_summary;
+		expect(summary.agent_name).toBe('Wave');
+		expect(summary).toHaveProperty('token_usage');
+	});
+
+	it('should not call updateSession when ending a different session', async () => {
+		const supabase = createMockSupabase({
+			selectResult: {
+				data: {
+					project_id: 'project-123',
+					agent_name: 'Wave',
+					started_at: new Date().toISOString()
+				},
+				error: null
+			},
+		});
+		const ctx = createMockContext(supabase, { sessionId: 'session-123' });
+
+		await endWorkSession({ session_id: 'different-session' }, ctx);
+
+		// Should NOT clear the current session since we're ending a different one
+		expect(ctx.updateSession).not.toHaveBeenCalledWith({ currentSessionId: null });
+	});
+});