@fruition/fcp-mcp-server 1.2.0 → 1.4.0

package/dist/index.js

@@ -10,11 +10,111 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+// Get version from package.json
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJsonPath = join(__dirname, '..', 'package.json');
+let MCP_SERVER_VERSION = '1.0.0'; // fallback
+try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    MCP_SERVER_VERSION = packageJson.version;
+}
+catch {
+    // Try one level up (for dist folder)
+    try {
+        const altPath = join(__dirname, '..', '..', 'package.json');
+        const packageJson = JSON.parse(readFileSync(altPath, 'utf-8'));
+        MCP_SERVER_VERSION = packageJson.version;
+    }
+    catch {
+        console.error('[MCP Server] Warning: Could not read package.json version');
+    }
+}
+import { execSync } from 'child_process';
 // 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 || '';
+let currentProject = null;
+/**
+ * Detect the current git remote URL
+ */
+function detectGitRemote() {
+    try {
+        const remote = execSync('git config --get remote.origin.url', {
+            encoding: 'utf-8',
+            timeout: 5000,
+            stdio: ['pipe', 'pipe', 'ignore'],
+        }).trim();
+        return remote || null;
+    }
+    catch {
+        // Not a git repo or no remote configured
+        return null;
+    }
+}
+/**
+ * Resolve project from git remote URL via FCP API
+ */
+async function resolveProjectFromRepo(repoUrl) {
+    if (!FCP_API_URL) {
+        return null;
+    }
+    try {
+        const url = `${FCP_API_URL}/api/mcp/resolve-project?repo_url=${encodeURIComponent(repoUrl)}`;
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (FCP_API_TOKEN && FCP_API_TOKEN !== 'dev_bypass') {
+            headers['X-API-Key'] = FCP_API_TOKEN;
+        }
+        else if (FCP_API_TOKEN === 'dev_bypass') {
+            headers['X-Dev-Bypass'] = 'true';
+        }
+        const response = await fetch(url, { headers });
+        if (!response.ok) {
+            return null;
+        }
+        const data = await response.json();
+        if (data.found && data.project) {
+            return {
+                project_key: data.project.project_key,
+                website_id: data.project.website_id,
+                domain: data.project.domain,
+                account_name: data.project.account_name || 'Unknown',
+                github: data.project.github,
+            };
+        }
+        return null;
+    }
+    catch (error) {
+        console.error('[MCP Server] Error resolving project:', error);
+        return null;
+    }
+}
+/**
+ * Initialize project detection on startup
+ */
+async function initializeProjectDetection() {
+    const remoteUrl = detectGitRemote();
+    if (!remoteUrl) {
+        console.error('[MCP Server] No git remote detected - project will be tracked as general');
+        return;
+    }
+    console.error(`[MCP Server] Detected git remote: ${remoteUrl}`);
+    const project = await resolveProjectFromRepo(remoteUrl);
+    if (project) {
+        currentProject = project;
+        console.error(`[MCP Server] Resolved project: ${project.domain} (${project.project_key})`);
+    }
+    else {
+        console.error('[MCP Server] Could not resolve project from repo - check FCP website github config');
+    }
+}
 // API Client
 class FCPClient {
     baseUrl;
@@ -157,6 +257,19 @@ class UnrooClient {
             body: JSON.stringify({ action: 'heartbeat', ...input }),
         });
     }
+    async logActivity(taskId, input) {
+        return this.fetch(`/api/external/fcp/tasks/${encodeURIComponent(taskId)}/activity`, {
+            method: 'POST',
+            body: JSON.stringify({
+                activity_type: input.activity_type,
+                source: input.source || 'claude_code',
+                field_changed: input.field_changed,
+                old_value: input.old_value,
+                new_value: input.new_value,
+                metadata: input.metadata,
+            }),
+        });
+    }
 }
 // ============================================================================
 // Auto Session Tracking
@@ -211,18 +324,30 @@ class SessionTracker {
             return;
         }
         try {
-            await this.unrooClient.startSession({
+            // Use auto-detected project if available
+            const sessionInput = {
                 task_id: this.currentTaskId || undefined,
                 source: 'claude-code-mcp',
                 machine_id: process.env.HOSTNAME || 'unknown',
-            });
+            };
+            // Add auto-detected project info
+            if (currentProject) {
+                sessionInput.project_key = currentProject.project_key;
+                sessionInput.repo_name = `${currentProject.github.owner}/${currentProject.github.repo}`;
+            }
+            await this.unrooClient.startSession(sessionInput);
             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');
+            if (currentProject) {
+                console.error(`[SessionTracker] Session started for project: ${currentProject.domain}`);
+            }
+            else {
+                console.error('[SessionTracker] Session started (no project detected)');
+            }
         }
         catch (error) {
             console.error('[SessionTracker] Failed to start session:', error);
@@ -249,7 +374,7 @@ class SessionTracker {
         }
     }
     /**
-     * End the current session
+     * End the current session and log activity summary to task
      */
     async endSession() {
         if (!this.sessionActive || !UNROO_API_KEY) {
@@ -260,9 +385,34 @@ class SessionTracker {
             this.heartbeatInterval = null;
         }
         try {
-            await this.unrooClient.endSession();
+            // End the session first
+            const result = await this.unrooClient.endSession();
             this.sessionActive = false;
             console.error('[SessionTracker] Session ended');
+            // Log activity summary to the task if we have a current task
+            if (this.currentTaskId && result.session) {
+                try {
+                    const session = result.session;
+                    const uniqueTools = [...new Set(this.activities.map(a => a.tool))];
+                    await this.unrooClient.logActivity(this.currentTaskId, {
+                        activity_type: 'claude_code_session',
+                        source: 'claude_code',
+                        metadata: {
+                            session_id: session.id,
+                            duration_seconds: session.duration_minutes ? session.duration_minutes * 60 : 0,
+                            total_tool_calls: session.total_tool_calls || this.toolCallCount,
+                            tools_used: uniqueTools.slice(0, 20), // Limit to 20 tools
+                            started_at: session.started_at,
+                            ended_at: session.ended_at || new Date().toISOString(),
+                        },
+                    });
+                    console.error(`[SessionTracker] Logged session activity to task ${this.currentTaskId}`);
+                }
+                catch (activityError) {
+                    console.error('[SessionTracker] Failed to log activity to task:', activityError);
+                    // Don't throw - session end was successful
+                }
+            }
         }
         catch (error) {
             console.error('[SessionTracker] Failed to end session:', error);
@@ -283,7 +433,7 @@ class SessionTracker {
 // Create server
 const server = new Server({
     name: 'fcp-mcp-server',
-    version: '1.0.0',
+    version: MCP_SERVER_VERSION,
 }, {
     capabilities: {
         tools: {},
@@ -990,11 +1140,62 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
     }
     throw new Error(`Unknown resource: ${uri}`);
 });
+// Version comparison helper
+function compareVersions(v1, v2) {
+    const parts1 = v1.split('.').map(Number);
+    const parts2 = v2.split('.').map(Number);
+    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+        const p1 = parts1[i] || 0;
+        const p2 = parts2[i] || 0;
+        if (p1 > p2)
+            return 1;
+        if (p1 < p2)
+            return -1;
+    }
+    return 0;
+}
+// Check for updates on startup
+async function checkForUpdates() {
+    if (!FCP_API_URL)
+        return;
+    try {
+        const response = await fetch(`${FCP_API_URL}/api/mcp/version`, {
+            headers: FCP_API_TOKEN ? { 'X-API-Key': FCP_API_TOKEN } : {},
+        });
+        if (!response.ok) {
+            // Silently ignore - version endpoint may not exist on older FCP versions
+            return;
+        }
+        const data = await response.json();
+        const latestVersion = data.version;
+        const minVersion = data.minVersion;
+        if (compareVersions(MCP_SERVER_VERSION, minVersion) < 0) {
+            console.error(`\n⚠️  [MCP Server] INCOMPATIBLE VERSION`);
+            console.error(`   Your version: ${MCP_SERVER_VERSION}`);
+            console.error(`   Minimum required: ${minVersion}`);
+            console.error(`   Please update: ${data.updateUrl}\n`);
+        }
+        else if (compareVersions(MCP_SERVER_VERSION, latestVersion) < 0) {
+            console.error(`\n📦 [MCP Server] Update available: ${MCP_SERVER_VERSION} → ${latestVersion}`);
+            console.error(`   Update: ${data.updateUrl}\n`);
+        }
+        else {
+            console.error(`[MCP Server] Version ${MCP_SERVER_VERSION} (up to date)`);
+        }
+    }
+    catch {
+        // Silently ignore network errors - don't block startup
+    }
+}
 // Start server
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error('FCP MCP Server running on stdio');
+    console.error(`FCP MCP Server v${MCP_SERVER_VERSION} running on stdio`);
+    // Auto-detect project from git remote (non-blocking)
+    initializeProjectDetection();
+    // Check for updates (non-blocking)
+    checkForUpdates();
     // Handle graceful shutdown
     const shutdown = async () => {
         console.error('Shutting down MCP server...');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fruition/fcp-mcp-server",
-  "version": "1.2.0",
+  "version": "1.4.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",