@fruition/fcp-mcp-server 1.3.0 → 1.4.0

package/dist/index.js

@@ -33,11 +33,88 @@ 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;
@@ -180,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
@@ -234,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);
@@ -272,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) {
@@ -283,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);
@@ -1065,6 +1192,8 @@ async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
     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

package/package.json

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