AI Automation
Bomber MCP

Use Model Context Protocol-powered automation to help agents create, update, and maintain Atomic Design-compliant components, hooks, features, domains, and app structures.

Explore Bomber
View on CodeBerg
Bomber MCP preview
Atomic Bomb

Bomber MCP

Bomber MCP Provides AI-driven code generation and project automation through the Model Context Protocol, enabling agents to create, modify, and maintain Atomic Design-compliant components, features, hooks, domains, and application structures.

Bomber is written in Rust and executes the

atomic-bomb
NPM package, which serves as the core engine for processing MCP requests and generating code based on the provided context and instructions.

Hosted on my Codeberg Repo: https://codeberg.org/ReneKrewinkel/bomber
Just download, compile and run it!

number-1

Define Context and Instructions

Agents provide Bomber MCP with a structured context and specific instructions for the desired code generation or modification tasks.

number-2

Process MCP Requests

Bomber MCP processes the incoming MCP requests using the atomic-bomb NPM package, which generates code based on the provided context and instructions.

number-3

Generate and Maintain Code

Bomber MCP generates new code or modifies existing code to create, update, and maintain Atomic Design-compliant components, features, hooks, domains, and application structures.

Features

Written in Rust, Bomber MCP executes the atomic-bomb NPM package, which serves as the core engine for processing MCP requests and generating code based on the provided context and instructions.

    It runs this command from the project root path supplied by the agent:

    Shell
    npx atomic-bomb --type <TYPE> --name <NAME> [--for <NAME>]

    Build

    Shell
    cargo build --release

    The compiled server binary will be available at:

    TEXT
    target/release/bomber

    Run

    Shell
    target/release/bomber

    Bomber writes a trace log for each received MCP request to stdout.

    By default, Bomber listens on:

    TEXT
    http://127.0.0.1:3042

    Endpoints:

    • GET /health
      : health check.
    • GET /
      : health check with endpoint discovery.
    • POST /mcp
      : JSON-RPC MCP endpoint.

    Agent Configuration

    Configure the AI agent to connect to Bomber as an HTTP MCP server:

    JSON
    {
    "mcpServers": {
    "bomber": {
    "url": "http://127.0.0.1:3042/mcp"
    }
    }
    }

    The agent must provide the project root path in every

    atomic_bomb
    tool call.

    App Configuration

    Bomber uses [

    app_config
    ](https://codeberg.org/ReneKrewinkel/app_config) for optional TOML configuration.

    Preferred config file:

    TEXT
    ~/.config/bomber/config.toml

    If that file does not exist, Bomber falls back to the other paths supported by

    app_config
    , including:

    TEXT
    ~/.bomber/config.toml

    Example config:

    TOML
    [server]
    host = "127.0.0.1"
    port = 3042

    [atomic_bomb]
    command = "npx"
    package = "atomic-bomb"

    All fields are optional.

    • server.host
      : HTTP bind host. Defaults to
      127.0.0.1
      .
    • server.port
      : HTTP bind port. Defaults to
      3042
      .
    • atomic_bomb.command
      : executable to run. Defaults to
      npx
      .
    • atomic_bomb.package
      : first argument passed to the command. Defaults to
      atomic-bomb
      .

    The project root is intentionally not read from config. It must be supplied by the agent for each tool call.

    For simple configs, top-level keys are also accepted:

    TOML
    host = "127.0.0.1"
    port = 3042
    command = "npx"
    package = "atomic-bomb"

    App Info

    Bomber uses [

    app_info
    ](https://codeberg.org/ReneKrewinkel/app_info) as its application metadata starter. The MCP
    initialize
    response is populated from Cargo package metadata through
    app_info::get_metadata!()
    .

    At startup,

    app_info::show!()
    prints application metadata, and MCP request tracing is written to stdout.

    Tool

    The server exposes one tool:

    TEXT
    atomic_bomb

    Input

    Tool arguments:

    JSON
    {
    "project_root": "/absolute/path/to/project/root",
    "type": "component",
    "name": "Button",
    "for": "BaseButton"
    }

    Full MCP request:

    JSON
    {
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tools/call",
    "params": {
    "name": "atomic_bomb",
    "arguments": {
    "project_root": "/absolute/path/to/project/root",
    "type": "component",
    "name": "Button",
    "for": "BaseButton"
    }
    }
    }

    Fields:

    • project_root
      : project root path where
      atomic-bomb
      should run.
    • type
      : passed to
      atomic-bomb
      as
      --type
      .
    • name
      : passed to
      atomic-bomb
      as
      --name
      .
    • for
      : optional target name passed to
      atomic-bomb
      as
      --for
      .

    project_root
    ,
    type
    , and
    name
    are required strings and must not be empty.
    for
    is optional, but must be a non-empty string when provided.

    Agent Call

    An AI agent should call the MCP tool named

    atomic_bomb
    with
    project_root
    ,
    type
    , and
    name
    arguments, and may include
    for
    . The server changes into
    project_root
    and executes:

    Shell
    npx atomic-bomb --type component --name Button --for BaseButton

    The command is executed without a shell, so argument values are passed directly to

    npx
    .

    HTTP Examples

    Initialize:

    Shell
    curl -sS http://127.0.0.1:3042/mcp \
    -H 'Content-Type: application/json' \
    -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}'

    List tools:

    Shell
    curl -sS http://127.0.0.1:3042/mcp \
    -H 'Content-Type: application/json' \
    -d '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}'

    Call the tool:

    Shell
    curl -sS http://127.0.0.1:3042/mcp \
    -H 'Content-Type: application/json' \
    -d '{
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tools/call",
    "params": {
    "name": "atomic_bomb",
    "arguments": {
    "project_root": "/absolute/path/to/project/root",
    "type": "component",
    "name": "Button",
    "for": "BaseButton"
    }
    }
    }'

    Result

    On success, the tool returns MCP text content containing stdout and stderr from

    atomic-bomb
    .

    Example successful result text:

    TEXT
    stdout:
    Created component Button

    If

    atomic-bomb
    exits with a non-zero status, the MCP tool response is marked with
    isError: true
    and includes the exit status plus captured stdout/stderr.

    Requirements

    • Rust toolchain for building this server.
    • Node.js and
      npx
      available on
      PATH
      when the server runs.
    • Network access or a local npm cache if
      npx
      needs to download
      atomic-bomb
      .
    • Optional config at
      ~/.config/bomber/config.toml
      .

    Protocol Support

    This server implements JSON-RPC MCP requests over HTTP:

    • initialize
    • notifications/initialized
    • tools/list
    • tools/call

    Requests go to

    POST /mcp
    with an
    application/json
    body. Notifications return
    202 Accepted
    with an empty body.

    Atomic Bomb | René Krewinkel
    Made with ❤ by René Krewinkel
    https://krewinkel.studio

    Copyright © René Krewinkel - 2024 - 2026