Esta é a afirmação principal e é defensável hoje contra comprometimento de agente, injeção de prompt, roubo de logs e exfiltração de habilidades.
Leia [docs/THREAT-MODEL.md](https://github.com/rohansx/wardn/blob/HEAD/docs/THREAT-MODEL.md) para a divisão honesta entre o que é coberto e o que não é — incluindo o nível onde a afirmação mais forte de "comprometimento do host não vaza nada" se torna alcançável.

O próprio cofre (criptografado em repouso, chave derivada de senha) é um componente real e a razão pela qual o firewall pode ser executado em uma única máquina. O próximo nível [docs/HOSTED-TIER.md](https://github.com/rohansx/wardn/blob/HEAD/docs/HOSTED-TIER.md) adicionalmente envolve o proxy em um enclave de computação confidencial para que mesmo um VPS totalmente comprometido não possa ler a chave.

[![Crates.io](https://img.shields.io/crates/v/wardn.svg)](https://crates.io/crates/wardn)
[![License](https://img.shields.io/crates/l/wardn.svg)](LICENSE)

## O Problema

Todo framework de agente de IA hoje armazena chaves de API em variáveis de ambiente ou arquivos `.env`. Um agente comprometido, habilidade maliciosa, ladrão comum ou injeção de prompt exfiltrado `Authorization: Bearer sk-...` de um log de LLM obtém acesso total às suas credenciais.```
~/.env              → OPENAI_KEY=sk-proj-real-key      # plaintext, readable by anyone
agent context       → "Use OPENAI_KEY=sk-proj-real-key" # leaked into LLM context window
agent logs          → Authorization: Bearer sk-proj-... # sitting in log files

## Arquitetura```mermaid
flowchart TB
    subgraph Agent["AI Agent Process"]
        A1["Agent Code"]
        A2["ENV: OPENAI_KEY=wdn_placeholder_a1b2..."]
    end

    subgraph Wardn["wardn daemon · localhost:7777"]
        direction TB
        P["HTTP Proxy"]
        MCP["MCP Server\n(stdio)"]

        subgraph Pipeline["Request Pipeline"]
            direction LR
            S1["Identify\nAgent"] --> S2["Resolve\nPlaceholder"] --> S3["Check\nAuth"] --> S4["Rate\nLimit"] --> S5["Inject\nReal Key"]
        end

        subgraph ResponsePipeline["Response Pipeline"]
            direction RL
            R1["Strip Real\nKeys"] --> R2["Replace with\nPlaceholders"]
        end

        subgraph Vault["Encrypted Vault"]
            V1["AES-256-GCM"]
            V2["Argon2id KDF"]
            V3["Placeholder Map\nper agent × credential"]
        end
    end

    subgraph External["External APIs"]
        E1["api.openai.com"]
        E2["api.anthropic.com"]
        E3["..."]
    end

    A1 -- "placeholder token\nin headers/body" --> P
    A1 -. "MCP: get_credential_ref\nlist_credentials\ncheck_rate_limit" .-> MCP
    MCP -. "placeholder token\n(never real keys)" .-> A1
    P --> Pipeline
    Pipeline --> External
    External --> ResponsePipeline
    ResponsePipeline -- "response with\nplaceholders only" --> A1
    Pipeline <--> Vault
    ResponsePipeline <--> Vault

    style Agent fill:#1a1a2e,stroke:#e94560,color:#fff
    style Wardn fill:#0f3460,stroke:#16213e,color:#fff
    style Pipeline fill:#16213e,stroke:#e94560,color:#fff
    style ResponsePipeline fill:#16213e,stroke:#e94560,color:#fff
    style Vault fill:#1a1a2e,stroke:#00d2ff,color:#fff
    style External fill:#0a0a0a,stroke:#533483,color:#fff

## Demonstração

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/12823/1fa6109ffd855ec98c173c5edd2d7ee77f6b0c918a3cdecb1ea5fbfe8326161d.gif" alt="wardn demonstração" width="800">
</p>

## Níveis de Confiança, Honestos

| Nível | Onde | O que garante |
|---|---|---|
| **Auto-hospedado (hoje)** | seu laptop, seu VPS, CI | Cofre criptografado em repouso, alegação de firewall contra agentes. **Não** defende contra root no host. |
| **Hospedado (em breve)** | gerenciado pela wardn ou BYO-cloud | Enclave de computação confidencial (Nitro / SEV-SNP) + atestação remota + fluxo de criptografia para o proxy. Alegação real de "comprometimento do host não vaza nada". |

O nível auto-hospedado é a alegação principal e é enviado hoje. O nível hospedado é o caminho de atualização estrito: custa dinheiro e complexidade operacional, e seu design está em [docs/HOSTED-TIER.md](https://github.com/rohansx/wardn/blob/HEAD/docs/HOSTED-TIER.md). Inventário completo e honesto do que é e não é coberto:

👉 **[docs/THREAT-MODEL.md](https://github.com/rohansx/wardn/blob/HEAD/docs/THREAT-MODEL.md)** — tabela de cobertura / não cobertura, "nenhum cofre de software elimina comprometimento do host" explicitamente destacado, e o caminho de atualização.

## Instalação```bash
# Prebuilt binary (Linux/macOS, amd64/arm64), checksum-verified
curl -sSf https://raw.githubusercontent.com/rohansx/wardn/main/install.sh | sh

# or from crates.io
cargo install wardn

# or Homebrew, once the tap is published (see Formula/wardn.rb)
brew install rohansx/wardn/wardn

Assim é. O Claude Code agora utiliza o servidor MCP do wardn para obter tokens de espaço reservado em vez de ler as chaves reais do seu ambiente.

### O que acontece a seguir

1. O Claude Code chama `get_credential_ref` → obtém `wdn_placeholder_a1b2...` (não a chave real)
2. O agente envia a requisição com o espaço reservado através do proxy wardn
3. O proxy troca o espaço reservado pela chave real, encaminha para a API
4. O proxy remove a chave real da resposta antes de devolvê-la ao agente

A chave real nunca entra na memória, logs ou contexto do LLM do agente.

## Painel Local

Assim que o daemon estiver ativo (`wardn serve`, ou iniciado por `wardn run`), abra
**http://127.0.0.1:7777/ui** num navegador. Uma visualização somente leitura e local de:

- **Credenciais** — cada credencial armazenada com suas ACLs (agentes permitidos,
  domínios permitidos, limites de taxa e distintivos de orçamento).
- **Atividade Recente** — os últimos 50 eventos de proxy com método, domínio,
  caminho, status, agente, request_id e custo registado (`request_completed`,
  `credential_injected`, `rate_limit`, `budget_exceeded`, `loop_detected`,
  `request_error`).
- **Orçamentos** — o orçamento configurado de cada credencial (máximo, gasto,
  restante, janela, modo) com uma barra de progresso que fica amarela → vermelha à medida que
  ultrapassa 50% / 80%.

Atualizado automaticamente a cada 2 s. Sem endpoints de mutação — a única forma
de sair do painel é pela própria API (`/api/summary`, `/api/credentials`,
`/api/audit?limit=N`, `/api/budgets`).```bash
# Static, anonymous, never sees real keys
curl http://127.0.0.1:7777/api/summary | jq

## Referência da CLI

### Gerenciamento de Vault```bash
wardn vault create                        # create encrypted vault
wardn vault set OPENAI_KEY                # store credential (prompts for value, no echo)
wardn vault get OPENAI_KEY                # get placeholder token (never the real value)
wardn vault get OPENAI_KEY --agent bot    # get placeholder for specific agent
wardn vault list                          # list all credentials
wardn vault rotate OPENAI_KEY             # rotate value, placeholders unchanged
wardn vault remove OPENAI_KEY             # remove credential

# Custom vault path
wardn --vault /path/to/vault.enc vault list

### Claude Code / Integração com Cursor```bash
wardn setup claude-code                   # register wardn as MCP server in Claude Code
wardn setup cursor                        # register wardn as MCP server in Cursor

# Or manually:
claude mcp add --transport stdio --scope user wardn -- wardn serve --mcp --agent claude-code

#### Ferramentas MCP disponíveis

| Ferramenta | O que retorna | Segurança |
|------|----------------|----------|
| `get_credential_ref` | Token temporário (`wdn_placeholder_...`) | Nunca o valor real |
| `list_credentials` | Nomes de credenciais + metadados | Filtrado pelo acesso do agente |
| `check_rate_limit` | Cota restante, informações de nova tentativa | Somente leitura |

### Migração de Credenciais```bash
wardn migrate --dry-run                             # audit Claude Code dir for exposed keys
wardn migrate --source claude-code                  # scan + migrate to vault
wardn migrate --source open-claw                    # scan OpenClaw config
wardn migrate --source directory --path ./my-proj   # scan any directory

Cada importador solicita a frase secreta do cofre no primeiro uso (ou a lê a partir de `WARDN_PASSPHRASE` / do chaveiro do SO). Os valores existentes são sobrescritos silenciosamente — o importador é apenas de valor, os metadados (agentes permitidos / domínios / limite de taxa / orçamento) são preservados.

### Automation

Para CI/scripts, defina as variáveis de ambiente `WARDN_PASSPHRASE` e `WARDN_VALUE` para ignorar prompts interativos:```bash
WARDN_PASSPHRASE=my-pass wardn vault list
WARDN_PASSPHRASE=my-pass WARDN_VALUE=sk-proj-xxx wardn vault set OPENAI_KEY

### Operações do Cofre```rust
use wardn::{Vault, config::CredentialConfig};

// Create an encrypted vault
let vault = Vault::create("vault.enc", "my-passphrase")?;

// Store a credential
vault.set_with_config("OPENAI_KEY", "sk-proj-real-key-123", &CredentialConfig {
    allowed_agents: vec!["researcher".into(), "writer".into()],
    allowed_domains: vec!["api.openai.com".into()],
    rate_limit: Some(RateLimitConfig { max_calls: 200, per: TimePeriod::Hour }),
})?;

// Agent gets a placeholder (not the real key)
let placeholder = vault.get_placeholder("OPENAI_KEY", "researcher")?;
// → "wdn_placeholder_a1b2c3d4e5f6g7h8"

// Rotate the real key — all placeholders keep working
vault.rotate("OPENAI_KEY", "sk-proj-new-key-456")?;

### MCP Server```rust
use wardn::mcp::WardenMcpServer;

// Serve over stdio (for Claude Code, Cursor, etc.)
WardenMcpServer::serve_stdio(vault, rate_limiter, "agent-id".into()).await?;

Defina `RUST_LOG=wardn=info` (ou `debug`/`trace`) para controlar a verbosidade. Os logs vão para stderr, nunca para stdout.

## Configuração```toml
[warden]
vault_path = "~/.vibeguard/vault.enc"

[warden.credentials.OPENAI_KEY]
rate_limit = { max_calls = 200, per = "hour" }
allowed_agents = ["researcher", "writer"]
allowed_domains = ["api.openai.com"]

[warden.credentials.ANTHROPIC_KEY]
rate_limit = { max_calls = 100, per = "hour" }
allowed_agents = ["researcher"]
allowed_domains = ["api.anthropic.com"]

## Desenvolvimento```bash
# Integration tests use a fast (insecure) KDF so the suite runs in
# milliseconds instead of paying the real Argon2id cost per test —
# always pass this feature flag when running tests locally or in CI:
cargo test --features test-fast-kdf

cargo build
cargo clippy --all-targets --features test-fast-kdf

subgraph KDF["Key Derivation"]
    Argon["Argon2id\nm=19456 t=2 p=1"]
end

subgraph Encrypt["Encryption"]
    AES["AES-256-GCM"]
    Nonce["Random Nonce\n(12 bytes)"]
end

subgraph Output["WDNV File"]
    direction TB
    Magic["WDNV (4B)"]
    Ver["Version (2B)"]
    SaltOut["Salt (16B)"]
    Payload["Nonce ‖ Ciphertext ‖ Tag"]
end

Pass --> Argon
Salt --> Argon
Argon -- "256-bit key" --> AES
Creds --> AES
Nonce --> AES
AES --> Payload

style Input fill:#1a1a2e,stroke:#e94560,color:#fff
style KDF fill:#16213e,stroke:#00d2ff,color:#fff
style Encrypt fill:#16213e,stroke:#00d2ff,color:#fff
style Output fill:#0f3460,stroke:#533483,color:#fff

### Formato do Arquivo```
Bytes 0-3:   Magic "WDNV"
Bytes 4-5:   Version (u16 LE)
Bytes 6-21:  Argon2id salt (16 bytes)
Bytes 22+:   AES-256-GCM encrypted payload (nonce ‖ ciphertext ‖ tag)