> For the complete documentation index, see [llms.txt](https://docs.rome.builders/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.rome.builders/pt-br/produtos/rome-cli.md).

# Rome CLI + MCP

A CLI de desenvolvedor da Rome e o servidor MCP — fatos fundamentados sobre a chain, o padrão de build correto e as ações exclusivas da Rome (fund, deploy, verify) para um humano ou um agente de IA.

`rome` acompanha um construtor — humano ou agente de IA — por todo o ciclo de build-on-Rome: fatos da cadeia fundamentados, o padrão certo, chamadas de contrato, a rampa de entrada de financiamento, deploy/send, diagnóstico entre VMs e um gate de funcionamento para ambas as vias. Um núcleo de capacidades, duas superfícies alinhadas — uma CLI (`rome <command>`) e um [MCP](https://modelcontextprotocol.io) servidor (`rome mcp`) — para que um agente e um humano compartilhem o mesmo modelo mental.

## Instalação

Prioridade ao repositório (publicação no npm pendente):

```bash
# uso único, sem instalação:
npx github:rome-protocol/rome-cli#v0.12.0 facts chain hadrian

# instalação duradoura — clone + link:
git clone --branch v0.12.0 https://github.com/rome-protocol/rome-cli
cd rome-cli && npm install && npm install -g .
```

Um simples `npm install -g github:rome-protocol/rome-cli` funciona **não** funciona hoje — o npm prepara as dependências git do pacote sem os próprios node\_modules ([rome-cli#25](https://github.com/rome-protocol/rome-cli/issues/25)). Use o npx de uso único ou clone + link, e fixe uma tag como acima: o npx mantém a cópia que buscou primeiro, então um `npx github:rome-protocol/rome-cli` pode continuar executando uma versão antiga, enquanto uma tag fixada sempre busca essa versão.

## Duas camadas sobre um núcleo

**Leituras — fundamentação + diagnóstico.** Sem chaves; tanto na CLI quanto no servidor MCP.

| Comando                                                  | O que retorna                                                                                                                               |
| -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| `rome facts chain·tokens·contracts·gas·balance·programs` | fatos ao vivo da cadeia vindos do registro + RPC — sem ids, endereços ou seletores alucinados                                               |
| `rome cookbook patterns·cpi-recipe·errors`               | qual exemplo se encaixa no seu objetivo · as regras de conta de CPI que os agentes erram · decodifique uma falha do Rome → causa + correção |
| `rome call <chain> <addr> <sig> [args]`                  | ler um contrato (`eth_call`) — argumentos de múltiplos valores vão separados por vírgula em um único argumento: `"0xOwner…,0xSpender…"`     |
| `rome doctor <chain>`                                    | pré-verificação — a cadeia está ativa? RPC acessível? programa configurado? carteira financiada?                                            |
| `rome tx <chain> <hash>`                                 | diagnosticar uma tx — recibo EVM + a(s) tx(s) de liquidação na Solana + um link Via (o Rome não tem `debug_traceTransaction`)               |
| `rome preset foundry\|hardhat <chain>`                   | uma configuração de rede Rome pronta para sua toolchain + as particularidades                                                               |

**Ações — assinar on-chain.** somente na CLI, chave do ambiente, **nunca** no MCP.

| Comando                                                                    | O que faz                                                                                                                                                                                                                                                                                                                                               |
| -------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `rome deploy <chain> <artifact>`                                           | implantar um contrato compilado, lidando com as peculiaridades de gas do Rome                                                                                                                                                                                                                                                                           |
| `rome send <chain> <addr> <sig>`                                           | escrever em um contrato pelo caminho de escrita correto do Rome                                                                                                                                                                                                                                                                                         |
| `rome fund <chain> --from <src> --amount <usdc>`                           | fazer bridge de USDC → gas do Rome (CCTP) — a rampa de entrada "from home"                                                                                                                                                                                                                                                                              |
| `rome bridge <chain> --from <src> --amount <usdc> [--intent gas\|wrapper]` | fazer bridge de USDC **em** como gas ou wUSDC                                                                                                                                                                                                                                                                                                           |
| `rome bridge <chain> --to <dest> --amount <usdc>`                          | fazer bridge de wUSDC **para fora** — queimar no Rome; você reivindica no destino (o Rome subsidia a entrada, não a reivindicação de saída)                                                                                                                                                                                                             |
| `rome activate <chain>`                                                    | financiamento opcional de PDA; fazer bridge para fora não precisa disso, porque o contrato de bridge (RomeBridgeWithdraw v12 e posteriores) paga o rent da mensagem e o cobra em gas                                                                                                                                                                    |
| `rome verify <chain> [--path …]`                                           | o **gate de funcionamento sensível ao caminho**, um para cada forma de entrada: `solidity` — o mesmo contrato responde na via EVM *e* a via Solana · `solana-program` — uma chamada na via EVM aciona seu programa Solana via CPI · `de origem` — fazer bridge para dentro → agir no Rome → fazer bridge para fora, o trajeto de ida e volta comprovado |

## Conecte isso a um agente de IA (MCP)

Você não executa nem hospeda nada — seu cliente MCP inicia `rome mcp` (um servidor stdio) sob demanda. Registre-o uma vez:

```json
{ "mcpServers": { "rome": { "command": "npx", "args": ["-y", "github:rome-protocol/rome-cli#v0.12.0", "mcp"] } } }
```

(Com a instalação clone + link, `{ "command": "rome", "args": ["mcp"] }` também funciona — a forma com npx só não precisa de instalação prévia.)

O agente então chama ferramentas como `facts_chain`, `cookbook_cpi_recipe`, `doctor`, `tx`, e `preset` — fundamentado no registro ao vivo + RPC, então ele para de adivinhar endereços e seletores. A superfície MCP é **somente leitura e não contém chaves** — seguro para conectar a qualquer agente; ele nunca pode assinar nem mover fundos. As ações de assinatura ficam na CLI, com a chave fornecida pelo ambiente.

## O ciclo de fundamentação do agente

1. `rome cookbook patterns <o que estou construindo>` → qual repositório de exemplo + arquitetura
2. `rome facts chain <chain>` → RPC, id do programa, token de gas (sem hardcoding)
3. …escreva código usando exatamente esses valores…
4. `rome verify <chain> --path <your way in>` → prove que funciona, independentemente do caminho por onde você entrou

## Saiba mais

* Repositório + guias completos: [`rome-protocol/rome-cli`](https://github.com/rome-protocol/rome-cli)
* [Ecossistema e repositórios](https://docs.rome.builders/pt-br/primeiros-passos-1/ecosystem.md) · [Construir um app de duas vias](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/dual-lane-app.md) · [De casa: alcance o Rome a partir de outra cadeia](https://docs.rome.builders/pt-br/guias-do-desenvolvedor/from-home.md)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.rome.builders/pt-br/produtos/rome-cli.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
