@vibescope/mcp-server 0.0.1

package/dist/handlers/roles.js

@@ -0,0 +1,281 @@
+/**
+ * Role Handlers
+ *
+ * Manages agent roles for specialized work:
+ * - get_role_settings: Get role configuration for a project
+ * - update_role_settings: Update role settings
+ * - set_session_role: Change the current session's role
+ * - get_agents_by_role: Get active agents grouped by role
+ */
+import { validateUUID, validateRequired } from '../validators.js';
+// Valid agent roles - must match AgentRole type in types.ts and database enum
+const VALID_ROLES = ['developer', 'validator', 'deployer', 'reviewer', 'maintainer'];
+function isValidRole(role) {
+    return VALID_ROLES.includes(role);
+}
+/**
+ * Verify the user owns or has access to the project
+ * This is needed because MCP server uses service_role which bypasses RLS
+ */
+async function verifyProjectAccess(ctx, projectId) {
+    const { supabase, auth } = ctx;
+    // Check if user owns the project
+    const { data: ownedProject } = await supabase
+        .from('projects')
+        .select('id')
+        .eq('id', projectId)
+        .eq('user_id', auth.userId)
+        .single();
+    if (ownedProject)
+        return;
+    // Check if project is shared with user's organization (for org-scoped keys)
+    if (auth.scope === 'organization' && auth.organizationId) {
+        const { data: sharedProject } = await supabase
+            .from('project_shares')
+            .select('project_id')
+            .eq('project_id', projectId)
+            .eq('organization_id', auth.organizationId)
+            .single();
+        if (sharedProject)
+            return;
+    }
+    throw new Error('Project not found or access denied');
+}
+/**
+ * Get role settings for a project
+ */
+export const getRoleSettings = async (args, ctx) => {
+    const { project_id } = args;
+    const { supabase } = ctx;
+    validateRequired(project_id, 'project_id');
+    validateUUID(project_id, 'project_id');
+    // Verify user has access to this project
+    await verifyProjectAccess(ctx, project_id);
+    const { data: settings, error } = await supabase
+        .from('project_role_settings')
+        .select('*')
+        .eq('project_id', project_id)
+        .order('role');
+    if (error) {
+        throw new Error(`Failed to get role settings: ${error.message}`);
+    }
+    // If no settings exist, return defaults
+    if (!settings || settings.length === 0) {
+        return {
+            result: {
+                project_id,
+                settings: VALID_ROLES.map(role => ({
+                    role,
+                    enabled: true,
+                    display_name: role.charAt(0).toUpperCase() + role.slice(1),
+                    description: getRoleDescription(role),
+                })),
+                note: 'Using default settings. Call update_role_settings to customize.',
+            },
+        };
+    }
+    return {
+        result: {
+            project_id,
+            settings,
+        },
+    };
+};
+function getRoleDescription(role) {
+    const descriptions = {
+        developer: 'General development work, picks up any available task',
+        validator: 'Focuses on validating completed tasks',
+        deployer: 'Handles deployment coordination and monitoring',
+        reviewer: 'Code review and quality checks',
+        maintainer: 'Task management, git orchestration, housekeeping',
+    };
+    return descriptions[role];
+}
+/**
+ * Update role settings for a project
+ */
+export const updateRoleSettings = async (args, ctx) => {
+    const { project_id, role, enabled, display_name, description, priority_filter, fallback_activities, auto_assign_validation, auto_assign_deployment, } = args;
+    const { supabase } = ctx;
+    validateRequired(project_id, 'project_id');
+    validateUUID(project_id, 'project_id');
+    validateRequired(role, 'role');
+    if (!isValidRole(role)) {
+        throw new Error(`Invalid role: ${role}. Valid roles: ${VALID_ROLES.join(', ')}`);
+    }
+    // Verify user has access to this project
+    await verifyProjectAccess(ctx, project_id);
+    const updates = {
+        updated_at: new Date().toISOString(),
+    };
+    if (enabled !== undefined)
+        updates.enabled = enabled;
+    if (display_name !== undefined)
+        updates.display_name = display_name;
+    if (description !== undefined)
+        updates.description = description;
+    if (priority_filter !== undefined)
+        updates.priority_filter = priority_filter;
+    if (fallback_activities !== undefined)
+        updates.fallback_activities = fallback_activities;
+    if (auto_assign_validation !== undefined)
+        updates.auto_assign_validation = auto_assign_validation;
+    if (auto_assign_deployment !== undefined)
+        updates.auto_assign_deployment = auto_assign_deployment;
+    // Upsert the role settings
+    const { data, error } = await supabase
+        .from('project_role_settings')
+        .upsert({
+        project_id,
+        role,
+        ...updates,
+    }, {
+        onConflict: 'project_id,role',
+    })
+        .select()
+        .single();
+    if (error) {
+        throw new Error(`Failed to update role settings: ${error.message}`);
+    }
+    return {
+        result: {
+            success: true,
+            settings: data,
+        },
+    };
+};
+/**
+ * Set the current session's role
+ */
+export const setSessionRole = async (args, ctx) => {
+    const { role, role_config } = args;
+    const { supabase, session, updateSession } = ctx;
+    validateRequired(role, 'role');
+    if (!isValidRole(role)) {
+        throw new Error(`Invalid role: ${role}. Valid roles: ${VALID_ROLES.join(', ')}`);
+    }
+    const sessionId = session.currentSessionId;
+    if (!sessionId) {
+        throw new Error('No active session. Call start_work_session first.');
+    }
+    const updates = {
+        role,
+        updated_at: new Date().toISOString(),
+    };
+    // Allow role_config for custom configurations (e.g., maintainer with specific focus areas)
+    if (role_config) {
+        updates.role_config = role_config;
+    }
+    const { error } = await supabase
+        .from('agent_sessions')
+        .update(updates)
+        .eq('id', sessionId);
+    if (error) {
+        throw new Error(`Failed to set role: ${error.message}`);
+    }
+    // Update session state
+    updateSession({ currentRole: role });
+    // Get role-specific guidance
+    const guidance = getRoleGuidance(role);
+    return {
+        result: {
+            success: true,
+            role,
+            persona: session.currentPersona,
+            guidance,
+        },
+    };
+};
+function getRoleGuidance(role) {
+    const guidance = {
+        developer: 'Focus on implementing features and fixing bugs. Use get_next_task to find work.',
+        validator: 'Prioritize validation tasks. Use get_tasks_awaiting_validation to find completed tasks to review.',
+        deployer: 'Monitor deployment status with check_deployment_status. Handle deployment requests and coordination.',
+        reviewer: 'Run code reviews using code_review fallback activity. Check for security and quality issues.',
+        maintainer: 'Handle task management, git orchestration. Run performance_audit, dependency_audit when idle.',
+    };
+    return guidance[role];
+}
+/**
+ * Get active agents grouped by role
+ */
+export const getAgentsByRole = async (args, ctx) => {
+    const { project_id } = args;
+    const { supabase } = ctx;
+    validateRequired(project_id, 'project_id');
+    validateUUID(project_id, 'project_id');
+    // Verify user has access to this project
+    await verifyProjectAccess(ctx, project_id);
+    const { data: agents, error } = await supabase
+        .from('agent_sessions')
+        .select(`
+			id,
+			agent_name,
+			role,
+			status,
+			current_task_id,
+			last_synced_at,
+			role_config
+		`)
+        .eq('project_id', project_id)
+        .neq('status', 'disconnected')
+        .gte('last_synced_at', new Date(Date.now() - 5 * 60 * 1000).toISOString());
+    if (error) {
+        throw new Error(`Failed to get agents: ${error.message}`);
+    }
+    // Group by role
+    const byRole = {};
+    for (const agent of agents || []) {
+        const role = agent.role || 'developer';
+        if (!byRole[role]) {
+            byRole[role] = [];
+        }
+        byRole[role].push(agent);
+    }
+    // Get current task titles
+    const taskIds = (agents || [])
+        .map(a => a.current_task_id)
+        .filter((id) => !!id);
+    let taskTitles = {};
+    if (taskIds.length > 0) {
+        const { data: tasks } = await supabase
+            .from('tasks')
+            .select('id, title')
+            .in('id', taskIds);
+        taskTitles = (tasks || []).reduce((acc, t) => {
+            acc[t.id] = t.title;
+            return acc;
+        }, {});
+    }
+    // Enrich agents with task titles
+    const enrichedByRole = {};
+    for (const [role, roleAgents] of Object.entries(byRole)) {
+        enrichedByRole[role] = roleAgents.map(agent => ({
+            id: agent.id,
+            agent_name: agent.agent_name,
+            role: agent.role || 'developer',
+            status: agent.status,
+            current_task: agent.current_task_id
+                ? { id: agent.current_task_id, title: taskTitles[agent.current_task_id] || 'Unknown' }
+                : null,
+            last_synced_at: agent.last_synced_at,
+        }));
+    }
+    return {
+        result: {
+            project_id,
+            total_agents: agents?.length || 0,
+            by_role: enrichedByRole,
+            available_roles: VALID_ROLES,
+        },
+    };
+};
+/**
+ * Role handlers registry
+ */
+export const roleHandlers = {
+    get_role_settings: getRoleSettings,
+    update_role_settings: updateRoleSettings,
+    set_session_role: setSessionRole,
+    get_agents_by_role: getAgentsByRole,
+};

package/dist/handlers/session.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Session Handlers
+ *
+ * Handles agent session lifecycle:
+ * - start_work_session
+ * - heartbeat
+ * - end_work_session
+ * - get_help
+ * - get_token_usage
+ */
+import type { Handler, HandlerRegistry } from './types.js';
+export declare const startWorkSession: Handler;
+export declare const heartbeat: Handler;
+export declare const endWorkSession: Handler;
+export declare const getHelp: Handler;
+export declare const getTokenUsage: Handler;
+/**
+ * Session handlers registry
+ */
+export declare const sessionHandlers: HandlerRegistry;