@fruition/fcp-mcp-server 1.0.0

package/README.md

@@ -0,0 +1,151 @@
+# FCP MCP Server
+
+MCP (Model Context Protocol) server that gives Claude Code direct access to the FCP Launch Coordination System.
+
+## Features
+
+### Tools
+
+| Tool | Description |
+|------|-------------|
+| `fcp_list_launches` | List launches with optional filters (status, platform, upcoming days) |
+| `fcp_get_launch` | Get detailed launch info including checklist and team |
+| `fcp_get_legacy_access` | Get legacy hosting access info for migrations |
+| `fcp_get_checklist` | Get checklist items with Claude instructions |
+| `fcp_update_checklist_item` | Update checklist item status as you complete work |
+| `fcp_add_progress_note` | Add progress notes to document work done |
+| `fcp_get_claude_md` | Generate CLAUDE.md content for a launch |
+
+### Resources
+
+- `fcp://launches` - List of all launches
+- `fcp://launches/{id}` - Single launch details
+
+## Setup
+
+### 1. Install Dependencies
+
+```bash
+cd mcp-server
+npm install
+```
+
+### 2. Build
+
+```bash
+npm run build
+```
+
+### 3. Configure Environment
+
+Create a `.env` file or set environment variables:
+
+```bash
+FCP_API_URL=https://fcp.fru.io  # or http://localhost:3090 for local dev
+FCP_API_TOKEN=your_api_token     # Get from FCP Settings > API Tokens
+```
+
+### 4. Add to Claude Code
+
+Add to your Claude Code settings (`~/.claude/settings.json`):
+
+```json
+{
+  "mcpServers": {
+    "fcp": {
+      "command": "node",
+      "args": ["/path/to/fcp/mcp-server/dist/index.js"],
+      "env": {
+        "FCP_API_URL": "https://fcp.fru.io",
+        "FCP_API_TOKEN": "your_api_token"
+      }
+    }
+  }
+}
+```
+
+Or for development:
+
+```json
+{
+  "mcpServers": {
+    "fcp": {
+      "command": "npx",
+      "args": ["tsx", "/path/to/fcp/mcp-server/src/index.ts"],
+      "env": {
+        "FCP_API_URL": "http://localhost:3090",
+        "FCP_API_TOKEN": "dev_token"
+      }
+    }
+  }
+}
+```
+
+## Usage Examples
+
+Once configured, Claude Code can use these tools naturally:
+
+### Get launch context for current project
+
+```
+"What's the status of launch 3 and what checklist items are remaining?"
+```
+
+Claude will call `fcp_get_launch` and `fcp_get_checklist` to get the info.
+
+### Work through checklist items
+
+```
+"I've completed the database export. Mark that checklist item as done."
+```
+
+Claude will call `fcp_update_checklist_item` to update the status.
+
+### Get legacy access info
+
+```
+"How do I access the legacy hosting for this migration?"
+```
+
+Claude will call `fcp_get_legacy_access` to get hosting, database, and file access details.
+
+### Document progress
+
+```
+"Add a note that I've migrated all user accounts successfully."
+```
+
+Claude will call `fcp_add_progress_note` to log the progress.
+
+## Development
+
+Run in development mode:
+
+```bash
+npm run dev
+```
+
+This uses `tsx` to run TypeScript directly without building.
+
+## API Token
+
+To get an API token for the MCP server:
+
+1. Go to FCP: https://fcp.fru.io/dashboard/settings
+2. Navigate to "API Tokens" section
+3. Create a new token with "Launch Management" permissions
+4. Copy the token to your MCP server configuration
+
+## Troubleshooting
+
+### "Authentication failed"
+- Check that `FCP_API_TOKEN` is set correctly
+- Verify the token has the required permissions
+
+### "Connection refused"
+- Check that `FCP_API_URL` is correct
+- For local dev, ensure FCP is running on port 3090
+
+### Tools not appearing
+- Restart Claude Code after updating settings
+- Check Claude Code logs for MCP server errors

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * FCP MCP Server
+ *
+ * Provides Claude Code with direct access to FCP Launch Coordination System:
+ * - Query launches, checklists, and legacy access info
+ * - Update checklist item status
+ * - Get project context for migrations
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,433 @@
+#!/usr/bin/env node
+/**
+ * FCP MCP Server
+ *
+ * Provides Claude Code with direct access to FCP Launch Coordination System:
+ * - Query launches, checklists, and legacy access info
+ * - Update checklist item status
+ * - Get project context for migrations
+ */
+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';
+// Configuration
+const FCP_API_URL = process.env.FCP_API_URL || 'https://fcp.fru.io';
+const FCP_API_TOKEN = process.env.FCP_API_TOKEN || '';
+// API Client
+class FCPClient {
+    baseUrl;
+    token;
+    constructor(baseUrl, token) {
+        this.baseUrl = baseUrl;
+        this.token = token;
+    }
+    async fetch(path, options = {}) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            'Content-Type': 'application/json',
+            ...(options.headers || {}),
+        };
+        if (this.token) {
+            // Support dev bypass mode for local testing
+            if (this.token === 'dev_bypass') {
+                headers['X-Dev-Bypass'] = 'true';
+            }
+            else {
+                // Production mode: use X-API-Key header
+                headers['X-API-Key'] = this.token;
+            }
+        }
+        const response = await fetch(url, {
+            ...options,
+            headers,
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`FCP API error (${response.status}): ${error}`);
+        }
+        return response.json();
+    }
+    async listLaunches(filters) {
+        const params = new URLSearchParams();
+        if (filters?.status)
+            params.set('status', filters.status);
+        if (filters?.platform)
+            params.set('platform', filters.platform);
+        if (filters?.upcoming)
+            params.set('upcoming', filters.upcoming.toString());
+        if (filters?.limit)
+            params.set('limit', filters.limit.toString());
+        const query = params.toString();
+        return this.fetch(`/api/launches${query ? `?${query}` : ''}`);
+    }
+    async getLaunch(id) {
+        return this.fetch(`/api/launches/${id}`);
+    }
+    async updateChecklistItem(launchId, itemId, updates) {
+        return this.fetch(`/api/launches/${launchId}/checklist/${itemId}`, {
+            method: 'PUT',
+            body: JSON.stringify(updates),
+        });
+    }
+    async getClaudeMd(launchId) {
+        return this.fetch(`/api/launches/${launchId}/claude-md`);
+    }
+    async addNote(launchId, content) {
+        return this.fetch(`/api/launches/${launchId}/notes`, {
+            method: 'POST',
+            body: JSON.stringify({ content }),
+        });
+    }
+}
+// Create server
+const server = new Server({
+    name: 'fcp-mcp-server',
+    version: '1.0.0',
+}, {
+    capabilities: {
+        tools: {},
+        resources: {},
+    },
+});
+const client = new FCPClient(FCP_API_URL, FCP_API_TOKEN);
+// Tool definitions
+const TOOLS = [
+    {
+        name: 'fcp_list_launches',
+        description: 'List launches from FCP with optional filters. Returns upcoming launches, their status, and basic info.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: {
+                    type: 'string',
+                    description: 'Filter by status: planning, in_progress, soft_launched, launched, on_hold, cancelled',
+                },
+                platform: {
+                    type: 'string',
+                    description: 'Filter by platform: wordpress, drupal, nextjs, other',
+                },
+                upcoming: {
+                    type: 'number',
+                    description: 'Show launches within next N days',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of launches to return',
+                },
+            },
+        },
+    },
+    {
+        name: 'fcp_get_launch',
+        description: 'Get detailed information about a specific launch including checklist items, legacy access info, and team assignments.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                launch_id: {
+                    type: 'number',
+                    description: 'The ID of the launch to retrieve',
+                },
+            },
+            required: ['launch_id'],
+        },
+    },
+    {
+        name: 'fcp_get_legacy_access',
+        description: 'Get legacy hosting access information for a migration launch. Includes hosting provider, database access, file access, git repo, and DNS details.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                launch_id: {
+                    type: 'number',
+                    description: 'The ID of the launch',
+                },
+            },
+            required: ['launch_id'],
+        },
+    },
+    {
+        name: 'fcp_get_checklist',
+        description: 'Get the launch checklist with item statuses and any Claude-specific instructions for completing tasks.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                launch_id: {
+                    type: 'number',
+                    description: 'The ID of the launch',
+                },
+                category: {
+                    type: 'string',
+                    description: 'Optional: filter by category (pre_launch, content, technical, seo, testing, dns, monitoring, post_launch)',
+                },
+                status: {
+                    type: 'string',
+                    description: 'Optional: filter by status (pending, in_progress, completed, blocked, skipped)',
+                },
+            },
+            required: ['launch_id'],
+        },
+    },
+    {
+        name: 'fcp_update_checklist_item',
+        description: 'Update the status of a checklist item. Use this to mark items as completed, in_progress, or blocked as you work through tasks.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                launch_id: {
+                    type: 'number',
+                    description: 'The ID of the launch',
+                },
+                item_id: {
+                    type: 'number',
+                    description: 'The ID of the checklist item',
+                },
+                status: {
+                    type: 'string',
+                    enum: ['pending', 'in_progress', 'completed', 'blocked', 'skipped'],
+                    description: 'New status for the item',
+                },
+                notes: {
+                    type: 'string',
+                    description: 'Optional notes about the status change',
+                },
+            },
+            required: ['launch_id', 'item_id', 'status'],
+        },
+    },
+    {
+        name: 'fcp_add_progress_note',
+        description: 'Add a progress note to a launch. Use this to document what work was done or any issues encountered.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                launch_id: {
+                    type: 'number',
+                    description: 'The ID of the launch',
+                },
+                content: {
+                    type: 'string',
+                    description: 'The note content',
+                },
+            },
+            required: ['launch_id', 'content'],
+        },
+    },
+    {
+        name: 'fcp_get_claude_md',
+        description: 'Generate CLAUDE.md content for a launch. Returns formatted markdown with project context, legacy access info, and checklist.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                launch_id: {
+                    type: 'number',
+                    description: 'The ID of the launch',
+                },
+            },
+            required: ['launch_id'],
+        },
+    },
+];
+// Register tool handlers
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: TOOLS };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case 'fcp_list_launches': {
+                const result = await client.listLaunches(args);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_get_launch': {
+                const { launch_id } = args;
+                const result = await client.getLaunch(launch_id);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_get_legacy_access': {
+                const { launch_id } = args;
+                const result = await client.getLaunch(launch_id);
+                const legacyAccess = {
+                    launch_id,
+                    launch_name: result.launch.name,
+                    launch_type: result.launch.launch_type,
+                    legacy_domain: result.launch.legacy_domain,
+                    legacy_access_info: result.launch.legacy_access_info || {},
+                };
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(legacyAccess, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_get_checklist': {
+                const { launch_id, category, status } = args;
+                const result = await client.getLaunch(launch_id);
+                let checklist = result.checklist || [];
+                if (category) {
+                    checklist = checklist.filter((item) => item.category === category);
+                }
+                if (status) {
+                    checklist = checklist.filter((item) => item.status === status);
+                }
+                // Format for readability
+                const formatted = checklist.map((item) => ({
+                    id: item.id,
+                    title: item.title,
+                    status: item.status,
+                    category: item.category,
+                    is_blocker: item.is_blocker,
+                    description: item.description,
+                    claude_instructions: item.claude_instructions,
+                }));
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                launch_id,
+                                launch_name: result.launch.name,
+                                total_items: formatted.length,
+                                completed: formatted.filter((i) => i.status === 'completed').length,
+                                blockers: formatted.filter((i) => i.is_blocker && i.status !== 'completed').length,
+                                items: formatted,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_update_checklist_item': {
+                const { launch_id, item_id, status, notes } = args;
+                const result = await client.updateChecklistItem(launch_id, item_id, {
+                    status,
+                    notes,
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Checklist item ${item_id} updated to status: ${status}`,
+                                item: result,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_add_progress_note': {
+                const { launch_id, content } = args;
+                const result = await client.addNote(launch_id, content);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: 'Progress note added',
+                                note: result,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_get_claude_md': {
+                const { launch_id } = args;
+                const result = await client.getClaudeMd(launch_id);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: result.content,
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ error: message }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Resource handlers
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return {
+        resources: [
+            {
+                uri: 'fcp://launches',
+                name: 'FCP Launches',
+                description: 'List of all launches in FCP',
+                mimeType: 'application/json',
+            },
+        ],
+    };
+});
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    if (uri === 'fcp://launches') {
+        const result = await client.listLaunches({ limit: 50 });
+        return {
+            contents: [
+                {
+                    uri,
+                    mimeType: 'application/json',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    // Handle fcp://launches/{id}
+    const launchMatch = uri.match(/^fcp:\/\/launches\/(\d+)$/);
+    if (launchMatch) {
+        const launchId = parseInt(launchMatch[1], 10);
+        const result = await client.getLaunch(launchId);
+        return {
+            contents: [
+                {
+                    uri,
+                    mimeType: 'application/json',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    throw new Error(`Unknown resource: ${uri}`);
+});
+// Start server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('FCP MCP Server running on stdio');
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@fruition/fcp-mcp-server",
+  "version": "1.0.0",
+  "description": "MCP Server for FCP Launch Coordination System - enables Claude Code to interact with FCP launches",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "fcp-mcp-server": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "claude",
+    "fcp",
+    "launch-coordination",
+    "anthropic"
+  ],
+  "author": "Fruition",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fruition/fcp.git",
+    "directory": "mcp-server"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0"
+  }
+}