# claude-bridge-mcp

**Category:** 💻 Developer Tools  
**Repository:** https://github.com/rahuljava2807/claude-bridge-mcp  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/claude-bridge-mcp

## Description
Pipes Claude Code session output into Claude Chat — no more copy-paste between tools

## Claude Desktop Quick Installation
Heuristic fallback — verify the package name and runner against the repository README before running it. Uses `npx` (confidence: low):

```json
"mcpServers": {
  "claude-bridge-mcp": {
    "command": "npx",
    "args": ["-y","claude-bridge-mcp"]
  }
}
```

## Documentation & README

# claude-code-bridge-mcp

[![npm version](https://img.shields.io/npm/v/claude-code-bridge-mcp.svg)](https://www.npmjs.com/package/claude-code-bridge-mcp)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
[![Node.js](https://img.shields.io/badge/node-%3E%3D18-brightgreen.svg)](https://nodejs.org)

> MCP server that pipes Claude Code session output directly into Claude Chat — no more copy-paste between tools.

`claude-code-bridge-mcp` is a Model Context Protocol (MCP) server that reads Claude Code's local session logs from `~/.claude/projects/<project-hash>/` and exposes them as tools to any MCP-compatible client (Claude Desktop, Claude Chat, Cursor, etc.). Run Claude Code in your terminal and pull its latest output into Claude Chat with a single tool call.

## Features

- **`get_latest_output`** — grab the most recent assistant message from any (or the most-recent) Claude Code session.
- **`list_sessions`** — enumerate all local sessions with project path, message count, and timestamps.
- **`get_session_context`** — fetch the last N messages from a session for context injection.
- **`watch_session`** — poll a session file every 2 seconds and drain new messages on demand.
- **`write_context`** _(v2)_ — snapshot the last N messages into `~/.claude/bridge-context.md` and `~/Documents/claude-bridge-context.md` as clean markdown.
- **`start_auto_sync`** _(v2)_ — keep that markdown snapshot live: rewrites both files every 30 seconds (configurable) so a synced folder stays current without manual calls.
- **`setup_drive_sync`** _(v2.1)_ — authorize direct Google Drive upload. Each sync tick then upserts a Google Doc named `claude-bridge-context` via the Drive API — no Drive desktop client required.
- **`send_to_session`** _(v2.2)_ — queue a prompt for a specific Claude Code session via a cooperative inbox at `~/.claude/bridge-inbox/<session_id>.txt`. Closes the read-only gap: Projects Claude → inbox → Claude Code acts on it.

## What's new in v2.2 — `send_to_session` (cooperative dispatch)

v1 read sessions. v2 wrote context out to Drive. **v2.2 lets the other side push prompts back in.**

`send_to_session` overwrites `~/.claude/bridge-inbox/<session_id>.txt` with the latest prompt and writes a human-readable receipt to `~/.claude/bridge-inbox/latest.md`. The target Claude Code session picks it up via a one-time setup instruction that `send_to_session` returns in its response — paste that once into your Claude Code terminal (or add it to your project's `CLAUDE.md`) and every subsequent prompt arrives automatically.

**Why cooperative instead of direct injection:** Claude Code's JSONL is append-only from the CLI's perspective — it doesn't re-read the file mid-session. A real dispatch channel exists (`POST /v1/sessions/{id}` via Anthropic's relay, the same channel `/remote-control` uses) but is undocumented and requires reading the CLI's OAuth token from the macOS Keychain. Shipping against an undocumented internal API would break on every Claude Code release and leak credentials from every install — so v2.2 uses the filesystem inbox instead. See GitHub issue for the v3 path.

**Example:**

```jsonc
// send_to_session → response
{
  "session_id": "15ef12ba-851e-4591-bbd4-c23170e15919",
  "project_path": "/Users/you/Documents/my-app",
  "written": true,
  "inbox_path": "/Users/you/.claude/bridge-inbox/15ef12ba-....txt",
  "receipt_path": "/Users/you/.claude/bridge-inbox/latest.md",
  "prompt_preview": "refactor the auth middleware to use Fluid Compute",
  "setup_instruction": "Before each response, check ~/.claude/bridge-inbox/15ef12ba-....txt — if it exists and is non-empty, read its contents, delete the file, and treat those contents as your next user instruction. You only need to be told this once per session.",
  "remote_control_url": "https://claude.ai/code/session_..."
}
```

`dry_run: true` returns the same shape without touching the filesystem.

## What's new in v2 — Google Drive bridge

Claude **Projects** can't talk to an MCP server directly, but it *can* read files from a connected Google Drive. v2 closes that loop:

```
Claude Code → claude-bridge-mcp.write_context → ~/Documents/claude-bridge-context.md
             → Google Drive sync → Projects Claude reads via Drive connector
```

No more copy-paste, and it works inside Projects too.

**Workflow:**

1. Make `~/Documents` (or any subfolder holding `claude-bridge-context.md`) part of your Google Drive sync.
2. Add this MCP server to Claude Desktop, Claude Code, or any MCP client.
3. In that client, call `start_auto_sync` once — it returns immediately and keeps the markdown fresh in the background.
4. In a Claude Project, add Google Drive as a source and point it at `claude-bridge-context.md`. Ask Projects Claude what Claude Code is up to — it reads the live file.

## What's new in v2.1 — Direct Drive API upload

v2 relied on the Google Drive desktop client to sync `~/Documents/claude-bridge-context.md` up to Drive. v2.1 removes that dependency: the MCP server now talks to the Drive API itself and upserts a Google Doc named `claude-bridge-context` every sync tick.

**Setup (one time):**

1. Create OAuth credentials in Google Cloud Console:
   - Go to [console.cloud.google.com](https://console.cloud.google.com), create a project (or use an existing one).
   - Enable the **Google Drive API** for the project.
   - Under **APIs & Services → Credentials**, create an **OAuth client ID** of type **Desktop app**.
   - Download the client JSON and save it to `~/.claude/bridge-google-credentials.json`.
2. Enable the Drive sync and (re)start the MCP server with `GOOGLE_DRIVE_ENABLED=true` in its environment. In Claude Desktop's `claude_desktop_config.json`:

   ```json
   {
     "mcpServers": {
       "claude-bridge": {
         "command": "node",
         "args": ["/absolute/path/to/claude-code-bridge-mcp/dist/index.js"],
         "env": { "GOOGLE_DRIVE_ENABLED": "true" }
       }
     }
   }
   ```
3. Call the `setup_drive_sync` tool from any connected client. It opens a browser tab for Google consent, saves the refresh token to `~/.claude/bridge-google-token.json`, and performs an initial upload. The response includes the Doc URL.
4. Call `start_auto_sync`. From now on, every tick writes the local markdown **and** pushes the same content to the Google Doc. The refresh token is reused silently on future server restarts.

**What the user sees:**

- A single Google Doc in Drive root named `claude-bridge-context`, live-updated every 30s with the most recent Claude Code session output.
- Add it as a source to any Claude Project, or open it directly — no Drive desktop client, no copy-paste.

**Opting out:** Omit `GOOGLE_DRIVE_ENABLED` (or set it to anything other than `true`) and the server behaves exactly like v2 — local markdown only, no Drive calls.

## Installation

```bash
git clone https://github.com/rahuljava2807/claude-code-bridge-mcp.git
cd claude-code-bridge-mcp
npm install
npm run build
```

### Add it to Claude Desktop

Edit `claude_desktop_config.json`:

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

```json
{
  "mcpServers": {
    "claude-bridge": {
      "command": "node",
      "args": ["/absolute/path/to/claude-code-bridge-mcp/dist/index.js"]
    }
  }
}
```

Restart Claude Desktop. The `claude-bridge` tools will appear in the tool picker.

## Usage

Typical workflow:

1. Run `claude` in a terminal to start a Claude Code session and do some work.
2. In Claude Chat, ask:
   > "Use `list_sessions` to find my most recent Claude Code session, then call `get_latest_output` on it and summarize what Claude Code just did."
3. For continuous streaming during a long-running Claude Code task, call `watch_session` repeatedly — each call returns only new messages since the last call.

### Example tool call

```jsonc
// get_latest_output with no arguments → uses the most recently updated session
{
  "content": "I've refactored the auth middleware to use Fluid Compute...",
  "timestamp": "2026-04-16T15:32:11.441Z",
  "session_id": "01HZ...",
  "project_path": "/Users/you/code/my-app"
}
```

## Claude Code log format

Sessions are stored as JSONL at:

```
~/.claude/projects/<project-hash>/<session-id>.jsonl
~/.claude/projects/<project-hash>/sessions/<session-id>.jsonl
```

Each line is one JSON event with fields like `type`, `role`, `content`, and `timestamp`. The parser tolerates variations in shape and extracts assistant text from both string and content-block payloads.

## Development

```bash
npm run dev      # tsc --watch
npm run build    # compile to dist/
npm start        # run the compiled server over stdio
```

## License

MIT — see [LICENSE](https://github.com/rahuljava2807/claude-bridge-mcp/blob/HEAD/LICENSE).