npm package: @fruition/fcp-mcp-server
Description: MCP Server for FCP Launch Coordination System - enables Claude Code to interact with FCP launches and track development time
Author: Fruition
Latest version: 1.16.2

# FCP MCP Server

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

### FCP Launch Management 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 |

### Unroo Task Management Tools

| Tool | Description |
|------|-------------|
| `unroo_list_projects` | List all Unroo projects mapped to FCP clients |
| `unroo_list_tasks` | Query tasks with filters (status, project, assignee) |
| `unroo_create_task` | Create new tasks for discovered issues or follow-ups |
| `unroo_update_task` | Update task status, hours logged, priority |
| `unroo_get_my_tasks` | Get tasks assigned to current user |
| `unroo_start_session` | Start work session for time tracking |
| `unroo_end_session` | End work session and log time |
| `unroo_create_follow_up` | Create follow-up task linked to a parent |

### 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

---

## 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://app.unroo.io) and check My Day or Timesheet to see your tracked sessions.