@vibescope/mcp-server 0.0.1 → 0.1.0

package/src/handlers/deployment.ts

@@ -21,6 +21,7 @@ import {
 	validateUUID,
 	validateEnvironment,
 } from '../validators.js';
+import { getApiClient } from '../api-client.js';
 
 export const requestDeployment: Handler = async (args, ctx) => {
 	const { project_id, environment = 'production', version_bump = 'patch', notes, git_ref } = args as {
@@ -31,8 +32,7 @@ export const requestDeployment: Handler = async (args, ctx) => {
 		git_ref?: string;
 	};
 
-	const { supabase, session } = ctx;
-	const currentSessionId = session.currentSessionId;
+	const { session } = ctx;
 
 	validateRequired(project_id, 'project_id');
 	validateUUID(project_id, 'project_id');
@@ -46,220 +46,39 @@ export const requestDeployment: Handler = async (args, ctx) => {
 		});
 	}
 
-	// Check for existing active deployment
-	const { data: existingDeployment } = await supabase
-		.from('deployments')
-		.select('id, status')
-		.eq('project_id', project_id)
-		.not('status', 'in', '("deployed","failed")')
-		.single();
-
-	if (existingDeployment) {
-		return {
-			result: {
-				success: false,
-				error: 'A deployment is already in progress',
-				existing_deployment_id: existingDeployment.id,
-				existing_status: existingDeployment.status,
-				hint: 'Wait for the current deployment to complete or cancel it first',
-			},
-		};
-	}
-
-	// Check for unvalidated completed tasks
-	const { data: unvalidatedTasks } = await supabase
-		.from('tasks')
-		.select('id, title, completed_at, completed_by_session_id')
-		.eq('project_id', project_id)
-		.eq('status', 'completed')
-		.is('validated_at', null)
-		.order('completed_at', { ascending: true });
-
-	if (unvalidatedTasks && unvalidatedTasks.length > 0) {
-		return {
-			result: {
-				success: false,
-				error: 'Cannot deploy: There are unvalidated completed tasks',
-				unvalidated_tasks: unvalidatedTasks.map(t => ({
-					id: t.id,
-					title: t.title,
-					completed_at: t.completed_at,
-				})),
-				unvalidated_count: unvalidatedTasks.length,
-				hint: 'All completed tasks must be validated before deployment. Use validate_task to review each task.',
-				action: `Call validate_task(task_id: "${unvalidatedTasks[0].id}", approved: true/false, validation_notes: "...")`,
-			},
-		};
-	}
+	const apiClient = getApiClient();
+	const response = await apiClient.requestDeployment(project_id, {
+		environment,
+		version_bump,
+		notes,
+		git_ref
+	});
 
-	// Get current version from project
-	const { data: project } = await supabase
-		.from('projects')
-		.select('current_version')
-		.eq('id', project_id)
-		.single();
-
-	const currentVersion = project?.current_version || '0.0.0';
-
-	// Create new deployment
-	const { data: deployment, error } = await supabase
-		.from('deployments')
-		.insert({
-			project_id,
-			environment,
-			version_bump,
-			notes,
-			git_ref,
-			requested_by: 'agent',
-			requesting_agent_session_id: currentSessionId,
-		})
-		.select()
-		.single();
-
-	if (error) throw error;
-
-	// Auto-convert pending deployment requirements to tasks
-	const { data: pendingRequirements } = await supabase
-		.from('deployment_requirements')
-		.select('id, type, title, description, stage, blocking')
-		.eq('project_id', project_id)
-		.eq('status', 'pending')
-		.is('converted_task_id', null);
-
-	const convertedTasks: Array<{ task_id: string; requirement_id: string; title: string }> = [];
-
-	if (pendingRequirements && pendingRequirements.length > 0) {
-		for (const req of pendingRequirements) {
-			const isDeployStage = req.stage === 'deployment';
-			const isBlocking = req.blocking ?? isDeployStage;
-			const titlePrefix = isBlocking
-				? 'DEPLOY:'
-				: isDeployStage
-					? 'DEPLOY:'
-					: req.stage === 'verification'
-						? 'VERIFY:'
-						: 'PREP:';
-
-			// Create linked task
-			const { data: newTask } = await supabase
-				.from('tasks')
-				.insert({
-					project_id,
-					title: `${titlePrefix} ${req.title}`,
-					description: `[${req.type}] ${req.description || req.title}`,
-					priority: 1,
-					status: 'pending',
-					blocking: isBlocking,
-					created_by: 'agent',
-					created_by_session_id: currentSessionId,
-				})
-				.select('id')
-				.single();
-
-			if (newTask) {
-				// Link task to requirement WITHOUT changing status
-				// This keeps the requirement visible in the deployment steps list (permanent)
-				await supabase
-					.from('deployment_requirements')
-					.update({
-						converted_task_id: newTask.id,
-					})
-					.eq('id', req.id);
-
-				convertedTasks.push({
-					task_id: newTask.id,
-					requirement_id: req.id,
-					title: `${titlePrefix} ${req.title}`,
-				});
-			}
-		}
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to request deployment');
 	}
 
-	// Log progress
-	const convertedMsg = convertedTasks.length > 0
-		? ` (${convertedTasks.length} requirements converted to tasks)`
-		: '';
-	await supabase.from('progress_logs').insert({
-		project_id,
-		summary: `Deployment requested for ${environment} (${version_bump} bump from ${currentVersion})${convertedMsg}`,
-		details: notes || undefined,
-		created_by: 'agent',
-		created_by_session_id: currentSessionId,
-	});
-
-	return {
-		result: {
-			success: true,
-			deployment_id: deployment.id,
-			status: deployment.status,
-			environment: deployment.environment,
-			version_bump,
-			current_version: currentVersion,
-			converted_requirements: convertedTasks.length,
-			converted_tasks: convertedTasks.length > 0 ? convertedTasks : undefined,
-			message: convertedTasks.length > 0
-				? `Deployment created. ${convertedTasks.length} requirements converted to tasks. Run build/tests then call claim_deployment_validation.`
-				: 'Deployment created. Run build/tests then call claim_deployment_validation.',
-		},
-	};
+	return { result: response.data };
 };
 
 export const claimDeploymentValidation: Handler = async (args, ctx) => {
 	const { project_id } = args as { project_id: string };
-	const { supabase, session } = ctx;
-	const currentSessionId = session.currentSessionId;
+	const { session } = ctx;
 
 	validateRequired(project_id, 'project_id');
 	validateUUID(project_id, 'project_id');
 
-	// Find pending deployment
-	const { data: deployment, error: fetchError } = await supabase
-		.from('deployments')
-		.select('*')
-		.eq('project_id', project_id)
-		.eq('status', 'pending')
-		.single();
-
-	if (fetchError || !deployment) {
-		return {
-			result: {
-				success: false,
-				error: 'No pending deployment found',
-				hint: 'Use request_deployment to create a deployment first, or check_deployment_status to see current state',
-			},
-		};
-	}
+	const apiClient = getApiClient();
+	const response = await apiClient.claimDeploymentValidation(
+		project_id,
+		session.currentSessionId || undefined
+	);
 
-	// Claim validation
-	const { data: updated, error: updateError } = await supabase
-		.from('deployments')
-		.update({
-			status: 'validating',
-			validation_agent_session_id: currentSessionId,
-			validation_started_at: new Date().toISOString(),
-		})
-		.eq('id', deployment.id)
-		.eq('status', 'pending')
-		.select()
-		.single();
-
-	if (updateError || !updated) {
-		return {
-			result: {
-				success: false,
-				error: 'Failed to claim validation - deployment may have been claimed by another agent',
-			},
-		};
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to claim deployment validation');
 	}
 
-	return {
-		result: {
-			success: true,
-			deployment_id: deployment.id,
-			status: 'validating',
-			message: 'Validation claimed. Run build and tests, then call report_validation with results.',
-		},
-	};
+	return { result: response.data };
 };
 
 export const reportValidation: Handler = async (args, ctx) => {
@@ -270,8 +89,7 @@ export const reportValidation: Handler = async (args, ctx) => {
 		error_message?: string;
 	};
 
-	const { supabase, session } = ctx;
-	const currentSessionId = session.currentSessionId;
+	const { session } = ctx;
 
 	validateRequired(project_id, 'project_id');
 	validateUUID(project_id, 'project_id');
@@ -282,232 +100,54 @@ export const reportValidation: Handler = async (args, ctx) => {
 		});
 	}
 
-	// Find validating deployment
-	const { data: deployment, error: fetchError } = await supabase
-		.from('deployments')
-		.select('id')
-		.eq('project_id', project_id)
-		.eq('status', 'validating')
-		.single();
-
-	if (fetchError || !deployment) {
-		return {
-			result: {
-				success: false,
-				error: 'No deployment being validated. Use claim_deployment_validation first.',
-			},
-		};
-	}
-
-	const validationPassed = build_passed && (tests_passed !== false);
-	const newStatus = validationPassed ? 'ready' : 'failed';
-
-	const { error: updateError } = await supabase
-		.from('deployments')
-		.update({
-			status: newStatus,
-			build_passed,
-			tests_passed: tests_passed ?? null,
-			validation_completed_at: new Date().toISOString(),
-			validation_error: error_message || null,
-		})
-		.eq('id', deployment.id);
-
-	if (updateError) throw updateError;
-
-	// Log result
-	await supabase.from('progress_logs').insert({
-		project_id,
-		summary: validationPassed
-			? `Deployment validation passed - ready to deploy`
-			: `Deployment validation failed: ${error_message || 'build/tests failed'}`,
-		details: `Build: ${build_passed ? 'passed' : 'failed'}, Tests: ${tests_passed === undefined ? 'skipped' : tests_passed ? 'passed' : 'failed'}`,
-		created_by: 'agent',
-		created_by_session_id: currentSessionId,
+	const apiClient = getApiClient();
+	const response = await apiClient.reportValidation(project_id, {
+		build_passed,
+		tests_passed: tests_passed ?? true,
+		error_message
 	});
 
-	// Auto-create task for failed validation
-	let createdTaskId: string | null = null;
-	if (!validationPassed) {
-		const failureType = !build_passed ? 'build' : 'test';
-		const { data: newTask } = await supabase
-			.from('tasks')
-			.insert({
-				project_id,
-				title: `Fix ${failureType} failure`,
-				description: error_message || `${failureType} failed during deployment validation`,
-				priority: 1,
-				status: 'pending',
-				created_by: 'agent',
-				created_by_session_id: currentSessionId,
-				estimated_minutes: 30,
-			})
-			.select('id')
-			.single();
-
-		createdTaskId = newTask?.id || null;
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to report validation');
 	}
 
-	return {
-		result: {
-			success: true,
-			status: newStatus,
-			passed: validationPassed,
-			...(createdTaskId && { fix_task_id: createdTaskId }),
-		},
-	};
+	return { result: response.data };
 };
 
 export const checkDeploymentStatus: Handler = async (args, ctx) => {
 	const { project_id } = args as { project_id: string };
-	const { supabase } = ctx;
 
 	validateRequired(project_id, 'project_id');
 	validateUUID(project_id, 'project_id');
 
-	// Get most recent deployment
-	const { data: deployment, error } = await supabase
-		.from('deployments')
-		.select('*')
-		.eq('project_id', project_id)
-		.order('created_at', { ascending: false })
-		.limit(1)
-		.single();
-
-	if (error || !deployment) {
-		return {
-			result: {
-				has_deployment: false,
-				message: 'No deployments found for this project',
-			},
-		};
-	}
-
-	// Auto-timeout stale deployments
-	const DEPLOYMENT_TIMEOUT_MS: Record<string, number> = {
-		pending: 30 * 60 * 1000,
-		validating: 15 * 60 * 1000,
-		ready: 30 * 60 * 1000,
-		deploying: 10 * 60 * 1000,
-	};
+	const apiClient = getApiClient();
+	const response = await apiClient.checkDeploymentStatus(project_id);
 
-	if (!['deployed', 'failed'].includes(deployment.status)) {
-		const timeout = DEPLOYMENT_TIMEOUT_MS[deployment.status];
-		if (timeout) {
-			const startTime =
-				deployment.status === 'deploying'
-					? deployment.deployment_started_at
-					: deployment.status === 'validating'
-						? deployment.validation_started_at
-						: deployment.created_at;
-
-			if (startTime && Date.now() - new Date(startTime).getTime() > timeout) {
-				const timeoutError = `Timed out: deployment was stuck in '${deployment.status}' state for too long`;
-				await supabase
-					.from('deployments')
-					.update({
-						status: 'failed',
-						deployment_error: timeoutError,
-						deployment_completed_at: new Date().toISOString(),
-					})
-					.eq('id', deployment.id);
-
-				deployment.status = 'failed';
-				deployment.deployment_error = timeoutError;
-			}
-		}
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to check deployment status');
 	}
 
-	return {
-		result: {
-			has_deployment: true,
-			deployment: {
-				id: deployment.id,
-				status: deployment.status,
-				environment: deployment.environment,
-				requested_by: deployment.requested_by,
-				build_passed: deployment.build_passed,
-				tests_passed: deployment.tests_passed,
-				validation_error: deployment.validation_error,
-				deployment_error: deployment.deployment_error,
-				deployment_summary: deployment.deployment_summary,
-				notes: deployment.notes,
-				git_ref: deployment.git_ref,
-				created_at: deployment.created_at,
-				validation_started_at: deployment.validation_started_at,
-				validation_completed_at: deployment.validation_completed_at,
-				deployment_started_at: deployment.deployment_started_at,
-				deployment_completed_at: deployment.deployment_completed_at,
-			},
-		},
-	};
+	return { result: response.data };
 };
 
 export const startDeployment: Handler = async (args, ctx) => {
 	const { project_id } = args as { project_id: string };
-	const { supabase, session } = ctx;
-	const currentSessionId = session.currentSessionId;
+	const { session } = ctx;
 
 	validateRequired(project_id, 'project_id');
 	validateUUID(project_id, 'project_id');
 
-	// Find ready deployment and project deployment instructions
-	const [deploymentResult, projectResult] = await Promise.all([
-		supabase
-			.from('deployments')
-			.select('id, environment')
-			.eq('project_id', project_id)
-			.eq('status', 'ready')
-			.single(),
-		supabase
-			.from('projects')
-			.select('deployment_instructions, git_main_branch')
-			.eq('id', project_id)
-			.single(),
-	]);
-
-	if (deploymentResult.error || !deploymentResult.data) {
-		return {
-			result: {
-				success: false,
-				error: 'No deployment ready. Must pass validation first.',
-			},
-		};
-	}
-
-	const deployment = deploymentResult.data;
-	const project = projectResult.data;
-
-	const { error: updateError } = await supabase
-		.from('deployments')
-		.update({
-			status: 'deploying',
-			deployment_started_at: new Date().toISOString(),
-		})
-		.eq('id', deployment.id);
-
-	if (updateError) throw updateError;
-
-	await supabase.from('progress_logs').insert({
+	const apiClient = getApiClient();
+	const response = await apiClient.startDeployment(
 		project_id,
-		summary: `Deployment to ${deployment.environment} started`,
-		created_by: 'agent',
-		created_by_session_id: currentSessionId,
-	});
-
-	const result: Record<string, unknown> = {
-		success: true,
-		status: 'deploying',
-		env: deployment.environment,
-	};
+		session.currentSessionId || undefined
+	);
 
-	if (project?.deployment_instructions) {
-		result.instructions = project.deployment_instructions;
-	} else {
-		result.instructions = `No deployment instructions configured. Common steps:\n1. Push to ${project?.git_main_branch || 'main'} branch\n2. Or run your deploy command (e.g., fly deploy, vercel deploy)\n3. Call complete_deployment when done`;
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to start deployment');
 	}
 
-	return { result };
+	return { result: response.data };
 };
 
 export const completeDeployment: Handler = async (args, ctx) => {
@@ -517,8 +157,7 @@ export const completeDeployment: Handler = async (args, ctx) => {
 		summary?: string;
 	};
 
-	const { supabase, session } = ctx;
-	const currentSessionId = session.currentSessionId;
+	const { session } = ctx;
 
 	validateRequired(project_id, 'project_id');
 	validateUUID(project_id, 'project_id');
@@ -529,122 +168,33 @@ export const completeDeployment: Handler = async (args, ctx) => {
 		});
 	}
 
-	// Find deploying deployment
-	const { data: deployment, error: fetchError } = await supabase
-		.from('deployments')
-		.select('id, environment, version_bump')
-		.eq('project_id', project_id)
-		.eq('status', 'deploying')
-		.single();
-
-	if (fetchError || !deployment) {
-		return {
-			result: {
-				success: false,
-				error: 'No deployment in progress. Use start_deployment first.',
-			},
-		};
-	}
-
-	const newStatus = success ? 'deployed' : 'failed';
-	let newVersion: string | null = null;
-
-	// If successful, calculate and store new version
-	if (success) {
-		const { data: project } = await supabase
-			.from('projects')
-			.select('current_version')
-			.eq('id', project_id)
-			.single();
-
-		const currentVersion = project?.current_version || '0.0.0';
-		const versionBump = deployment.version_bump || 'patch';
-		const parts = currentVersion.split('.').map((p: string) => parseInt(p, 10) || 0);
-		let [major, minor, patch] = [parts[0] || 0, parts[1] || 0, parts[2] || 0];
-
-		switch (versionBump) {
-			case 'major': major += 1; minor = 0; patch = 0; break;
-			case 'minor': minor += 1; patch = 0; break;
-			default: patch += 1;
-		}
-
-		newVersion = `${major}.${minor}.${patch}`;
+	const apiClient = getApiClient();
+	const response = await apiClient.completeDeployment(project_id, {
+		success,
+		summary
+	});
 
-		await supabase
-			.from('projects')
-			.update({ current_version: newVersion })
-			.eq('id', project_id);
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to complete deployment');
 	}
 
-	const { error: updateError } = await supabase
-		.from('deployments')
-		.update({
-			status: newStatus,
-			version: newVersion,
-			deployment_completed_at: new Date().toISOString(),
-			deployment_summary: summary || null,
-		})
-		.eq('id', deployment.id);
-
-	if (updateError) throw updateError;
-
-	await supabase.from('progress_logs').insert({
-		project_id,
-		summary: success
-			? `Deployed to ${deployment.environment}${newVersion ? ` v${newVersion}` : ''}`
-			: `Deployment failed`,
-		details: summary || undefined,
-		created_by: 'agent',
-		created_by_session_id: currentSessionId,
-	});
-
-	return {
-		result: {
-			success: true,
-			status: newStatus,
-			...(newVersion && { version: newVersion }),
-		},
-	};
+	return { result: response.data };
 };
 
 export const cancelDeployment: Handler = async (args, ctx) => {
 	const { project_id, reason } = args as { project_id: string; reason?: string };
-	const { supabase, session } = ctx;
-	const currentSessionId = session.currentSessionId;
 
 	validateRequired(project_id, 'project_id');
 	validateUUID(project_id, 'project_id');
 
-	const { data: deployment, error: fetchError } = await supabase
-		.from('deployments')
-		.select('id')
-		.eq('project_id', project_id)
-		.not('status', 'in', '("deployed","failed")')
-		.single();
+	const apiClient = getApiClient();
+	const response = await apiClient.cancelDeployment(project_id, reason);
 
-	if (fetchError || !deployment) {
-		return { result: { success: false, error: 'No active deployment' } };
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to cancel deployment');
 	}
 
-	const { error: updateError } = await supabase
-		.from('deployments')
-		.update({
-			status: 'failed',
-			deployment_error: `Cancelled: ${reason || 'unspecified'}`,
-			deployment_completed_at: new Date().toISOString(),
-		})
-		.eq('id', deployment.id);
-
-	if (updateError) throw updateError;
-
-	await supabase.from('progress_logs').insert({
-		project_id,
-		summary: `Deployment cancelled${reason ? `: ${reason}` : ''}`,
-		created_by: 'agent',
-		created_by_session_id: currentSessionId,
-	});
-
-	return { result: { success: true } };
+	return { result: response.data };
 };
 
 export const addDeploymentRequirement: Handler = async (args, ctx) => {
@@ -658,9 +208,6 @@ export const addDeploymentRequirement: Handler = async (args, ctx) => {
 		blocking?: boolean;
 	};
 
-	const { supabase, session } = ctx;
-	const currentSessionId = session.currentSessionId;
-
 	validateRequired(project_id, 'project_id');
 	validateUUID(project_id, 'project_id');
 	validateRequired(type, 'type');
@@ -676,95 +223,37 @@ export const addDeploymentRequirement: Handler = async (args, ctx) => {
 		throw new ValidationError(`stage must be one of: ${validStages.join(', ')}`);
 	}
 
-	const { data: requirement, error } = await supabase
-		.from('deployment_requirements')
-		.insert({
-			project_id,
-			type,
-			title,
-			description: description || null,
-			file_path: file_path || null,
-			stage,
-			blocking,
-			created_by_session_id: currentSessionId,
-		})
-		.select('id, type, title, stage, blocking')
-		.single();
-
-	if (error) throw new Error(`Failed to add requirement: ${error.message}`);
-
-	const blockingText = blocking ? ' (BLOCKING)' : '';
-	await supabase.from('progress_logs').insert({
-		project_id,
-		summary: `Added ${stage} deployment requirement${blockingText}: ${title}`,
-		details: `Type: ${type}, Stage: ${stage}${blocking ? ', Blocking: true' : ''}${file_path ? `, File: ${file_path}` : ''}`,
-		created_by: 'agent',
-		created_by_session_id: currentSessionId,
+	const apiClient = getApiClient();
+	const response = await apiClient.addDeploymentRequirement(project_id, {
+		type: type as 'migration' | 'env_var' | 'config' | 'manual' | 'breaking_change' | 'agent_task',
+		title,
+		description,
+		file_path,
+		stage: stage as 'preparation' | 'deployment' | 'verification',
+		blocking
 	});
 
-	const stageMessage = blocking
-		? 'Will block all other work when converted to task.'
-		: stage === 'deployment'
-			? 'Will run during deployment.'
-			: stage === 'verification'
-				? 'Will run after deployment for verification.'
-				: 'Will run during preparation phase.';
-
-	return {
-		result: {
-			success: true,
-			requirement_id: requirement.id,
-			stage: requirement.stage,
-			message: `Added ${type} requirement. ${stageMessage}`,
-		},
-	};
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to add deployment requirement');
+	}
+
+	return { result: response.data };
 };
 
 export const completeDeploymentRequirement: Handler = async (args, ctx) => {
 	const { requirement_id } = args as { requirement_id: string };
-	const { supabase, session } = ctx;
-	const currentSessionId = session.currentSessionId;
 
 	validateRequired(requirement_id, 'requirement_id');
 	validateUUID(requirement_id, 'requirement_id');
 
-	const { data: requirement, error: fetchError } = await supabase
-		.from('deployment_requirements')
-		.select('id, title, status')
-		.eq('id', requirement_id)
-		.single();
+	const apiClient = getApiClient();
+	const response = await apiClient.completeDeploymentRequirement(requirement_id);
 
-	if (fetchError || !requirement) {
-		throw new Error('Requirement not found');
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to complete deployment requirement');
 	}
 
-	if (requirement.status !== 'pending') {
-		return {
-			result: {
-				success: false,
-				error: `Requirement is already ${requirement.status}`,
-			},
-		};
-	}
-
-	const { error: updateError } = await supabase
-		.from('deployment_requirements')
-		.update({
-			status: 'completed',
-			completed_at: new Date().toISOString(),
-			completed_by: currentSessionId || 'agent',
-		})
-		.eq('id', requirement_id);
-
-	if (updateError) throw updateError;
-
-	return {
-		result: {
-			success: true,
-			requirement_id,
-			title: requirement.title,
-		},
-	};
+	return { result: response.data };
 };
 
 export const getDeploymentRequirements: Handler = async (args, ctx) => {
@@ -774,41 +263,20 @@ export const getDeploymentRequirements: Handler = async (args, ctx) => {
 		stage?: string;
 	};
 
-	const { supabase } = ctx;
-
 	validateRequired(project_id, 'project_id');
 	validateUUID(project_id, 'project_id');
 
-	let query = supabase
-		.from('deployment_requirements')
-		.select('id, type, title, description, file_path, status, stage, blocking, created_at, completed_at')
-		.eq('project_id', project_id)
-		.order('stage', { ascending: true })
-		.order('created_at', { ascending: false });
-
-	if (status !== 'all') {
-		query = query.eq('status', status);
-	}
+	const apiClient = getApiClient();
+	const response = await apiClient.getDeploymentRequirements(project_id, {
+		status: status as 'pending' | 'completed' | 'converted_to_task' | 'all',
+		stage: stage as 'preparation' | 'deployment' | 'verification' | 'all' | undefined
+	});
 
-	if (stage && stage !== 'all') {
-		query = query.eq('stage', stage);
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to get deployment requirements');
 	}
 
-	const { data: requirements, error } = await query;
-
-	if (error) throw new Error(`Failed to fetch requirements: ${error.message}`);
-
-	const preparationPending = requirements?.filter(r => r.status === 'pending' && r.stage === 'preparation').length || 0;
-	const deploymentPending = requirements?.filter(r => r.status === 'pending' && r.stage === 'deployment').length || 0;
-
-	return {
-		result: {
-			requirements: requirements || [],
-			preparation_pending: preparationPending,
-			deployment_pending: deploymentPending,
-			deployment_blocked: preparationPending > 0 || deploymentPending > 0,
-		},
-	};
+	return { result: response.data };
 };
 
 // ============================================================================
@@ -836,9 +304,6 @@ export const scheduleDeployment: Handler = async (args, ctx) => {
 		git_ref?: string;
 	};
 
-	const { supabase, session } = ctx;
-	const currentSessionId = session.currentSessionId;
-
 	validateRequired(project_id, 'project_id');
 	validateUUID(project_id, 'project_id');
 	validateRequired(scheduled_at, 'scheduled_at');
@@ -873,47 +338,22 @@ export const scheduleDeployment: Handler = async (args, ctx) => {
 		});
 	}
 
-	// Create scheduled deployment
-	const { data: schedule, error } = await supabase
-		.from('scheduled_deployments')
-		.insert({
-			project_id,
-			environment,
-			version_bump,
-			schedule_type,
-			scheduled_at: scheduledDate.toISOString(),
-			auto_trigger,
-			notes: notes || null,
-			git_ref: git_ref || null,
-			created_by: 'agent',
-			created_by_session_id: currentSessionId,
-		})
-		.select('id, scheduled_at, schedule_type')
-		.single();
-
-	if (error) throw new Error(`Failed to create schedule: ${error.message}`);
-
-	// Log progress
-	await supabase.from('progress_logs').insert({
-		project_id,
-		summary: `Scheduled ${schedule_type} deployment to ${environment} for ${scheduledDate.toISOString()}`,
-		details: `Auto-trigger: ${auto_trigger}, Version bump: ${version_bump}`,
-		created_by: 'agent',
-		created_by_session_id: currentSessionId,
+	const apiClient = getApiClient();
+	const response = await apiClient.scheduleDeployment(project_id, {
+		environment: environment as 'development' | 'staging' | 'production',
+		version_bump: version_bump as 'patch' | 'minor' | 'major',
+		schedule_type: schedule_type as 'once' | 'daily' | 'weekly' | 'monthly',
+		scheduled_at: scheduledDate.toISOString(),
+		auto_trigger,
+		notes,
+		git_ref
 	});
 
-	return {
-		result: {
-			success: true,
-			schedule_id: schedule.id,
-			scheduled_at: schedule.scheduled_at,
-			schedule_type: schedule.schedule_type,
-			auto_trigger,
-			message: auto_trigger
-				? 'Deployment scheduled. Will trigger automatically when time arrives.'
-				: 'Deployment scheduled. Manual trigger required from dashboard.',
-		},
-	};
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to schedule deployment');
+	}
+
+	return { result: response.data };
 };
 
 export const getScheduledDeployments: Handler = async (args, ctx) => {
@@ -922,43 +362,17 @@ export const getScheduledDeployments: Handler = async (args, ctx) => {
 		include_disabled?: boolean;
 	};
 
-	const { supabase } = ctx;
-
 	validateRequired(project_id, 'project_id');
 	validateUUID(project_id, 'project_id');
 
-	let query = supabase
-		.from('scheduled_deployments')
-		.select('*')
-		.eq('project_id', project_id)
-		.order('scheduled_at', { ascending: true });
+	const apiClient = getApiClient();
+	const response = await apiClient.getScheduledDeployments(project_id, include_disabled);
 
-	if (!include_disabled) {
-		query = query.eq('enabled', true);
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to get scheduled deployments');
 	}
 
-	const { data: schedules, error } = await query;
-
-	if (error) throw new Error(`Failed to fetch schedules: ${error.message}`);
-
-	const now = new Date();
-	const schedulesWithStatus = (schedules || []).map(s => ({
-		...s,
-		is_due: s.enabled && new Date(s.scheduled_at) <= now,
-	}));
-
-	const dueCount = schedulesWithStatus.filter(s => s.is_due && s.auto_trigger).length;
-
-	return {
-		result: {
-			schedules: schedulesWithStatus,
-			count: schedulesWithStatus.length,
-			due_count: dueCount,
-			...(dueCount > 0 && {
-				hint: 'There are due schedules. Call trigger_scheduled_deployment to execute.',
-			}),
-		},
-	};
+	return { result: response.data };
 };
 
 export const updateScheduledDeployment: Handler = async (args, ctx) => {
@@ -984,8 +398,6 @@ export const updateScheduledDeployment: Handler = async (args, ctx) => {
 		git_ref?: string;
 	};
 
-	const { supabase } = ctx;
-
 	validateRequired(schedule_id, 'schedule_id');
 	validateUUID(schedule_id, 'schedule_id');
 
@@ -1027,242 +439,75 @@ export const updateScheduledDeployment: Handler = async (args, ctx) => {
 		return { result: { success: false, error: 'No updates provided' } };
 	}
 
-	const { error } = await supabase
-		.from('scheduled_deployments')
-		.update(updates)
-		.eq('id', schedule_id);
+	const apiClient = getApiClient();
+	const response = await apiClient.updateScheduledDeployment(schedule_id, updates as {
+		environment?: 'development' | 'staging' | 'production';
+		version_bump?: 'patch' | 'minor' | 'major';
+		schedule_type?: 'once' | 'daily' | 'weekly' | 'monthly';
+		scheduled_at?: string;
+		auto_trigger?: boolean;
+		enabled?: boolean;
+		notes?: string;
+		git_ref?: string;
+	});
 
-	if (error) throw new Error(`Failed to update schedule: ${error.message}`);
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to update scheduled deployment');
+	}
 
-	return { result: { success: true, schedule_id } };
+	return { result: response.data };
 };
 
 export const deleteScheduledDeployment: Handler = async (args, ctx) => {
 	const { schedule_id } = args as { schedule_id: string };
-	const { supabase } = ctx;
 
 	validateRequired(schedule_id, 'schedule_id');
 	validateUUID(schedule_id, 'schedule_id');
 
-	const { error } = await supabase
-		.from('scheduled_deployments')
-		.delete()
-		.eq('id', schedule_id);
+	const apiClient = getApiClient();
+	const response = await apiClient.deleteScheduledDeployment(schedule_id);
 
-	if (error) throw new Error(`Failed to delete schedule: ${error.message}`);
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to delete scheduled deployment');
+	}
 
-	return { result: { success: true } };
+	return { result: response.data };
 };
 
 export const triggerScheduledDeployment: Handler = async (args, ctx) => {
 	const { schedule_id } = args as { schedule_id: string };
-	const { supabase, session } = ctx;
-	const currentSessionId = session.currentSessionId;
+	const { session } = ctx;
 
 	validateRequired(schedule_id, 'schedule_id');
 	validateUUID(schedule_id, 'schedule_id');
 
-	// Get the schedule
-	const { data: schedule, error: fetchError } = await supabase
-		.from('scheduled_deployments')
-		.select('*')
-		.eq('id', schedule_id)
-		.single();
-
-	if (fetchError || !schedule) {
-		return { result: { success: false, error: 'Schedule not found' } };
-	}
-
-	if (!schedule.enabled) {
-		return { result: { success: false, error: 'Schedule is disabled' } };
-	}
-
-	// Check for existing active deployment
-	const { data: existingDeployment } = await supabase
-		.from('deployments')
-		.select('id, status')
-		.eq('project_id', schedule.project_id)
-		.not('status', 'in', '("deployed","failed")')
-		.single();
-
-	if (existingDeployment) {
-		return {
-			result: {
-				success: false,
-				error: 'A deployment is already in progress',
-				existing_deployment_id: existingDeployment.id,
-				hint: 'Wait for current deployment to complete or cancel it first',
-			},
-		};
-	}
-
-	// Create the deployment (similar to request_deployment)
-	const { data: deployment, error: deployError } = await supabase
-		.from('deployments')
-		.insert({
-			project_id: schedule.project_id,
-			environment: schedule.environment,
-			version_bump: schedule.version_bump,
-			notes: schedule.notes,
-			git_ref: schedule.git_ref,
-			requested_by: 'agent',
-			requesting_agent_session_id: currentSessionId,
-		})
-		.select('id, status')
-		.single();
-
-	if (deployError) throw new Error(`Failed to create deployment: ${deployError.message}`);
-
-	// Auto-convert pending deployment requirements to tasks
-	const { data: pendingRequirements } = await supabase
-		.from('deployment_requirements')
-		.select('id, type, title, description, stage, blocking')
-		.eq('project_id', schedule.project_id)
-		.eq('status', 'pending')
-		.is('converted_task_id', null);
-
-	const convertedTasks: Array<{ task_id: string; requirement_id: string; title: string }> = [];
-
-	if (pendingRequirements && pendingRequirements.length > 0) {
-		for (const req of pendingRequirements) {
-			const isDeployStage = req.stage === 'deployment';
-			const isBlocking = req.blocking ?? isDeployStage;
-			const titlePrefix = isBlocking
-				? 'DEPLOY:'
-				: isDeployStage
-					? 'DEPLOY:'
-					: req.stage === 'verification'
-						? 'VERIFY:'
-						: 'PREP:';
-
-			// Create linked task
-			const { data: newTask } = await supabase
-				.from('tasks')
-				.insert({
-					project_id: schedule.project_id,
-					title: `${titlePrefix} ${req.title}`,
-					description: `[${req.type}] ${req.description || req.title}`,
-					priority: 1,
-					status: 'pending',
-					blocking: isBlocking,
-					created_by: 'agent',
-					created_by_session_id: currentSessionId,
-				})
-				.select('id')
-				.single();
-
-			if (newTask) {
-				// Link task to requirement WITHOUT changing status
-				// This keeps the requirement visible in the deployment steps list (permanent)
-				await supabase
-					.from('deployment_requirements')
-					.update({
-						converted_task_id: newTask.id,
-					})
-					.eq('id', req.id);
-
-				convertedTasks.push({
-					task_id: newTask.id,
-					requirement_id: req.id,
-					title: `${titlePrefix} ${req.title}`,
-				});
-			}
-		}
-	}
-
-	// Update the schedule
-	const scheduleUpdates: Record<string, unknown> = {
-		last_triggered_at: new Date().toISOString(),
-		last_deployment_id: deployment.id,
-		trigger_count: schedule.trigger_count + 1,
-	};
-
-	// For recurring schedules, calculate next run time
-	if (schedule.schedule_type !== 'once') {
-		const currentScheduledAt = new Date(schedule.scheduled_at);
-		let nextScheduledAt: Date;
-
-		switch (schedule.schedule_type) {
-			case 'daily':
-				nextScheduledAt = new Date(currentScheduledAt.getTime() + 24 * 60 * 60 * 1000);
-				break;
-			case 'weekly':
-				nextScheduledAt = new Date(currentScheduledAt.getTime() + 7 * 24 * 60 * 60 * 1000);
-				break;
-			case 'monthly':
-				nextScheduledAt = new Date(currentScheduledAt.getTime() + 30 * 24 * 60 * 60 * 1000);
-				break;
-			default:
-				nextScheduledAt = currentScheduledAt;
-		}
+	const apiClient = getApiClient();
+	const response = await apiClient.triggerScheduledDeployment(
+		schedule_id,
+		session.currentSessionId || undefined
+	);
 
-		scheduleUpdates.scheduled_at = nextScheduledAt.toISOString();
-	} else {
-		// One-time schedule, disable it
-		scheduleUpdates.enabled = false;
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to trigger scheduled deployment');
 	}
 
-	await supabase
-		.from('scheduled_deployments')
-		.update(scheduleUpdates)
-		.eq('id', schedule_id);
-
-	// Log progress
-	const convertedMsg = convertedTasks.length > 0
-		? `, ${convertedTasks.length} requirements converted to tasks`
-		: '';
-	await supabase.from('progress_logs').insert({
-		project_id: schedule.project_id,
-		summary: `Triggered scheduled deployment to ${schedule.environment}${convertedMsg}`,
-		details: `Schedule: ${schedule.schedule_type}, Trigger #${schedule.trigger_count + 1}`,
-		created_by: 'agent',
-		created_by_session_id: currentSessionId,
-	});
-
-	return {
-		result: {
-			success: true,
-			deployment_id: deployment.id,
-			schedule_id,
-			schedule_type: schedule.schedule_type,
-			next_scheduled_at: schedule.schedule_type !== 'once' ? scheduleUpdates.scheduled_at : null,
-			converted_requirements: convertedTasks.length,
-			converted_tasks: convertedTasks.length > 0 ? convertedTasks : undefined,
-			message: convertedTasks.length > 0
-				? `Deployment created from schedule. ${convertedTasks.length} requirements converted to tasks. Run validation then deploy.`
-				: 'Deployment created from schedule. Run validation then deploy.',
-		},
-	};
+	return { result: response.data };
 };
 
 export const checkDueDeployments: Handler = async (args, ctx) => {
 	const { project_id } = args as { project_id: string };
-	const { supabase } = ctx;
 
 	validateRequired(project_id, 'project_id');
 	validateUUID(project_id, 'project_id');
 
-	// Find schedules that are due (enabled, auto_trigger, and scheduled_at <= now)
-	const { data: dueSchedules, error } = await supabase
-		.from('scheduled_deployments')
-		.select('id, environment, version_bump, schedule_type, scheduled_at')
-		.eq('project_id', project_id)
-		.eq('enabled', true)
-		.eq('auto_trigger', true)
-		.lte('scheduled_at', new Date().toISOString())
-		.order('scheduled_at', { ascending: true });
-
-	if (error) throw new Error(`Failed to check schedules: ${error.message}`);
-
-	return {
-		result: {
-			due_schedules: dueSchedules || [],
-			count: dueSchedules?.length || 0,
-			...(dueSchedules && dueSchedules.length > 0 && {
-				hint: `Call trigger_scheduled_deployment(schedule_id: "${dueSchedules[0].id}") to trigger the first due deployment`,
-			}),
-		},
-	};
+	const apiClient = getApiClient();
+	const response = await apiClient.checkDueDeployments(project_id);
+
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to check due deployments');
+	}
+
+	return { result: response.data };
 };
 
 /**