Bomber MCP preview
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.

    Version

    Version 0.2.3 @ (Codeberg)

      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` 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` 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
      For AI Agents