@vibescope/mcp-server 0.2.1 → 0.2.3

package/src/api-client.ts

@@ -123,6 +123,23 @@ export class VibescopeApiClient {
 			priority: number;
 			estimated_minutes?: number;
 		} | null;
+		pending_requests?: Array<{
+			id: string;
+			request_type: string;
+			message: string;
+			created_at: string;
+		}>;
+		pending_requests_count?: number;
+		URGENT_QUESTIONS?: {
+			count: number;
+			oldest_waiting_minutes: number;
+			action_required: string;
+			requests: Array<{
+				id: string;
+				message: string;
+				waiting_minutes: number;
+			}>;
+		};
 		directive?: string;
 		blockers_count?: number;
 		validation_count?: number;
@@ -382,6 +399,7 @@ export class VibescopeApiClient {
 		progress_note?: string;
 		estimated_minutes?: number;
 		git_branch?: string;
+		worktree_path?: string;
 		session_id?: string;
 	}): Promise<ApiResponse<{
 		success: boolean;
@@ -426,7 +444,11 @@ export class VibescopeApiClient {
 		next_action: string;
 		warnings?: string[];
 	}>> {
-		return this.request('POST', `/api/mcp/tasks/${taskId}/complete`, params);
+		// Use proxy endpoint for consistency - direct endpoint had routing issues on Vercel
+		return this.proxy('complete_task', {
+			task_id: taskId,
+			summary: params.summary,
+		}, params.session_id ? { session_id: params.session_id, persona: null, instance_id: '' } : undefined);
 	}
 
 	async deleteTask(taskId: string): Promise<ApiResponse<{
@@ -1609,6 +1631,63 @@ export class VibescopeApiClient {
 		});
 	}
 
+	async getBodyOfWorkCosts(params: {
+		body_of_work_id?: string;
+		project_id?: string;
+	}): Promise<ApiResponse<{
+		bodies_of_work: Array<{
+			body_of_work_id: string;
+			title: string;
+			project_id: string;
+			status: string;
+			task_count: number;
+			total_cost_usd: number;
+			total_tokens: number;
+			pre_phase_cost_usd: number;
+			core_phase_cost_usd: number;
+			post_phase_cost_usd: number;
+			model_breakdown: Record<string, { input: number; output: number }>;
+		}>;
+		count: number;
+		totals: {
+			total_cost_usd: number;
+			total_tokens: number;
+			total_tasks: number;
+		};
+	}>> {
+		return this.proxy('get_body_of_work_costs', params);
+	}
+
+	async getSprintCosts(params: {
+		sprint_id?: string;
+		project_id?: string;
+	}): Promise<ApiResponse<{
+		sprints: Array<{
+			sprint_id: string;
+			title: string;
+			project_id: string;
+			status: string;
+			sprint_number: number;
+			task_count: number;
+			total_cost_usd: number;
+			total_tokens: number;
+			cost_per_story_point: number | null;
+			committed_points: number;
+			velocity_points: number;
+			model_breakdown: Record<string, { input: number; output: number }>;
+		}>;
+		count: number;
+		totals: {
+			total_cost_usd: number;
+			total_tokens: number;
+			total_tasks: number;
+			total_velocity_points: number;
+			avg_cost_per_point: number | null;
+		};
+	}>> {
+		return this.proxy('get_sprint_costs', params);
+	}
+
 	async getTokenUsage(): Promise<ApiResponse<{
 		session_tokens: number;
 		estimated_cost: number;
@@ -1695,6 +1774,7 @@ export class VibescopeApiClient {
 		environment?: string;
 		version_bump?: string;
 		auto_trigger?: boolean;
+		hours_interval?: number;
 		notes?: string;
 		git_ref?: string;
 	}): Promise<ApiResponse<{
@@ -1712,6 +1792,7 @@ export class VibescopeApiClient {
 			id: string;
 			scheduled_at: string;
 			schedule_type: string;
+			hours_interval: number;
 			environment: string;
 			version_bump: string;
 			auto_trigger: boolean;
@@ -1731,6 +1812,7 @@ export class VibescopeApiClient {
 	async updateScheduledDeployment(scheduleId: string, updates: {
 		scheduled_at?: string;
 		schedule_type?: string;
+		hours_interval?: number;
 		environment?: string;
 		version_bump?: string;
 		auto_trigger?: boolean;
@@ -1883,6 +1965,159 @@ export class VibescopeApiClient {
 	}>> {
 		return this.proxy('abandon_checkout', params);
 	}
+
+	// ============================================================================
+	// Worktree Management
+	// ============================================================================
+
+	async getStaleWorktrees(projectId: string): Promise<ApiResponse<{
+		project_id: string;
+		project_name: string;
+		stale_worktrees: Array<{
+			task_id: string;
+			task_title: string;
+			worktree_path: string;
+			git_branch: string | null;
+			status: string;
+			completed_at: string | null;
+			updated_at: string;
+			pr_url: string | null;
+			stale_reason: 'task_finished' | 'potentially_abandoned';
+		}>;
+		count: number;
+		cleanup_instructions: string[] | null;
+	}>> {
+		return this.request('GET', `/api/mcp/worktrees/stale?project_id=${projectId}`);
+	}
+
+	async clearWorktreePath(taskId: string): Promise<ApiResponse<{
+		success: boolean;
+		task_id: string;
+	}>> {
+		return this.request('PATCH', `/api/mcp/tasks/${taskId}`, { worktree_path: null });
+	}
+
+	// ============================================================================
+	// Connector endpoints
+	// ============================================================================
+
+	async getConnectors(projectId: string, params?: {
+		type?: string;
+		status?: string;
+		limit?: number;
+		offset?: number;
+	}): Promise<ApiResponse<{
+		connectors: Array<{
+			id: string;
+			name: string;
+			type: string;
+			description?: string;
+			status: string;
+			events: Record<string, boolean>;
+			events_sent: number;
+			last_triggered_at?: string;
+			last_error?: string;
+			last_error_at?: string;
+			created_at: string;
+		}>;
+		total_count: number;
+		has_more: boolean;
+	}>> {
+		return this.proxy('get_connectors', {
+			project_id: projectId,
+			...params
+		});
+	}
+
+	async getConnector(connectorId: string): Promise<ApiResponse<{
+		connector: {
+			id: string;
+			name: string;
+			type: string;
+			description?: string;
+			config: Record<string, unknown>;
+			events: Record<string, boolean>;
+			status: string;
+			events_sent: number;
+			last_triggered_at?: string;
+			last_error?: string;
+			last_error_at?: string;
+			created_at: string;
+		};
+	}>> {
+		return this.proxy('get_connector', { connector_id: connectorId });
+	}
+
+	async addConnector(projectId: string, params: {
+		name: string;
+		type: string;
+		description?: string;
+		config?: Record<string, unknown>;
+		events?: Record<string, boolean>;
+	}): Promise<ApiResponse<{
+		success: boolean;
+		connector_id: string;
+	}>> {
+		return this.proxy('add_connector', {
+			project_id: projectId,
+			...params
+		});
+	}
+
+	async updateConnector(connectorId: string, updates: {
+		name?: string;
+		description?: string;
+		config?: Record<string, unknown>;
+		events?: Record<string, boolean>;
+		status?: string;
+	}): Promise<ApiResponse<{
+		success: boolean;
+		connector_id: string;
+	}>> {
+		return this.proxy('update_connector', {
+			connector_id: connectorId,
+			...updates
+		});
+	}
+
+	async deleteConnector(connectorId: string): Promise<ApiResponse<{
+		success: boolean;
+	}>> {
+		return this.proxy('delete_connector', { connector_id: connectorId });
+	}
+
+	async testConnector(connectorId: string): Promise<ApiResponse<{
+		success: boolean;
+		event_id: string;
+		status?: number;
+		error?: string;
+	}>> {
+		return this.proxy('test_connector', { connector_id: connectorId });
+	}
+
+	async getConnectorEvents(params: {
+		connector_id?: string;
+		project_id?: string;
+		status?: string;
+		limit?: number;
+		offset?: number;
+	}): Promise<ApiResponse<{
+		events: Array<{
+			id: string;
+			connector_id: string;
+			event_type: string;
+			status: string;
+			response_status?: number;
+			error_message?: string;
+			attempts: number;
+			created_at: string;
+			sent_at?: string;
+		}>;
+		total_count: number;
+		has_more: boolean;
+	}>> {
+		return this.proxy('get_connector_events', params);
+	}
 }
 
 // Singleton instance

package/src/handlers/__test-setup__.ts

@@ -176,6 +176,15 @@ export const mockApiClient = {
 	getFileCheckouts: vi.fn(),
 	abandonCheckout: vi.fn(),
 
+	// Connectors
+	getConnectors: vi.fn(),
+	getConnector: vi.fn(),
+	addConnector: vi.fn(),
+	updateConnector: vi.fn(),
+	deleteConnector: vi.fn(),
+	testConnector: vi.fn(),
+	getConnectorEvents: vi.fn(),
+
 	// Proxy (generic)
 	proxy: vi.fn(),
 };

package/src/handlers/blockers.test.ts

@@ -83,19 +83,22 @@ describe('addBlocker', () => {
 		);
 	});
 
-	it('should throw error when API call fails', async () => {
+	it('should return error when API call fails', async () => {
 		mockApiClient.addBlocker.mockResolvedValue({
 			ok: false,
 			error: 'Insert failed',
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			addBlocker({
-				project_id: '123e4567-e89b-12d3-a456-426614174000',
-				description: 'Test blocker',
-			}, ctx)
-		).rejects.toThrow('Insert failed');
+		const result = await addBlocker({
+			project_id: '123e4567-e89b-12d3-a456-426614174000',
+			description: 'Test blocker',
+		}, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Insert failed',
+		});
 	});
 });
 
@@ -177,16 +180,19 @@ describe('resolveBlocker', () => {
 		);
 	});
 
-	it('should throw error when API call fails', async () => {
+	it('should return error when API call fails', async () => {
 		mockApiClient.resolveBlocker.mockResolvedValue({
 			ok: false,
 			error: 'Update failed',
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			resolveBlocker({ blocker_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Update failed');
+		const result = await resolveBlocker({ blocker_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Update failed',
+		});
 	});
 });
 
@@ -298,16 +304,19 @@ describe('getBlockers', () => {
 		expect(mockApiClient.getBlockers).toHaveBeenCalled();
 	});
 
-	it('should throw error when API call fails', async () => {
+	it('should return error when API call fails', async () => {
 		mockApiClient.getBlockers.mockResolvedValue({
 			ok: false,
 			error: 'Query failed',
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			getBlockers({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Query failed');
+		const result = await getBlockers({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Query failed',
+		});
 	});
 });
 
@@ -366,15 +375,18 @@ describe('deleteBlocker', () => {
 		);
 	});
 
-	it('should throw error when API call fails', async () => {
+	it('should return error when API call fails', async () => {
 		mockApiClient.deleteBlocker.mockResolvedValue({
 			ok: false,
 			error: 'Delete failed',
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			deleteBlocker({ blocker_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Delete failed');
+		const result = await deleteBlocker({ blocker_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Delete failed',
+		});
 	});
 });

package/src/handlers/blockers.ts

@@ -9,6 +9,7 @@
  */
 
 import type { Handler, HandlerRegistry } from './types.js';
+import { success, error } from './types.js';
 import {
 	parseArgs,
 	uuidValidator,
@@ -47,10 +48,10 @@ export const addBlocker: Handler = async (args, ctx) => {
 	const response = await apiClient.addBlocker(project_id, description, ctx.session.currentSessionId || undefined);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to add blocker');
+		return error(response.error || 'Failed to add blocker');
 	}
 
-	return { result: response.data };
+	return success(response.data);
 };
 
 export const resolveBlocker: Handler = async (args, _ctx) => {
@@ -60,10 +61,10 @@ export const resolveBlocker: Handler = async (args, _ctx) => {
 	const response = await apiClient.resolveBlocker(blocker_id, resolution_note);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to resolve blocker');
+		return error(response.error || 'Failed to resolve blocker');
 	}
 
-	return { result: response.data };
+	return success(response.data);
 };
 
 export const getBlockers: Handler = async (args, _ctx) => {
@@ -78,10 +79,10 @@ export const getBlockers: Handler = async (args, _ctx) => {
 	});
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to fetch blockers');
+		return error(response.error || 'Failed to fetch blockers');
 	}
 
-	return { result: response.data };
+	return success(response.data);
 };
 
 export const deleteBlocker: Handler = async (args, _ctx) => {
@@ -91,10 +92,10 @@ export const deleteBlocker: Handler = async (args, _ctx) => {
 	const response = await apiClient.deleteBlocker(blocker_id);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to delete blocker');
+		return error(response.error || 'Failed to delete blocker');
 	}
 
-	return { result: response.data };
+	return success(response.data);
 };
 
 /**

package/src/handlers/bodies-of-work.test.ts

@@ -109,16 +109,19 @@ describe('createBodyOfWork', () => {
 		);
 	});
 
-	it('should throw error when API call fails', async () => {
+	it('should return error when API call fails', async () => {
 		const ctx = createMockContext();
 		mockApiClient.proxy.mockResolvedValue({
 			ok: false,
 			error: 'Insert failed',
 		});
 
-		await expect(
-			createBodyOfWork({ project_id: VALID_UUID, title: 'Test' }, ctx)
-		).rejects.toThrow('Failed to create body of work');
+		const result = await createBodyOfWork({ project_id: VALID_UUID, title: 'Test' }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Insert failed',
+		});
 	});
 });
 
@@ -201,16 +204,19 @@ describe('getBodyOfWork', () => {
 		await expect(getBodyOfWork({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error when body of work not found', async () => {
+	it('should return error when body of work not found', async () => {
 		const ctx = createMockContext();
 		mockApiClient.proxy.mockResolvedValue({
 			ok: false,
 			error: 'Not found',
 		});
 
-		await expect(
-			getBodyOfWork({ body_of_work_id: VALID_UUID }, ctx)
-		).rejects.toThrow('Failed to get body of work');
+		const result = await getBodyOfWork({ body_of_work_id: VALID_UUID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Not found',
+		});
 	});
 
 	it('should return body of work with tasks organized by phase', async () => {
@@ -331,16 +337,19 @@ describe('addTaskToBodyOfWork', () => {
 		).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error when API returns error', async () => {
+	it('should return error when API returns error', async () => {
 		const ctx = createMockContext();
 		mockApiClient.proxy.mockResolvedValue({
 			ok: false,
 			error: 'Body of work not found',
 		});
 
-		await expect(
-			addTaskToBodyOfWork({ body_of_work_id: VALID_UUID, task_id: VALID_UUID_2 }, ctx)
-		).rejects.toThrow('Failed to add task to body of work');
+		const result = await addTaskToBodyOfWork({ body_of_work_id: VALID_UUID, task_id: VALID_UUID_2 }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Body of work not found',
+		});
 	});
 
 	it('should add task with default phase "core"', async () => {
@@ -435,16 +444,19 @@ describe('activateBodyOfWork', () => {
 		await expect(activateBodyOfWork({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error when API returns error', async () => {
+	it('should return error when API returns error', async () => {
 		const ctx = createMockContext();
 		mockApiClient.proxy.mockResolvedValue({
 			ok: false,
 			error: 'Body of work not found',
 		});
 
-		await expect(
-			activateBodyOfWork({ body_of_work_id: VALID_UUID }, ctx)
-		).rejects.toThrow('Failed to activate body of work');
+		const result = await activateBodyOfWork({ body_of_work_id: VALID_UUID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Body of work not found',
+		});
 	});
 
 	it('should activate body of work successfully', async () => {
@@ -484,15 +496,19 @@ describe('addTaskDependency', () => {
 		).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error when task depends on itself', async () => {
+	it('should return error when task depends on itself', async () => {
 		const ctx = createMockContext();
-		await expect(
-			addTaskDependency({
-				body_of_work_id: VALID_UUID,
-				task_id: VALID_UUID_2,
-				depends_on_task_id: VALID_UUID_2,
-			}, ctx)
-		).rejects.toThrow('A task cannot depend on itself');
+
+		const result = await addTaskDependency({
+			body_of_work_id: VALID_UUID,
+			task_id: VALID_UUID_2,
+			depends_on_task_id: VALID_UUID_2,
+		}, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'A task cannot depend on itself',
+		});
 	});
 
 	it('should add dependency successfully', async () => {
@@ -572,11 +588,15 @@ describe('removeTaskDependency', () => {
 describe('getTaskDependencies', () => {
 	beforeEach(() => vi.clearAllMocks());
 
-	it('should throw error when neither body_of_work_id nor task_id provided', async () => {
+	it('should return error when neither body_of_work_id nor task_id provided', async () => {
 		const ctx = createMockContext();
-		await expect(getTaskDependencies({}, ctx)).rejects.toThrow(
-			'Either body_of_work_id or task_id is required'
-		);
+
+		const result = await getTaskDependencies({}, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Either body_of_work_id or task_id is required',
+		});
 	});
 
 	it('should return dependencies filtered by body_of_work_id', async () => {
@@ -626,16 +646,19 @@ describe('getNextBodyOfWorkTask', () => {
 		await expect(getNextBodyOfWorkTask({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error when API returns error', async () => {
+	it('should return error when API returns error', async () => {
 		const ctx = createMockContext();
 		mockApiClient.proxy.mockResolvedValue({
 			ok: false,
 			error: 'Body of work not found',
 		});
 
-		await expect(
-			getNextBodyOfWorkTask({ body_of_work_id: VALID_UUID }, ctx)
-		).rejects.toThrow('Failed to get next body of work task');
+		const result = await getNextBodyOfWorkTask({ body_of_work_id: VALID_UUID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Body of work not found',
+		});
 	});
 
 	it('should return null when no tasks available', async () => {