@fruition/fcp-mcp-server 1.0.0 → 1.1.0

package/dist/index.js

@@ -13,6 +13,8 @@ import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSche
 // Configuration
 const FCP_API_URL = process.env.FCP_API_URL || 'https://fcp.fru.io';
 const FCP_API_TOKEN = process.env.FCP_API_TOKEN || '';
+const UNROO_API_URL = process.env.UNROO_API_URL || 'https://frugpt.fruition.net';
+const UNROO_API_KEY = process.env.UNROO_API_KEY || '';
 // API Client
 class FCPClient {
     baseUrl;
@@ -79,6 +81,205 @@ class FCPClient {
         });
     }
 }
+// Unroo API Client
+class UnrooClient {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async fetch(path, options = {}) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            'Content-Type': 'application/json',
+            'X-API-Key': this.apiKey,
+            ...(options.headers || {}),
+        };
+        const response = await fetch(url, {
+            ...options,
+            headers,
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Unroo API error (${response.status}): ${error}`);
+        }
+        return response.json();
+    }
+    async listProjects() {
+        return this.fetch('/api/external/fcp/projects');
+    }
+    async listTasks(filters) {
+        const params = new URLSearchParams();
+        if (filters.project_key)
+            params.set('project_key', filters.project_key);
+        if (filters.status)
+            params.set('status', filters.status);
+        if (filters.assignee_email)
+            params.set('assignee_email', filters.assignee_email);
+        if (filters.external_source_type)
+            params.set('external_source_type', filters.external_source_type);
+        if (filters.limit)
+            params.set('limit', filters.limit.toString());
+        const query = params.toString();
+        return this.fetch(`/api/external/fcp/tasks${query ? `?${query}` : ''}`);
+    }
+    async createTask(task) {
+        return this.fetch('/api/external/fcp/tasks', {
+            method: 'POST',
+            body: JSON.stringify(task),
+        });
+    }
+    async getTask(taskId) {
+        return this.fetch(`/api/external/fcp/tasks/${encodeURIComponent(taskId)}`);
+    }
+    async updateTask(taskId, updates) {
+        return this.fetch(`/api/external/fcp/tasks/${encodeURIComponent(taskId)}`, {
+            method: 'PUT',
+            body: JSON.stringify(updates),
+        });
+    }
+    async startSession(input) {
+        return this.fetch('/api/external/fcp/sessions', {
+            method: 'POST',
+            body: JSON.stringify({ action: 'start', ...input }),
+        });
+    }
+    async endSession() {
+        return this.fetch('/api/external/fcp/sessions', {
+            method: 'POST',
+            body: JSON.stringify({ action: 'end' }),
+        });
+    }
+    async sessionHeartbeat(input) {
+        return this.fetch('/api/external/fcp/sessions', {
+            method: 'POST',
+            body: JSON.stringify({ action: 'heartbeat', ...input }),
+        });
+    }
+}
+// ============================================================================
+// Auto Session Tracking
+// ============================================================================
+class SessionTracker {
+    unrooClient;
+    toolCallCount = 0;
+    sessionActive = false;
+    lastHeartbeat = null;
+    activities = [];
+    heartbeatInterval = null;
+    currentTaskId = null;
+    constructor(unrooClient) {
+        this.unrooClient = unrooClient;
+    }
+    /**
+     * Track a tool call - auto-starts session if needed
+     */
+    async trackToolCall(toolName, description) {
+        this.toolCallCount++;
+        this.activities.push({
+            timestamp: new Date().toISOString(),
+            tool: toolName,
+            description: description || toolName,
+        });
+        // Keep last 50 activities
+        if (this.activities.length > 50) {
+            this.activities = this.activities.slice(-50);
+        }
+        // Auto-start session on first tool call
+        if (!this.sessionActive && UNROO_API_KEY) {
+            await this.startSession();
+        }
+        // Send heartbeat every 30 tool calls or every 5 minutes
+        const shouldHeartbeat = this.toolCallCount % 30 === 0 ||
+            (this.lastHeartbeat && Date.now() - this.lastHeartbeat.getTime() > 5 * 60 * 1000);
+        if (shouldHeartbeat && this.sessionActive) {
+            await this.sendHeartbeat();
+        }
+    }
+    /**
+     * Set the current task being worked on
+     */
+    setCurrentTask(taskId) {
+        this.currentTaskId = taskId;
+    }
+    /**
+     * Start a new session
+     */
+    async startSession() {
+        if (!UNROO_API_KEY) {
+            return;
+        }
+        try {
+            await this.unrooClient.startSession({
+                task_id: this.currentTaskId || undefined,
+                source: 'claude-code-mcp',
+                machine_id: process.env.HOSTNAME || 'unknown',
+            });
+            this.sessionActive = true;
+            this.lastHeartbeat = new Date();
+            // Set up periodic heartbeat (every 5 minutes)
+            this.heartbeatInterval = setInterval(() => {
+                this.sendHeartbeat().catch(() => { });
+            }, 5 * 60 * 1000);
+            console.error('[SessionTracker] Session started');
+        }
+        catch (error) {
+            console.error('[SessionTracker] Failed to start session:', error);
+        }
+    }
+    /**
+     * Send a heartbeat to keep session alive
+     */
+    async sendHeartbeat() {
+        if (!this.sessionActive || !UNROO_API_KEY) {
+            return;
+        }
+        try {
+            await this.unrooClient.sessionHeartbeat({
+                tool_calls_delta: this.toolCallCount,
+                activity: this.activities.slice(-10), // Send last 10 activities
+            });
+            this.lastHeartbeat = new Date();
+            this.toolCallCount = 0;
+            console.error('[SessionTracker] Heartbeat sent');
+        }
+        catch (error) {
+            console.error('[SessionTracker] Failed to send heartbeat:', error);
+        }
+    }
+    /**
+     * End the current session
+     */
+    async endSession() {
+        if (!this.sessionActive || !UNROO_API_KEY) {
+            return;
+        }
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+        try {
+            await this.unrooClient.endSession();
+            this.sessionActive = false;
+            console.error('[SessionTracker] Session ended');
+        }
+        catch (error) {
+            console.error('[SessionTracker] Failed to end session:', error);
+        }
+    }
+    /**
+     * Get session stats
+     */
+    getStats() {
+        return {
+            active: this.sessionActive,
+            toolCalls: this.toolCallCount,
+            lastHeartbeat: this.lastHeartbeat?.toISOString() || null,
+        };
+    }
+}
+// Session tracker instance created after clients below
 // Create server
 const server = new Server({
     name: 'fcp-mcp-server',
@@ -90,6 +291,8 @@ const server = new Server({
     },
 });
 const client = new FCPClient(FCP_API_URL, FCP_API_TOKEN);
+const unrooClient = new UnrooClient(UNROO_API_URL, UNROO_API_KEY);
+const sessionTracker = new SessionTracker(unrooClient);
 // Tool definitions
 const TOOLS = [
     {
@@ -226,6 +429,216 @@ const TOOLS = [
             required: ['launch_id'],
         },
     },
+    // Unroo Task Management Tools
+    {
+        name: 'unroo_list_projects',
+        description: 'List all Unroo projects mapped to FCP clients. Returns project mappings with organization and JIRA key info.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'unroo_list_tasks',
+        description: 'List tasks from Unroo with optional filters. Use to find tasks for a project, by status, or by assignee.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_key: {
+                    type: 'string',
+                    description: 'Filter by JIRA project key or FCP-SITE-{id}',
+                },
+                status: {
+                    type: 'string',
+                    description: 'Filter by status: To Do, In Progress, Done, Blocked (comma-separated for multiple)',
+                },
+                assignee_email: {
+                    type: 'string',
+                    description: 'Filter by assignee email',
+                },
+                external_source_type: {
+                    type: 'string',
+                    description: 'Filter by source: fcp, fcp_checklist, fcp_launch',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of tasks to return (default 100)',
+                },
+            },
+        },
+    },
+    {
+        name: 'unroo_create_task',
+        description: 'Create a new task in Unroo. Requires title and project_key. Use for follow-up tasks, discovered issues, or new work items.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: {
+                    type: 'string',
+                    description: 'Task title (required)',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Detailed description of the task',
+                },
+                project_key: {
+                    type: 'string',
+                    description: 'JIRA project key or FCP-SITE-{id} (required)',
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['urgent', 'high', 'medium', 'low'],
+                    description: 'Task priority (default: medium)',
+                },
+                status: {
+                    type: 'string',
+                    description: 'Initial status (default: To Do)',
+                },
+                assignee_email: {
+                    type: 'string',
+                    description: 'Email of person to assign the task to',
+                },
+                due_date: {
+                    type: 'string',
+                    description: 'Due date in ISO format',
+                },
+                hours_estimated: {
+                    type: 'number',
+                    description: 'Estimated hours to complete',
+                },
+                labels: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Labels/tags for the task',
+                },
+                parent_issue_id: {
+                    type: 'string',
+                    description: 'Parent task ID if this is a subtask',
+                },
+            },
+            required: ['title', 'project_key'],
+        },
+    },
+    {
+        name: 'unroo_update_task',
+        description: 'Update an existing task in Unroo. Use to change status, log hours, update priority, or reassign.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                task_id: {
+                    type: 'string',
+                    description: 'The ID of the task to update (required)',
+                },
+                title: {
+                    type: 'string',
+                    description: 'Updated title',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Updated description',
+                },
+                status: {
+                    type: 'string',
+                    description: 'New status: To Do, In Progress, Done, Blocked',
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['urgent', 'high', 'medium', 'low'],
+                    description: 'Updated priority',
+                },
+                assignee_email: {
+                    type: 'string',
+                    description: 'New assignee email (null to unassign)',
+                },
+                hours_logged: {
+                    type: 'number',
+                    description: 'Total hours logged on the task',
+                },
+                resolution: {
+                    type: 'string',
+                    description: 'Resolution when marking as Done',
+                },
+            },
+            required: ['task_id'],
+        },
+    },
+    {
+        name: 'unroo_get_my_tasks',
+        description: 'Get tasks assigned to the current user (based on API key). Useful for finding your work items.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: {
+                    type: 'string',
+                    description: 'Filter by status (comma-separated for multiple)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of tasks to return',
+                },
+            },
+        },
+    },
+    {
+        name: 'unroo_start_session',
+        description: 'Start a work session for tracking time and activity. Call this when beginning work on a task.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                task_id: {
+                    type: 'string',
+                    description: 'The task you are working on',
+                },
+                task_jira_key: {
+                    type: 'string',
+                    description: 'JIRA issue key if applicable',
+                },
+                project_key: {
+                    type: 'string',
+                    description: 'Project being worked on',
+                },
+                repo_name: {
+                    type: 'string',
+                    description: 'Repository name if working on code',
+                },
+            },
+        },
+    },
+    {
+        name: 'unroo_end_session',
+        description: 'End the current work session and log time. Call this when finishing work.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'unroo_create_follow_up',
+        description: 'Create a follow-up task linked to a parent task. Use for discovered issues, tech debt, or next steps.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                parent_task_id: {
+                    type: 'string',
+                    description: 'The parent task this follows up on (required)',
+                },
+                title: {
+                    type: 'string',
+                    description: 'Follow-up task title (required)',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Description of the follow-up work',
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['urgent', 'high', 'medium', 'low'],
+                    description: 'Priority (default: same as parent or medium)',
+                },
+            },
+            required: ['parent_task_id', 'title'],
+        },
+    },
 ];
 // Register tool handlers
 server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -233,6 +646,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 });
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
+    // Track tool call for session management
+    await sessionTracker.trackToolCall(name, `Called ${name}`);
     try {
         switch (name) {
             case 'fcp_list_launches': {
@@ -360,6 +775,160 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
+            // Unroo Task Management Handlers
+            case 'unroo_list_projects': {
+                const result = await unrooClient.listProjects();
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'unroo_list_tasks': {
+                const filters = args;
+                const result = await unrooClient.listTasks(filters);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                total: result.summary?.total || result.tasks.length,
+                                by_status: result.summary?.by_status || {},
+                                tasks: result.tasks,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'unroo_create_task': {
+                const taskInput = args;
+                const result = await unrooClient.createTask({
+                    ...taskInput,
+                    external_source_type: 'claude_code',
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Task created: ${result.task.id}`,
+                                task: result.task,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'unroo_update_task': {
+                const { task_id, ...updates } = args;
+                const result = await unrooClient.updateTask(task_id, updates);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Task ${task_id} updated`,
+                                task: result.task,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'unroo_get_my_tasks': {
+                const { status, limit } = args;
+                // Note: The API key determines the user, tasks are filtered server-side
+                const result = await unrooClient.listTasks({
+                    status,
+                    limit: limit || 50,
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                total: result.tasks.length,
+                                tasks: result.tasks,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'unroo_start_session': {
+                const sessionInput = args;
+                // Update session tracker with task context
+                if (sessionInput.task_id) {
+                    sessionTracker.setCurrentTask(sessionInput.task_id);
+                }
+                const result = await unrooClient.startSession({
+                    ...sessionInput,
+                    source: 'claude-code-mcp',
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: 'Work session started',
+                                session: result.session,
+                                auto_tracking: sessionTracker.getStats(),
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'unroo_end_session': {
+                // End both explicit and auto-tracked sessions
+                await sessionTracker.endSession();
+                const result = await unrooClient.endSession();
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Session ended. Duration: ${result.session.duration_minutes} minutes`,
+                                session: result.session,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'unroo_create_follow_up': {
+                const { parent_task_id, title, description, priority } = args;
+                // Get parent task to inherit project_key
+                const parentResult = await unrooClient.getTask(parent_task_id);
+                if (!parentResult.task) {
+                    throw new Error(`Parent task not found: ${parent_task_id}`);
+                }
+                const parentTask = parentResult.task;
+                const result = await unrooClient.createTask({
+                    title: `[Follow-up] ${title}`,
+                    description: description || `Follow-up from task: ${parentTask.title}`,
+                    project_key: parentTask.project_key || 'FCP',
+                    priority: priority || parentTask.priority || 'medium',
+                    parent_issue_id: parent_task_id,
+                    external_source_type: 'claude_code_followup',
+                    labels: ['follow-up'],
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Follow-up task created: ${result.task.id}`,
+                                parent_task_id,
+                                task: result.task,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }
@@ -426,6 +995,14 @@ async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error('FCP MCP Server running on stdio');
+    // Handle graceful shutdown
+    const shutdown = async () => {
+        console.error('Shutting down MCP server...');
+        await sessionTracker.endSession();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
 }
 main().catch((error) => {
     console.error('Fatal error:', error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fruition/fcp-mcp-server",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "MCP Server for FCP Launch Coordination System - enables Claude Code to interact with FCP launches",
   "main": "dist/index.js",
   "type": "module",