@fruition/fcp-mcp-server 1.0.1 → 1.2.0

package/README.md

@@ -1,6 +1,6 @@
 # FCP MCP Server
 
-MCP (Model Context Protocol) server that gives Claude Code direct access to the FCP Launch Coordination System.
+MCP (Model Context Protocol) server that gives Claude Code direct access to the FCP Launch Coordination System. Also includes automatic time tracking integration with Unroo.
 
 ## Features
 
@@ -149,3 +149,76 @@ To get an API token for the MCP server:
 ### Tools not appearing
 - Restart Claude Code after updating settings
 - Check Claude Code logs for MCP server errors
+
+---
+
+## Time Tracking with Unroo
+
+This package also includes `unroo-heartbeat`, a script that automatically tracks your Claude Code development time in Unroo.
+
+### Quick Setup
+
+After installing the package globally (`npm install -g @fruition/fcp-mcp-server`), configure time tracking:
+
+#### 1. Set your Unroo API key
+
+Add to `~/.bashrc` or `~/.zshrc`:
+
+```bash
+export UNROO_API_KEY="mcp_XXXXXX_your_key_here"
+```
+
+Get your API key from Unroo: Settings → API Keys → Create with "Time Tracking" enabled.
+
+#### 2. Configure Claude Code hooks
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "unroo-heartbeat"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "unroo-heartbeat session_end"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+#### 3. Restart Claude Code
+
+Time tracking is now active. Sessions are automatically mapped to the correct Unroo project based on:
+1. `.unroo` file in project root (if present)
+2. Saved repo→project mappings (learned from previous sessions)
+3. Smart matching by repo name to Jira project key
+
+### Project Configuration (Optional)
+
+For repos that don't auto-match, create a `.unroo` file:
+
+```bash
+echo "project_slug=YOUR_JIRA_KEY" > .unroo
+```
+
+The system learns from this and saves the mapping permanently, so you only need to do this once per repo.
+
+### Viewing Time
+
+Log in to [Unroo](https://chat.frugpt.com) and check My Day or Timesheet to see your tracked sessions.

package/bin/unroo-heartbeat.sh

@@ -0,0 +1,90 @@
+#!/bin/bash
+# ============================================================================
+# UNROO CLAUDE CODE HEARTBEAT SCRIPT
+# ============================================================================
+# Sends heartbeat signals to UnRoo time tracker API
+# Called by Claude Code hooks on tool use events
+#
+# Usage:
+#   unroo-heartbeat.sh [event_type]
+#
+# Event types:
+#   tool_end (default) - After tool completes
+#   session_end - When Claude Code session ends
+#   heartbeat - Periodic heartbeat from watcher
+#
+# Environment variables:
+#   UNROO_API_KEY - Required: Your UnRoo API key with time tracking enabled
+#   UNROO_API_ENDPOINT - Optional: API base URL (default: https://chat.frugpt.com)
+#   TOOL_NAME - Optional: Name of the tool that was used
+#   TOOL_DESCRIPTION - Optional: Description of what the tool did
+#
+# Project Configuration:
+#   Create a .unroo file in your project root with:
+#     project_slug=YOUR_PROJECT_SLUG
+#   This maps time to the correct Unroo project (optional - auto-matching works for most repos).
+#
+# Installation:
+#   npm install -g @fruition/fcp-mcp-server
+#   Then set UNROO_API_KEY in your shell profile and configure Claude Code hooks.
+# ============================================================================
+
+# Configuration
+EVENT_TYPE="${1:-tool_end}"
+API_ENDPOINT="${UNROO_API_ENDPOINT:-https://chat.frugpt.com}"
+API_URL="${API_ENDPOINT}/api/unroo/claude-tracker/heartbeat"
+
+# Check for API key
+if [ -z "$UNROO_API_KEY" ]; then
+  # Silently exit if no API key - don't block Claude Code
+  exit 0
+fi
+
+# Get git remote URL (if in a git repo)
+GIT_REMOTE=""
+if git rev-parse --git-dir > /dev/null 2>&1; then
+  GIT_REMOTE=$(git remote get-url origin 2>/dev/null || echo "")
+fi
+
+# Get repo name from current directory
+REPO_NAME=$(basename "$(pwd)")
+
+# Check for project-specific config (.unroo file)
+PROJECT_SLUG=""
+if [ -f ".unroo" ]; then
+  PROJECT_SLUG=$(grep -E "^project_slug=" .unroo 2>/dev/null | cut -d= -f2)
+fi
+
+# Get machine ID (for multi-machine tracking)
+MACHINE_ID=""
+if [ -f /etc/machine-id ]; then
+  MACHINE_ID=$(cat /etc/machine-id | head -c 8)
+elif command -v hostid &> /dev/null; then
+  MACHINE_ID=$(hostid)
+fi
+
+# Build JSON payload
+JSON_PAYLOAD=$(cat <<EOF
+{
+  "api_key": "${UNROO_API_KEY}",
+  "event_type": "${EVENT_TYPE}",
+  "source": "claude-code",
+  "git_remote_url": "${GIT_REMOTE}",
+  "repo_name": "${REPO_NAME}",
+  "machine_id": "${MACHINE_ID}",
+  "tool_name": "${TOOL_NAME:-}",
+  "tool_description": "${TOOL_DESCRIPTION:-}",
+  "project_slug": "${PROJECT_SLUG:-}"
+}
+EOF
+)
+
+# Send heartbeat in background to not block Claude Code
+# Redirect all output to /dev/null to avoid any terminal output
+curl -s -X POST "$API_URL" \
+  -H "Content-Type: application/json" \
+  -d "$JSON_PAYLOAD" \
+  > /dev/null 2>&1 &
+
+# Exit immediately - don't wait for curl
+exit 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://chat.frugpt.com';
+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,14 +1,16 @@
 {
   "name": "@fruition/fcp-mcp-server",
-  "version": "1.0.1",
-  "description": "MCP Server for FCP Launch Coordination System - enables Claude Code to interact with FCP launches",
+  "version": "1.2.0",
+  "description": "MCP Server for FCP Launch Coordination System - enables Claude Code to interact with FCP launches and track development time",
   "main": "dist/index.js",
   "type": "module",
   "bin": {
-    "fcp-mcp-server": "./dist/index.js"
+    "fcp-mcp-server": "./dist/index.js",
+    "unroo-heartbeat": "./bin/unroo-heartbeat.sh"
   },
   "files": [
-    "dist"
+    "dist",
+    "bin"
   ],
   "scripts": {
     "build": "tsc",