@vibescope/mcp-server 0.0.1 → 0.1.0

package/dist/handlers/deployment.js

@@ -14,10 +14,10 @@
  * - get_deployment_requirements
  */
 import { ValidationError, validateRequired, validateUUID, validateEnvironment, } from '../validators.js';
+import { getApiClient } from '../api-client.js';
 export const requestDeployment = async (args, ctx) => {
     const { project_id, environment = 'production', version_bump = 'patch', notes, git_ref } = args;
-    const { supabase, session } = ctx;
-    const currentSessionId = session.currentSessionId;
+    const { session } = ctx;
     validateRequired(project_id, 'project_id');
     validateUUID(project_id, 'project_id');
     validateEnvironment(environment);
@@ -28,204 +28,33 @@ export const requestDeployment = async (args, ctx) => {
             hint: 'Must be one of: patch, minor, major',
         });
     }
-    // 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: "...")`,
-            },
-        };
-    }
-    // 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,
+    const apiClient = getApiClient();
+    const response = await apiClient.requestDeployment(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 = [];
-    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}`,
-                });
-            }
-        }
-    }
-    // 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,
+        git_ref
     });
-    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.',
-        },
-    };
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to request deployment');
+    }
+    return { result: response.data };
 };
 export const claimDeploymentValidation = async (args, ctx) => {
     const { project_id } = args;
-    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);
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to claim deployment validation');
     }
-    // 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',
-            },
-        };
-    }
-    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 = async (args, ctx) => {
     const { project_id, build_passed, tests_passed, error_message } = args;
-    const { supabase, session } = ctx;
-    const currentSessionId = session.currentSessionId;
+    const { session } = ctx;
     validateRequired(project_id, 'project_id');
     validateUUID(project_id, 'project_id');
     if (build_passed === undefined) {
@@ -234,211 +63,43 @@ export const reportValidation = async (args, ctx) => {
             hint: 'Set to true if the build succeeded, false otherwise',
         });
     }
-    // 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,
+    const apiClient = getApiClient();
+    const response = await apiClient.reportValidation(project_id, {
         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,
+        tests_passed: tests_passed ?? true,
+        error_message
     });
-    // Auto-create task for failed validation
-    let createdTaskId = 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 = async (args, ctx) => {
     const { project_id } = args;
-    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 = {
-        pending: 30 * 60 * 1000,
-        validating: 15 * 60 * 1000,
-        ready: 30 * 60 * 1000,
-        deploying: 10 * 60 * 1000,
-    };
-    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;
-            }
-        }
+    const apiClient = getApiClient();
+    const response = await apiClient.checkDeploymentStatus(project_id);
+    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 = async (args, ctx) => {
     const { project_id } = args;
-    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 apiClient = getApiClient();
+    const response = await apiClient.startDeployment(project_id, session.currentSessionId || undefined);
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to start deployment');
     }
-    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({
-        project_id,
-        summary: `Deployment to ${deployment.environment} started`,
-        created_by: 'agent',
-        created_by_session_id: currentSessionId,
-    });
-    const result = {
-        success: true,
-        status: 'deploying',
-        env: deployment.environment,
-    };
-    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`;
-    }
-    return { result };
+    return { result: response.data };
 };
 export const completeDeployment = async (args, ctx) => {
     const { project_id, success, summary } = args;
-    const { supabase, session } = ctx;
-    const currentSessionId = session.currentSessionId;
+    const { session } = ctx;
     validateRequired(project_id, 'project_id');
     validateUUID(project_id, 'project_id');
     if (success === undefined) {
@@ -447,117 +108,29 @@ export const completeDeployment = async (args, ctx) => {
             hint: 'Set to true if deployment succeeded, false otherwise',
         });
     }
-    // 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 = 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) => 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}`;
-        await supabase
-            .from('projects')
-            .update({ current_version: newVersion })
-            .eq('id', project_id);
-    }
-    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,
+    const apiClient = getApiClient();
+    const response = await apiClient.completeDeployment(project_id, {
+        success,
+        summary
     });
-    return {
-        result: {
-            success: true,
-            status: newStatus,
-            ...(newVersion && { version: newVersion }),
-        },
-    };
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to complete deployment');
+    }
+    return { result: response.data };
 };
 export const cancelDeployment = async (args, ctx) => {
     const { project_id, reason } = args;
-    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();
-    if (fetchError || !deployment) {
-        return { result: { success: false, error: 'No active deployment' } };
+    const apiClient = getApiClient();
+    const response = await apiClient.cancelDeployment(project_id, reason);
+    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 = async (args, ctx) => {
     const { project_id, type, title, description, file_path, stage = 'preparation', blocking = false } = args;
-    const { supabase, session } = ctx;
-    const currentSessionId = session.currentSessionId;
     validateRequired(project_id, 'project_id');
     validateUUID(project_id, 'project_id');
     validateRequired(type, 'type');
@@ -570,124 +143,50 @@ export const addDeploymentRequirement = async (args, ctx) => {
     if (!validStages.includes(stage)) {
         throw new ValidationError(`stage must be one of: ${validStages.join(', ')}`);
     }
-    const { data: requirement, error } = await supabase
-        .from('deployment_requirements')
-        .insert({
-        project_id,
-        type,
+    const apiClient = getApiClient();
+    const response = await apiClient.addDeploymentRequirement(project_id, {
+        type: 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,
+        description,
+        file_path,
+        stage: stage,
+        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 = async (args, ctx) => {
     const { requirement_id } = args;
-    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();
-    if (fetchError || !requirement) {
-        throw new Error('Requirement not found');
+    const apiClient = getApiClient();
+    const response = await apiClient.completeDeploymentRequirement(requirement_id);
+    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 = async (args, ctx) => {
     const { project_id, status = 'pending', stage } = args;
-    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);
-    }
-    if (stage && stage !== 'all') {
-        query = query.eq('stage', stage);
+    const apiClient = getApiClient();
+    const response = await apiClient.getDeploymentRequirements(project_id, {
+        status: status,
+        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 };
 };
 // ============================================================================
 // Scheduled Deployments
 // ============================================================================
 export const scheduleDeployment = async (args, ctx) => {
     const { project_id, environment = 'production', version_bump = 'patch', schedule_type = 'once', scheduled_at, auto_trigger = true, notes, git_ref, } = args;
-    const { supabase, session } = ctx;
-    const currentSessionId = session.currentSessionId;
     validateRequired(project_id, 'project_id');
     validateUUID(project_id, 'project_id');
     validateRequired(scheduled_at, 'scheduled_at');
@@ -717,82 +216,34 @@ export const scheduleDeployment = async (args, ctx) => {
             field: 'scheduled_at',
         });
     }
-    // Create scheduled deployment
-    const { data: schedule, error } = await supabase
-        .from('scheduled_deployments')
-        .insert({
-        project_id,
-        environment,
-        version_bump,
-        schedule_type,
+    const apiClient = getApiClient();
+    const response = await apiClient.scheduleDeployment(project_id, {
+        environment: environment,
+        version_bump: version_bump,
+        schedule_type: 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,
+        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 = async (args, ctx) => {
     const { project_id, include_disabled = false } = args;
-    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 });
-    if (!include_disabled) {
-        query = query.eq('enabled', true);
+    const apiClient = getApiClient();
+    const response = await apiClient.getScheduledDeployments(project_id, include_disabled);
+    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 = async (args, ctx) => {
     const { schedule_id, environment, version_bump, schedule_type, scheduled_at, auto_trigger, enabled, notes, git_ref, } = args;
-    const { supabase } = ctx;
     validateRequired(schedule_id, 'schedule_id');
     validateUUID(schedule_id, 'schedule_id');
     const updates = {};
@@ -830,213 +281,46 @@ export const updateScheduledDeployment = async (args, ctx) => {
     if (Object.keys(updates).length === 0) {
         return { result: { success: false, error: 'No updates provided' } };
     }
-    const { error } = await supabase
-        .from('scheduled_deployments')
-        .update(updates)
-        .eq('id', schedule_id);
-    if (error)
-        throw new Error(`Failed to update schedule: ${error.message}`);
-    return { result: { success: true, schedule_id } };
+    const apiClient = getApiClient();
+    const response = await apiClient.updateScheduledDeployment(schedule_id, updates);
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to update scheduled deployment');
+    }
+    return { result: response.data };
 };
 export const deleteScheduledDeployment = async (args, ctx) => {
     const { schedule_id } = args;
-    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);
-    if (error)
-        throw new Error(`Failed to delete schedule: ${error.message}`);
-    return { result: { success: true } };
+    const apiClient = getApiClient();
+    const response = await apiClient.deleteScheduledDeployment(schedule_id);
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to delete scheduled deployment');
+    }
+    return { result: response.data };
 };
 export const triggerScheduledDeployment = async (args, ctx) => {
     const { schedule_id } = args;
-    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' } };
+    const apiClient = getApiClient();
+    const response = await apiClient.triggerScheduledDeployment(schedule_id, session.currentSessionId || undefined);
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to trigger scheduled deployment');
     }
-    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 = [];
-    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 = {
-        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;
-        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;
-        }
-        scheduleUpdates.scheduled_at = nextScheduledAt.toISOString();
-    }
-    else {
-        // One-time schedule, disable it
-        scheduleUpdates.enabled = false;
-    }
-    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 = async (args, ctx) => {
     const { project_id } = args;
-    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 };
 };
 /**
  * Deployment handlers registry