npm package: @lucianfialho/build-in-public-mcp
Description: MCP server for Build in Public - automatically share your dev progress on Twitter with AI-powered suggestions
Author: Lucian Fialho
Latest version: 0.5.0

# Build in Public MCP Server

> **v0.5.0**

MCP (Model Context Protocol) server for Build in Public - share your dev progress on Twitter directly from Claude Code, Cursor, VS Code, JetBrains IDEs, and more.

## What is this?

If Claude Code is already helping you build, why not use it to document the journey too?

This MCP server analyzes your coding sessions and generates tweet suggestions about what you accomplished.

## Prerequisites: Twitter API Setup

You need a Twitter Developer account with API credentials. Here's how to get them:

### Step 1: Create a Twitter Developer Account

1. Go to [developer.x.com](https://developer.x.com/en/portal/dashboard)
2. Sign in with your Twitter account
3. Apply for a developer account (Free tier works)

### Step 2: Create a Project and App

1. In the Developer Portal, click **"Create Project"**
2. Give it a name (e.g., "Build in Public")
3. Select use case: **"Making a bot"** or **"Exploring the API"**
4. Give your app a name (e.g., "build-in-public-mcp")

### Step 3: Enable OAuth 1.0a with Write Permissions

1. In your app settings, go to **"User authentication settings"** → click **"Set up"**
2. Enable **OAuth 1.0a**
3. Set App permissions to **"Read and write"**
4. Set Type of App to **"Web App, Automated App or Bot"**
5. Set Callback URL to `https://example.com` (required but not used)
6. Set Website URL to `https://example.com`
7. Click **"Save"**

### Step 4: Get Your API Keys

1. Go to **"Keys and Tokens"** tab
2. Under **"Consumer Keys"**, click **"Regenerate"** (you need to regenerate AFTER enabling OAuth 1.0a)
3. Copy your **API Key** and **API Key Secret**

> **Important:** You must regenerate the keys AFTER setting up OAuth 1.0a permissions, otherwise the keys won't have write access.

## Installation

### Claude Code (Recommended)

```bash
claude mcp add --transport stdio \
  -e TWITTER_API_KEY=your_api_key \
  -e TWITTER_API_SECRET=your_api_secret \
  build-in-public npx @lucianfialho/build-in-public-mcp
```

### Cursor

Add to your `~/.cursor/mcp.json`:

```json
{
  "mcpServers": {
    "build-in-public": {
      "command": "npx",
      "args": ["@lucianfialho/build-in-public-mcp"],
      "env": {
        "TWITTER_API_KEY": "your_api_key",
        "TWITTER_API_SECRET": "your_api_secret"
      }
    }
  }
}
```

### VS Code

Add to User Settings JSON (`Ctrl+Shift+P` → "Preferences: Open User Settings (JSON)"):

```json
{
  "mcp.servers": {
    "build-in-public": {
      "command": "npx",
      "args": ["@lucianfialho/build-in-public-mcp"],
      "transport": "stdio",
      "env": {
        "TWITTER_API_KEY": "your_api_key",
        "TWITTER_API_SECRET": "your_api_secret"
      }
    }
  }
}
```

### Claude Desktop

Add to your config file:

**macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
**Windows:** `%APPDATA%\Claude\claude_desktop_config.json`

```json
{
  "mcpServers": {
    "build-in-public": {
      "command": "npx",
      "args": ["@lucianfialho/build-in-public-mcp"],
      "env": {
        "TWITTER_API_KEY": "your_api_key",
        "TWITTER_API_SECRET": "your_api_secret"
      }
    }
  }
}
```

### Global Install (Alternative)

```bash
npm install -g @lucianfialho/build-in-public-mcp
claude mcp add --transport stdio \
  -e TWITTER_API_KEY=your_api_key \
  -e TWITTER_API_SECRET=your_api_secret \
  build-in-public build-in-public-mcp
```

## Quick Start

### 1. Authenticate with Twitter

After installing and configuring your API keys, authenticate via OAuth:

```
You: Setup build in public authentication

Claude: Authorization URL opened in your browser!
        After authorizing, Twitter will show you a PIN code.

You: The PIN is 1234567

Claude: Authenticated as: @your_username
        Tokens saved to: ~/.build-in-public/auth.json
```

The OAuth flow generates access tokens that are saved locally. You only need to do this once.

### 2. Post Tweets

**Quick tweet:**
```
"Post to Twitter: Just launched my new feature!"
```

**AI-powered retro (analyzes your whole coding session):**
```
"Analyze my session and help me share what I accomplished on Twitter"
```

**Get suggestions:**
```
"Give me tweet suggestions based on what I've been working on"
```

## Environment Variables

| Variable | Required | Description |
|----------|----------|-------------|
| `TWITTER_API_KEY` | Yes | Twitter API Key (Consumer Key) |
| `TWITTER_API_SECRET` | Yes | Twitter API Secret (Consumer Secret) |
| `TWITTER_ACCESS_TOKEN` | No | Skip OAuth - use access token directly |
| `TWITTER_ACCESS_SECRET` | No | Skip OAuth - use access secret directly |

If you provide all 4 variables, the OAuth flow is skipped entirely.

## Available Tools

| Tool | Description |
|------|-------------|
| `setup_auth` | OAuth PIN-based authentication flow |
| `status` | Check auth status and configuration |
| `tweet` | Post a single tweet (max 280 chars) |
| `thread` | Create a Twitter thread from multiple messages |
| `suggest` | Generate tweet suggestions from session context |
| `save_context` | Save coding session context for suggestions |
| `get_context` | Retrieve current session context |

## Architecture

```
AI IDE/Editor -> STDIO -> MCP Server (local) -> Twitter API
                              |
                   ~/.build-in-public/
                   - auth.json (OAuth tokens)
                   - context.json (Session context)
                   - history.json (Tweet history)
```

100% local, zero external infrastructure.

## Privacy & Security

- OAuth tokens stored locally in `~/.build-in-public/auth.json` with `0600` permissions
- Never sent to external servers (except Twitter API)
- No analytics, no tracking, no telemetry
- Open source

## Contributing

Contributions, issues, and feedback welcome.

**Repository:** [github.com/lucianfialho/build-in-public-mcp](https://github.com/lucianfialho/build-in-public-mcp)

## License

MIT