Skip to main content
Glama

Bike MCP Server

MCP (Model Context Protocol) server for Bike outliner app on macOS.

Features

Reading

  • bike_list_documents - List all open documents

  • bike_get_document_outline - Read document structure (supports max_depth)

  • bike_query_rows - Search rows using Bike's outline path syntax

Writing

  • bike_create_document - Create new documents with optional structure

  • bike_create_rows - Add rows with nested children and positioning

  • bike_update_row - Edit row content and type (batch support)

  • bike_delete_row - Remove rows (batch support)

  • bike_group_rows - Group/move multiple rows under a parent

Related MCP server: MCP Mac Apps Server

Requirements

  • macOS (uses AppleScript)

  • Node.js 18+

  • Bike app installed

Installation

  1. Download bike-mcp-server.mcpb from releases

  2. Double-click the file to open with Claude Desktop

  3. Click Install

From source

cd bike-mcp-server
npm install
npm run build

Usage with Claude Desktop

Add to your Claude Desktop config file (~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "bike": {
      "command": "node",
      "args": ["/path/to/bike-mcp-server/dist/index.js"]
    }
  }
}

Then restart Claude Desktop.

Development

# Watch mode for development
npm run dev

# Build
npm run build

# Run directly
npm start

How It Works

The server communicates with Bike via AppleScript, using the osascript command. All operations require Bike to be running with a document open.

The outline structure is returned as human-readable indented text:

My Document (doc:abc123)

- First item [row:row-1]
  - Sub-item [row:row-1-1]
- Second item [row:row-2]

Example Prompts

Here are some prompts you can use with Claude Desktop:

  1. Explore your outlines: "List my open Bike documents and show me the outline of the first one"

  2. Create structured content: "Create a new Bike document with a project plan that has 3 main phases, each with 2-3 tasks"

  3. Search and transform: "Find all rows containing 'TODO' in my Bike document and convert them to task items"

Testing

No account or authentication required. To test the server:

  1. Open Bike app on macOS

  2. Create or open a document with some sample content

  3. Use Claude Desktop to interact with your outlines

Privacy

This server does not collect, store, or transmit any personal data. All communication happens locally between Claude Desktop and the Bike app via AppleScript. No data leaves your machine.

Support

License

MIT

Available Tools

8 tools
bike_create_documentCreate Bike DocumentA

Creates a new document in Bike, optionally with an outline structure.

Args:

  • structure (array, optional): Outline structure to populate the document. Each node can have:

    • name (string): Text content (may contain HTML if html=true)

    • type (string, optional): Row type (body, heading, task, code, quote, note, unordered, ordered, hr)

    • children (array, optional): Nested child nodes If not provided, creates an empty document.

  • html (boolean, optional): If true, name fields may contain HTML formatting: , , , , ,

Returns: Document info: "Untitled (doc:XXX)"

Examples:

  • Empty doc: bike_create_document({})

  • With structure: bike_create_document({ structure: [ { name: "Project", type: "heading", children: [ { name: "Task 1", type: "task" }, { name: "Task 2", type: "task" } ]} ] })

  • With HTML: bike_create_document({ structure: [{ name: "Click <a href="https://example.com">here" }], html: true })

Errors:

  • "Bike is not running" - Open Bike app first

Inputs: html, structure.

bike_create_rowsCreate Bike RowsA

Creates one or more rows with optional nested structure.

Args:

  • structure (array, required): Array of rows to create. Each can have:

    • name (string): Text content (may contain HTML if html=true)

    • type (string, optional): Row type (body, heading, task, code, quote, note, unordered, ordered, hr)

    • children (array, optional): Nested child rows

  • parent_id (string, optional): Parent row ID. If not provided, adds to root.

  • position (string, optional): Where to insert - 'first', 'last' (default), 'before', 'after'

  • reference_id (string, optional): Required for 'before'/'after' positioning.

  • html (boolean, optional): If true, name fields may contain HTML formatting: , , , , ,

Returns: Confirmation: "Created N row(s)"

Examples:

  • Single row: bike_create_rows({ structure: [{ name: "New item" }] })

  • With type: bike_create_rows({ structure: [{ name: "Task", type: "task" }] })

  • Nested: bike_create_rows({ structure: [ { name: "Parent", children: [{ name: "Child" }] } ] })

  • At position: bike_create_rows({ structure: [{ name: "First!" }], position: "first" })

  • Before row: bike_create_rows({ structure: [{ name: "Before X" }], position: "before", reference_id: "Kx9" })

  • With HTML: bike_create_rows({ structure: [{ name: "Click <a href="https://example.com">here" }], html: true })

Errors:

  • "Bike is not running" - Open Bike app first

  • "No document is open" - Open a document first

  • "reference_id is required" - When using before/after without reference_id

Inputs: structure (required), html, position, parent_id, +1 more.

bike_delete_rowDelete Bike RowsA
Destructive

Deletes one or more rows from the document.

WARNING: This is a destructive operation. Deleted rows and all their children will be permanently removed. This action cannot be undone via the MCP server (though Bike's undo may work if used immediately).

Args:

  • row_ids (string[], required): Array of row IDs to delete.

Returns: Confirmation with count: "Deleted 3 row(s)"

Examples:

  • Delete one row: bike_delete_row({ row_ids: ["Kx9"] })

  • Delete multiple: bike_delete_row({ row_ids: ["Kx9", "Lm2", "Np4"] })

Errors:

  • "Bike is not running" - Open Bike app first

  • "No document is open" - Open a document first

Inputs: row_ids (required).

bike_get_document_outlineGet Bike Document OutlineA
Read-onlyIdempotent

Retrieves the complete outline structure of the currently open Bike document.

Returns a hierarchical tree of rows with their IDs, text content, and children. Bike must be running with a document open for this tool to work.

Args:

  • max_depth (number, optional): Maximum depth of the outline tree to return. If not specified, returns the complete tree.

Returns: Human-readable indented outline with IDs:

Document Name (doc:root-id)

  • First item [row:Kx9]

    • Sub-item 1 [row:Lm2]

    • Sub-item 2 [row:Np4]

  • Second item [row:Qr7]

Examples:

  • Get full outline: bike_get_document_outline({})

  • Get only 2 levels deep: bike_get_document_outline({ max_depth: 2 })

Errors:

  • "Bike is not running" - Open Bike app first

  • "No document is open" - Open a document in Bike first

Inputs: max_depth.

bike_group_rowsGroup RowsA

Groups multiple rows under a new or existing parent row.

Two modes:

  1. Create new group: Provide group_name to create a new parent row and move specified rows into it. By default, the group is created in-place (before the first row being grouped).

  2. Move to existing: Provide parent_id to move rows into an existing row.

Use position ('first'/'last' for root, 'before'/'after' with reference_id) to override placement.

Inputs: row_ids (required), position, parent_id, group_name, +1 more.

bike_list_documentsList Bike DocumentsA
Read-onlyIdempotent

Lists all open documents in Bike.

Returns a list of all currently open documents with their names and IDs. The active (front) document is marked with an asterisk (*). Bike must be running for this tool to work.

Args: None

Returns: List of documents, one per line (active marked with *):

  • Active Document (doc:abc123) Other Document (doc:def456)

Examples:

  • List all open docs: bike_list_documents({})

Errors:

  • "Bike is not running" - Open Bike app first

  • "No documents open" - No documents are currently open

Inputs: no named parameters.

bike_query_rowsQuery Bike RowsA
Read-onlyIdempotent

Search for rows using Bike's outline path syntax.

Outline paths are powerful queries for filtering rows:

  • /project → Top-level rows containing "project"

  • //task → All rows of type "task" (anywhere)

  • //@done → Rows with @done attribute

  • //heading → All heading rows

  • /a/b → "b" rows inside "a" rows

  • /a union /b → Rows matching "a" OR "b"

  • /a intersect /b → Rows matching "a" AND "b"

Args:

  • outline_path (string, required): The outline path query.

Returns: Matching rows formatted as:

  • Row text [row:XXX]

Or scalar result (count, boolean, text) depending on the query.

Examples:

  • Find all tasks: bike_query_rows({ outline_path: "//task" })

  • Find headings: bike_query_rows({ outline_path: "//heading" })

  • Find by text: bike_query_rows({ outline_path: "//project" })

  • Find with attribute: bike_query_rows({ outline_path: "//@done" })

Errors:

  • "Bike is not running" - Open Bike app first

  • "No document is open" - Open a document first

Inputs: outline_path (required).

bike_update_rowUpdate Bike RowsA
Idempotent

Updates one or more rows' text content and/or type.

Args:

  • updates (array, required): Array of row updates. Each update has:

    • row_id (string, required): ID of the row to update

    • name (string, optional): New text content (may contain HTML if html=true)

    • type (string, optional): New row type (body, heading, quote, code, note, unordered, ordered, task, hr)

    • html (boolean, optional): If true, name contains HTML formatting: , , , , , NOTE: HTML updates recreate the row, so the row ID will change. Children are preserved. If you need the new ID, call bike_get_document_outline after.

Returns: Confirmation: "Updated N row(s)"

Examples:

  • Single update: bike_update_row({ updates: [{ row_id: "Kx9", name: "New text" }] })

  • Batch to task: bike_update_row({ updates: [ { row_id: "A1", type: "task" }, { row_id: "B2", type: "task" }, { row_id: "C3", type: "task" } ] })

  • Mixed: bike_update_row({ updates: [ { row_id: "X", name: "Title", type: "heading" }, { row_id: "Y", type: "task" } ] })

  • With HTML: bike_update_row({ updates: [ { row_id: "Z", name: "Important task", html: true } ] })

Errors:

  • "Bike is not running" - Open Bike app first

  • "No document is open" - Open a document first

  • "At least one of 'name' or 'type' must be provided" - Per row

Inputs: updates (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.5/5.0

    Scored across 8 tools

    Disambiguation5/5

    Each tool targets a distinct operation: listing documents, retrieving outlines, creating documents, creating rows, grouping rows, updating rows, deleting rows, and querying. Even though create_document and create_rows both create structure, they operate at different levels (document vs. rows within a document), avoiding ambiguity.

    Naming Consistency5/5

    All tools follow the pattern 'bike_<verb>_<noun>' using imperative verbs (list, get, create, group, update, delete, query). The naming is uniform and predictable, with only minor plural/singular variation that does not hinder understanding.

    Tool Count5/5

    With 8 tools, the server is well-scoped for a focused outlining application. Each tool addresses a core functionality without unnecessary bloat, and the count feels natural for the domain.

    Completeness4/5

    The tool set covers essential CRUD operations for rows (create, read via outline/query, update, delete) and document lifecycle (create, list). Missing operations like explicit row reordering or document closing are minor and can be worked around via existing tools, making the surface largely complete.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers