proof-of-commitment

Protocolo criptográfico de prova de compromisso para MCP. Faça compromissos verificáveis antes de publicar/agir, prevenindo mudanças narrativas posteriores.

GitHub

Experimente este MCPPatrocinado

Documentação

Prova de Comprometimento

Estrelas mentem. Sinais comportamentais não.

Um servidor MCP e ferramenta web que avalia pacotes npm, pacotes PyPI, crates Rust, módulos Go e repositórios GitHub quanto ao comprometimento comportamental — sinais mais difíceis de falsificar do que estrelas, READMEs ou contagens de downloads.

$ npx proof-of-commitment axios zod chalk lodash minimatch
Scoring 5 npm packages... done in 3.0s

Package      Risk          Score   Publishers   Downloads      Age    Provenance
chalk        🔴 CRITICAL   72      1            432.9M/wk      14.6y  —
minimatch    🔴 CRITICAL   78      1            634.1M/wk      14.9y  —
lodash       🔴 CRITICAL   80      1            158.9M/wk      14.1y  —
zod          🔴 CRITICAL   83      1            161.2M/wk      6.3y   🔐 verified
axios        🔴 CRITICAL   88      1            115.7M/wk      11.8y  🔐 verified
                ⚠ COMPROMISED — axios token theft (2026-03-30)

⚠  5 CRITICAL packages found.
   CRITICAL = sole npm publisher + >10M weekly downloads (publish-access concentration risk)

npm audit não sinaliza nenhum destes. Eles não são vulnerabilidades — são concentração de superfície de ataque. Um token npm roubado, um mantenedor alvo de phishing, e um único push alcança todo o ecossistema (axios, 30 de março de 2026 — aconteceu).

O problema da cadeia de suprimentos

26 dos 91 pacotes npm com mais de 10M de downloads semanais têm um único publicador npm. Juntos, eles respondem por mais de 3 bilhões de downloads por semana. npm audit não expõe isso. Estrelas também não.

Quatro pacotes em um projeto Node.js típico estão CRÍTICOS agora:

chalk — 432M downloads/semana, 1 publicador npm
zod — 185M downloads/semana, 1 publicador npm (30+ contribuidores GitHub)
lodash — 156M downloads/semana, 1 publicador npm
axios — 113M downloads/semana, 1 publicador npm (atacado em 30 de março de 2026)

Eles não aparecerão no seu package.json também — mas estes estão em quase todos os projetos:

minimatch — 625M downloads/semana, 1 publicador npm
glob — 366M downloads/semana, 1 publicador npm
cross-spawn — 215M downloads/semana, 1 publicador npm

Sinais comportamentais expõem isso. Estrelas e READMEs não.

Instalação rápida (MCP)

Sem necessidade de login. Adicione a qualquer ferramenta de IA compatível com MCP e comece a consultar risco na cadeia de suprimentos.

Claude Desktop

Abra ~/Library/Application Support/Claude/claude_desktop_config.json no macOS (referência do arquivo de configuração) ou %APPDATA%\Claude\claude_desktop_config.json no Windows, então adicione:

{
  "mcpServers": {
    "commit": {
      "type": "streamable-http",
      "url": "https://poc-backend.amdal-dev.workers.dev/mcp"
    }
  }
}

Reinicie o Claude Desktop. Um ícone de ferramenta aparece na entrada de chat — peça para auditar seu package.json.

Cursor

Abra ~/.cursor/mcp.json (documentação MCP do Cursor) e adicione:

{
  "mcpServers": {
    "commit": {
      "type": "streamable-http",
      "url": "https://poc-backend.amdal-dev.workers.dev/mcp"
    }
  }
}

Smithery (após indexação)

npx -y @smithery/cli install proof-of-commitment --client claude

Experimente agora

Terminal (instalação zero):

# New in v1.8.0: zero-arg auto-detect — cd into any project, run once:
npx proof-of-commitment
# Picks the highest-coverage manifest in cwd (package-lock.json > yarn.lock >
# pnpm-lock.yaml > pnpm-workspace.yaml > package.json; requirements.txt;
# Cargo.toml; go.sum > go.mod). When multiple ecosystems are present, the
# file with the most recent mtime wins.

# Explicit package list still works:
npx proof-of-commitment axios zod chalk

# Or point at a specific file:
npx proof-of-commitment --file package.json
npx proof-of-commitment --file package-lock.json   # npm (transitive)
npx proof-of-commitment --file yarn.lock           # yarn
npx proof-of-commitment --file pnpm-lock.yaml      # pnpm
npx proof-of-commitment --file pnpm-workspace.yaml # pnpm monorepo
npx proof-of-commitment --pypi litellm langchain requests
npx proof-of-commitment --cargo serde tokio reqwest
npx proof-of-commitment --golang github.com/gin-gonic/gin golang.org/x/net
npx proof-of-commitment --file go.mod
npx proof-of-commitment --file go.sum              # full transitive Go set

# JSON output for downstream tools:
npx proof-of-commitment --file package-lock.json --json | jq '.criticalCount'

Integração com CI (v1.8.0+)

--fail-on=<level> transforma o CLI em um portão de CI de uma linha. Nenhuma GitHub Action necessária.

# .github/workflows/supply-chain.yml
name: Supply Chain
on: [pull_request]
jobs:
  audit:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: '20' }
      - run: npx -y proof-of-commitment --fail-on=critical

Níveis:

`--fail-on`	Saída 1 quando…
`critical`	qualquer pacote é sinalizado CRÍTICO (concentração de acesso de publicação)
`risky`	qualquer pacote é CRÍTICO ou ALTO (pontuação < 40)
`none`	nunca — apenas relatório

Padrões: critical em CI (quando CI=true está definido, o que todo runner de CI importante faz) e para saída --json. Interativo (TTY, não-CI) mantém o padrão v1.7 de saída 0 — executar localmente não quebrará seus hábitos de shell.

A piiiico/commit-action@v1 dedicada ainda é a escolha certa quando você quer comentários em PR e resumos de etapas; --fail-on é para pipelines mínimos que só precisam de uma resposta sim/não.

Saída SARIF para GitHub Code Scanning (v1.26.0+)

--sarif gera SARIF 2.1.0 — o formato padrão para resultados de análise estática. Envie para o GitHub Code Scanning e os achados do Commit aparecem na aba Segurança junto com CodeQL e Snyk.

# .github/workflows/supply-chain.yml
name: Supply Chain
on: [pull_request]
jobs:
  audit:
    runs-on: ubuntu-latest
    permissions:
      security-events: write
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: '20' }
      - run: npx -y proof-of-commitment --file package-lock.json --sarif --fail-on=none > results.sarif
      - uses: github/codeql-action/upload-sarif@v3
        if: always()
        with:
          sarif_file: results.sarif
          category: commit-supply-chain

Pacotes CRÍTICOS e ALTOS aparecem como alertas na aba Segurança do repositório. Pacotes comprometidos (no registro de incidentes do Commit) recebem um alerta separado. --fail-on ainda controla o código de saída independentemente — use --fail-on=critical para também bloquear o PR.

Demonstração web (sem instalação): getcommit.dev/audit — cole seus pacotes, veja pontuações de risco em segundos.

Hooks de IDE (Cursor + Claude Code + Windsurf)

poc hook instala um portão de cadeia de suprimentos para Cursor (beforeShellExecution), Claude Code (PreToolUse) e Windsurf (pre_run_command) em um único comando. O mesmo script de hook intercepta instalações de pacotes de qualquer agente, detecta automaticamente qual cliente o chamou e bloqueia pacotes CRÍTICOS antes que eles sejam executados.

# Install for the current project (writes .cursor/hooks.json + .claude/settings.json + .windsurf/hooks.json):
poc hook

# Or protect every project for your user:
poc hook --global

# Narrow to one client:
poc hook --cursor          # only .cursor/hooks.json
poc hook --claude-code     # only .claude/settings.json
poc hook --windsurf        # only .windsurf/hooks.json

# Remove (cleans all three):
poc hook --uninstall

O hook escreve .cursor/hooks.json, .claude/settings.json e .windsurf/hooks.json (projeto) ou os equivalentes sob ~/ (com --global). Quando Cursor, Claude Code ou Windsurf executa npm install axios, pip install litellm, cargo add serde ou go get github.com/gin-gonic/gin, o hook chama a API do Commit e bloqueia, avisa ou permite — em menos de 500ms.

O que é interceptado:

Gerenciador de pacotes	Comando de exemplo
npm / npx	`npm install <pkg>`, `npm add <pkg>`
pnpm	`pnpm add <pkg>`
yarn	`yarn add <pkg>`
pip / pip3 / uv	`pip install <pkg>`
cargo	`cargo add <pkg>`, `cargo install <pkg>`
go	`go get <module>`, `go install <module>`

Por que isso importa: Ataques à cadeia de suprimentos agora acontecem em minutos. O worm Shai-Hulud (maio de 2026) comprometeu 637 pacotes em 39 minutos e visou especificamente assistentes de codificação de IA — plantando hooks de persistência em .claude/settings.json e .vscode/tasks.json. Quando seu assistente de IA instala uma dependência, ele ignora a revisão humana que costumava ser a última linha de defesa. poc hook coloca um portão de volta — o mesmo portão, seja Cursor, Claude Code ou Windsurf dirigindo.

Comportamento padrão: Pacotes CRÍTICOS (único publicador npm + >10M downloads/semana — o perfil exato do ataque LiteLLM/axios) são bloqueados. Pacotes ALTOS acionam um prompt "perguntar ao usuário" (Cursor/Claude Code) ou são bloqueados com uma mensagem (Windsurf). Defina COMMIT_HOOK_SEVERITY_BLOCK=HIGH para bloquear ambos.

Com uma chave de API: poc login sk_commit_… antes de executar poc hook — a chave é incorporada na configuração do hook e remove o limite de taxa.

Seja notificado antes do próximo ataque

O CLI informa o que está arriscado hoje. Uma chave de API gratuita desbloqueia monitoramento — recálculo de pontuação nos pacotes dos quais você depende, com alertas quando um degrada (queda de publicador, parada de lançamentos, queda de pontuação ≥10 pontos).

Aberto (gratuito): Monitore 3 pacotes · resumo semanal toda segunda-feira
Desenvolvedor ($15/mês): Monitore 15 pacotes · varreduras diárias · alertas de e-mail instantâneos

Obtenha uma chave de API gratuita → (sem cartão, 30 segundos · 200 auditorias/dia incluídas)

npm install -g proof-of-commitment   # then:
poc watch axios --email you@company.com  # free key + monitoring in one step
poc watch chalk                          # add more packages (3 free)
poc init                                 # add CI gate to this repo

GitHub Action

Adicione auditoria de cadeia de suprimentos a qualquer pipeline de CI em 30 segundos — detecta automaticamente pacotes de package.json ou requirements.txt, publica resultados como comentário no PR, escreve no GitHub Step Summary e opcionalmente falha em pacotes CRÍTICOS.

Use a action dedicada em piiiico/commit-action:

# .github/workflows/supply-chain.yml
name: Supply Chain Audit
on:
  pull_request:
    paths: ['package.json', 'package-lock.json', 'bun.lock']

jobs:
  audit:
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write
    steps:
      - uses: actions/checkout@v4
      - uses: piiiico/commit-action@v1
        with:
          fail-on-critical: true   # blocks merges on CRITICAL packages
          comment-on-pr: true      # posts results as a PR comment

Quando comment-on-pr: true (padrão), a action automaticamente publica a tabela de auditoria como um comentário no pull request — e atualiza o mesmo comentário em re-execução, para que você não receba spam de comentários. Revisores veem a tabela de risco sem sair do PR.

Entradas:

Entrada	Padrão	Descrição
`packages`	(automático)	Nomes de pacotes separados por vírgula (detectados automaticamente de `package.json`/`requirements.txt` se não definido)
`packages-file`	(automático)	Caminho para `package.json` ou `requirements.txt` (padrão: detecção automática na raiz do workspace)
`fail-on-critical`	`true`	Falhar o workflow se pacotes CRÍTICOS forem encontrados
`max-packages`	`20`	Máximo de pacotes para auditar ao detectar automaticamente
`include-dev-dependencies`	`false`	Incluir `devDependencies` de `package.json`
`comment-on-pr`	`true`	Publicar resultados de auditoria como comentário no PR (requer permissão `pull-requests: write`)
`api-key`	(nenhum)	Chave de API Commit Pro — permite solicitações em lote e 10K solicitações/mês
`api-url`	(prod)	Substituir endpoint da API (útil para auto-hospedagem)

Saídas: has-critical, critical-count, audit-summary (tabela markdown, também escrita no Step Summary).

Gratuito vs Pro: Sem uma chave de API, os pacotes são auditados um de cada vez (com atrasos para respeitar limites de taxa). Com uma chave de API Pro, todos os pacotes são auditados em uma única solicitação em lote — mais rápido e com limites mensais mais altos.

Exemplo de comentário em PR / saída do Step Summary:

| Package | Risk        | Score | Publishers | Downloads/wk | Age   |
|---------|-------------|-------|------------|--------------|-------|
| chalk   | 🔴 CRITICAL | 75    | 1          | 380M         | 12.7y |
| zod     | 🔴 CRITICAL | 83    | 1          | 133M         | 6.1y  |
| axios   | 🔴 CRITICAL | 89    | 1          | 93M          | 11.6y |

Badges de README

Adicione um badge de Confiança do Commit a qualquer pacote npm que você mantém ou do qual depende:

![Commit Trust](https://poc-backend.amdal-dev.workers.dev/badge/YOUR-PACKAGE)

Exemplos:

Pacote	URL do Badge
chalk	`![Commit Trust](https://poc-backend.amdal-dev.workers.dev/badge/chalk)`
react	`![Commit Trust](https://poc-backend.amdal-dev.workers.dev/badge/react)`
express	`![Commit Trust](https://poc-backend.amdal-dev.workers.dev/badge/express)`
@babel/core	`![Commit Trust](https://poc-backend.amdal-dev.workers.dev/badge/@babel/core)`

Notas: 🟢 OK (75+) · 🟠 AVISO (40–74) · 🔴 CRÍTICO (<40 ou único publicador npm com 10M+ downloads semanais)

Badges são armazenados em cache por 1 hora. Nenhuma chave de API necessária.

Também suporta PyPI, Cargo, módulos Go e o formato específico de ecossistema completo:

![commit score](https://poc-backend.amdal-dev.workers.dev/api/badge/npm/YOUR-PACKAGE)
![commit score](https://poc-backend.amdal-dev.workers.dev/api/badge/pypi/YOUR-PACKAGE)
![commit score](https://poc-backend.amdal-dev.workers.dev/api/badge/cargo/YOUR-CRATE)
![commit score](https://poc-backend.amdal-dev.workers.dev/api/badge/golang/github.com/owner/repo)

API REST

Sem chave de API. Sem instalação.

curl https://poc-backend.amdal-dev.workers.dev/api/audit \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"packages": ["axios", "zod", "chalk", "lodash", "express"]}'

{
  "count": 5,
  "results": [
    {
      "name": "chalk",
      "ecosystem": "npm",
      "score": 75,
      "maintainers": 1,
      "weeklyDownloads": 398397580,
      "ageYears": 12.7,
      "trend": "stable",
      "riskFlags": ["CRITICAL"],
      "scorecardScore": 3.6,        // null if no GitHub repo
      "hasDangerousWorkflow": false  // null if no Scorecard data
    },
    ...
  ]
}

12 ferramentas MCP

Ferramenta	Descrição
`audit_dependencies`	Auditoria de risco em lote para até 20 pacotes npm/PyPI/Cargo/Go
`audit_github_repo`	Busca o package.json/requirements.txt de um repositório e audita cada dependência
`audit_dependency_tree`	Mapeia a árvore de dependências completa de um pacote npm (incl. dependências CRÍTICAS transitivas)
`lookup_npm_package`	Perfil comportamental de um único pacote npm
`lookup_pypi_package`	Perfil comportamental de um único pacote PyPI
`lookup_cargo_crate`	Perfil comportamental de uma única crate Rust (crates.io)
`lookup_go_module`	Perfil comportamental de um único módulo Go (proxy.golang.org + GitHub)
`lookup_github_repo`	Pontuação de comprometimento de repositório GitHub (longevidade, frequência de commits, profundidade de contribuidores)
`lookup_business`	Registro comercial norueguês — anos de operação, funcionários, finanças
`lookup_business_by_org`	O mesmo, por número de organização
`query_commitment`	Dados comportamentais de extensão de navegador (visitantes verificados únicos, taxa de repetição)
`get_api_key`	Crie uma chave de API gratuita no chat — sem necessidade de navegador, chave retornada instantaneamente

Anônimo: 15 solicitações/IP/dia UTC em ambos /mcp e /api/audit. Chave gratuita (sem cartão, cadastro de 30s em https://getcommit.dev/get-started): 200/dia. Níveis superiores em https://getcommit.dev/pricing.

O que a pontuação mede

Cada pacote é pontuado de 0–100 em:

Longevidade — Há quanto tempo o pacote existe? Pacotes abandonados são reativados para ataques.
Profundidade de publicadores — Único publicador npm + milhões de downloads semanais = a superfície de ataque que o LiteLLM explorou. (Publicador = pessoa com acesso de publicação npm, distinto de contribuidores GitHub.)
Consistência de lançamentos — Lançamentos regulares sinalizam supervisão ativa. Lacunas longas = acúmulo de vulnerabilidades.
Tendência de downloads — Pacotes em crescimento atraem mais escrutínio (e ataques). Estável = perfil mais baixo.
OpenSSF Scorecard — Segurança de processo (aplicação de revisão de código, proteção de branch, segurança de CI/CD). Separado de sinais comportamentais. Scorecard alto ≠ seguro contra ataques de roubo de credenciais.

Tanto axios (8.1/10 Scorecard) quanto chalk (3.6/10 Scorecard) pontuam CRÍTICO em sinais comportamentais. Eles medem superfícies de ataque diferentes — Scorecard captura lacunas de processo, sinais comportamentais capturam concentração de publicadores.

Sinalizadores de risco:

CRITICAL — único publicador npm + >10M downloads semanais (perfil exato do ataque LiteLLM/axios)
HIGH — pacote com <1 ano + adoção rápida
WARN — sem lançamento em 12+ meses

Pontos de dados reais

# packages you know about:
chalk       — score 75, 1 publisher, 432M/week  ⚑ CRITICAL
zod         — score 83, 1 publisher, 185M/week  ⚑ CRITICAL  (30+ GitHub contributors)
lodash      — score 81, 1 publisher, 156M/week  ⚑ CRITICAL
axios       — score 88, 1 publisher, 113M/week  ⚑ CRITICAL  (attacked Mar 30 2026)
express     — score 90, 5 publishers, 95M/week

# packages probably not in your package.json, definitely in your lock file:
minimatch   — score 78, 1 publisher, 625M/week  ⚑ CRITICAL
glob        — score 80, 1 publisher, 366M/week  ⚑ CRITICAL
cross-spawn — score 72, 1 publisher, 215M/week  ⚑ CRITICAL

# post-attack:
litellm     — score 74, 1 publisher            ⚑ CRITICAL  (supply chain attack Mar 2026)

# Rust crates (new in v1.3.0):
serde       — score 78, 1 owner,  13M/week  ⚑ CRITICAL  (dtolnay sole owner)
tokio       — score 89, 2 owners, 10M/week
reqwest     — score 85, 1 owner,   8M/week  ⚑ HIGH

Por que sinais comportamentais

O ataque ao LiteLLM (março de 2026) e o ataque ao axios (30 de março de 2026) seguiram o mesmo padrão: credenciais roubadas → pacote malicioso enviado → 97M+ máquinas expostas. Ambos os pacotes pontuaram CRÍTICO por essas métricas antes dos ataques.

Sinais declarativos (estrelas, qualidade do README, badges de CI) não capturam esse risco. Comprometimento comportamental captura.

Blog

O Backdoor do LinkedIn: Por que o npm audit Perdeu um Ataque de 250 Linhas — Um ataque de clone falso de recrutador escondeu malware em arquivos de teste e o executou via scripts de ciclo de vida do npm. npm audit: silencioso. O que sinais comportamentais teriam sinalizado.
Previsão do Ataque ao Axios — Sinalizamos axios como CRÍTICO (único publicador npm, 113M downloads/semana) antes do roubo de token em 30 de março de 2026.

Stack

Camada	Tecnologia
Backend	Cloudflare Workers + D1
MCP	Model Context Protocol SDK
Dados	npm registry, PyPI, crates.io, proxy.golang.org, deps.dev, GitHub API, Brønnøysund (NO)
Landing	Astro + Cloudflare Pages

Roadmap

Planejado, não prometido. O projeto está em estágio inicial — contribuições são bem-vindas em qualquer um destes itens.

Recurso	Status	Notas
Suporte ao registro Cargo (Rust)	✅ Ativo	Ferramenta MCP, API REST, endpoint de badge — `ecosystem: "cargo"`
Suporte a módulos Go	✅ Ativo	proxy.golang.org + deps.dev + pontuação primária via GitHub — `ecosystem: "golang"`
Visualização da divisão de pontuação	Planejado	Componente de gráfico para as 5 dimensões em getcommit.dev/audit
Flag `--json` para CLI	✅ Ativo	`npx proof-of-commitment --file package-lock.json --json \| jq '.criticalCount'`
Suporte a monorepo pnpm workspace	✅ Ativo	`--file pnpm-workspace.yaml` ou detectado automaticamente a partir de `pnpm-lock.yaml`
Histórico de rastreamento de pontuação	Planejado	Gráficos de tendência — este pacote estava ficando mais arriscado ao longo do tempo?
Painéis de nível organizacional	Planejado	Visão agregada de risco em todos os repositórios de uma organização no GitHub

Veja issues abertas para coisas com as quais você pode ajudar hoje.

A visão mais ampla

Auditoria de cadeia de suprimentos é a primeira ferramenta. A primitiva subjacente é um grafo de compromisso — sinais comportamentais que substituem a confiança baseada em conteúdo em qualquer domínio.

Quando o conteúdo é livre para ser falsificado (avaliações, estrelas, READMEs), o compromisso se torna o sinal. Um publicador que lançou 847 versões ao longo de 12 anos é um tipo diferente de compromisso daquele que publicou uma única vez em 2023.

A mesma lógica se aplica a sites, empresas e agentes de IA. Duas redes de cartão nomearam essa lacuna de forma independente: Mastercard Verifiable Intent §9.2 lista explicitamente a confiança comportamental como "não coberta." Visa TAP identifica agentes sem responder se devemos confiar neles.

Proof of Commitment é a camada de confiança para a qual eles estão apontando.

→ getcommit.dev

Executar localmente

bun install
bun run dev:backend     # local server with SQLite
bun run test:e2e        # E2E test with mock World ID

Implantar:

bun run deploy          # deploys to Cloudflare Workers

Lançamento

A publicação é acionada automaticamente quando uma tag v* é enviada, ou manualmente via GitHub Actions workflow_dispatch.

Portão de fumaça do funil

Antes de npm publish ser executado, o fluxo de trabalho de CI executa scripts/funnel-smoke.sh — uma verificação pré-publicação com mock local que exercita quatro caminhos principais do funil:

Caminho	O que testa	Classe de bug capturada
A	Auditoria CLI com `COMMIT_API_KEY` definido → 200 + resultados	v1.20.0: cabeçalho `Authorization` ausente → 0 conversões pagas
B	Auditoria CLI anônima, 429 → mensagem + `instant_key_url`	Tratamento de 429 / exibição de CTA
C	cursor-hook (stdin do Cursor) 429 → `permission: ask` + URL de inscrição	v1.21.0: `allow` silencioso em 429 → lacuna de segurança + 0 conversões
D	cursor-hook (stdin `PreToolUse` do Claude Code) 429 → `hookSpecificOutput.permissionDecision: ask` + atribuição `claude-code-hook-429`	v1.22.0: resposta com formato incorreto quando o Claude Code dirige → permissão silenciosa / conversão mal atribuída

Qualquer falha de caminho bloqueia o lançamento. O portão executa um servidor mock local em Python, então é determinístico no CI e não depende do estado de limite de taxa de produção.

Segredo de CI opcional: Defina COMMIT_TEST_API_KEY nos segredos do repositório GitHub para usar uma chave de API real para o Caminho A. Caso contrário, usa uma chave mock que o servidor local aceita incondicionalmente.

Executar localmente:

bash scripts/funnel-smoke.sh