protect-mcp

AI एजेंट टूल कॉल्स के लिए fail-closed Cedar नीति गेट और हस्ताक्षरित रसीदें।

protect-mcp एक गेट है जो AI एजेंट के टूल कॉल्स के सामने बैठता है। यह प्रत्येक कॉल का मूल्यांकन Cedar नीति के विरुद्ध करता है (वही भाषा जिसका उपयोग AWS IAM के लिए करता है), नियम तोड़ने वाली चीज़ों को चलने से पहले रोक देता है, और प्रत्येक निर्णय की ऑफ़लाइन-सत्यापन-योग्य Ed25519 रसीद पर हस्ताक्षर करता है। यह स्थानीय रूप से चलता है, आपके निर्णयों का कोई टेलीमेट्री कहीं नहीं भेजता, और MIT लाइसेंस प्राप्त है।

यह अलग क्यों है

• डिफ़ॉल्ट रूप से fail-closed। किसी भी नीति त्रुटि, अनुपस्थित इंजन, या मूल्यांकन विफलता पर, निर्णय DENY होता है। गेट कभी चुपचाप अनुमति नहीं देता। शैडो रोलआउट के लिए एक observe मोड मौजूद है, लेकिन वहाँ भी जो कॉल ब्लॉक होती, उसे would_deny: true के रूप में चिह्नित किया जाता है, इसलिए विफलता कभी चुपचाप नहीं होती।
• यह अपनी ही संयमितता सिद्ध करता है। serve --enforce और doctor एक स्टार्टअप स्व-परीक्षण चलाते हैं और गेट को सशस्त्र करने से इनकार कर देते हैं जब तक वे यह नहीं दिखा सकें कि एक ज्ञात-निषिद्ध क्रिया वास्तव में अस्वीकृत होती है। जो गेट यह सिद्ध नहीं कर सकता कि वह अस्वीकार करता है, वह शुरू नहीं होता।
• प्रत्येक निर्णय एक रसीद है जिसे कोई भी सत्यापित कर सकता है। निर्णय Ed25519-हस्ताक्षरित होते हैं और @veritasacta/verify के साथ ऑफ़लाइन सत्यापन-योग्य होते हैं। किसी विक्रेता विश्वास की आवश्यकता नहीं: गणित को परवाह नहीं है कि इसे कौन चलाता है।

क्विकस्टार्ट: इंस्टॉल से पहले उपयोगी प्रमाण तक```bash

1. Generate an Ed25519 keypair, config template, and sample policy.

npx protect-mcp init

2. Wrap any MCP server in shadow mode. Nothing is blocked yet; calls are logged.

npx protect-mcp wrap -- node your-mcp-server.js

3. Inspect the local-only dashboard: tool inventory, risk, approvals, receipts.

npx protect-mcp dashboard --open

4. Draft a reviewable policy from observed calls.

npx protect-mcp recommend --write

5. When reviewed, restart the wrapper in enforce mode with that policy.

npx protect-mcp --policy protect-mcp.recommended.json --enforce -- node your-mcp-server.js

Claude Desktop के लिए, पहले एक dry-run config patch चलाएँ, फिर उसे लागू करें:```bash
npx protect-mcp wrap --claude-desktop
npx protect-mcp wrap --claude-desktop --write
npx protect-mcp dashboard --open

डैशबोर्ड 127.0.0.1 पर बाइंड होता है, केवल स्थानीय लॉग/रसीद फ़ाइलें पढ़ता है, और कुछ भी अपलोड नहीं करता। npx protect-mcp connect का उपयोग केवल तब करें जब आप स्पष्ट रूप से होस्टेड ScopeBlind डैशबोर्ड चाहते हों।

MCP सर्वर के रूप में गेट

यदि आप Claude Code हुक्स को वायर करने के बजाय गेट को टूल्स के रूप में कॉल करना पसंद करते हैं, तो इसे MCP सर्वर के रूप में चलाएँ:```bash npx protect-mcp mcp

यह stdio पर MCP बोलता है और चार read-only tools को expose करता है, पूरा loop:

- **`evaluate_action`**: एक proposed tool call को inline Cedar policy के विरुद्ध तय करता है, fail-closed (कोई भी policy error DENY है)। `{ allowed, decision, reason, policy_digest }` return करता है।
- **`sign_decision`**: एक decision को Ed25519 signed receipt में बदलता है (एक denial `gateway_restraint` sign करता है, एक allow `decision_receipt`)। receipt और उसकी public key return करता है; यदि आप एक supply नहीं करते हैं तो एक ephemeral key generate करता है।
- **`verify_receipt`**: एक signed receipt को offline, एक public key के विरुद्ध verify करता है। `{ valid, error, type, kid, issuer }` return करता है।
- **`self_test`**: इसे सिद्ध करता है, कोई inputs नहीं। एक known-forbidden action deny किया जाता है, फिर एक signed receipt round-trip करता है और एक tampered copy fail होती है।

किसी भी MCP host को इस पर point करें, उदाहरण के लिए Claude Desktop:```json
{
  "mcpServers": {
    "protect-mcp": { "command": "npx", "args": ["-y", "protect-mcp", "mcp"] }
  }
}

Receipts रनटाइम पर गेट द्वारा हस्ताक्षरित रसीदों के साथ बाइट-संगत हैं, इसलिए यहाँ मिंट की गई रसीद @veritasacta/verify और ब्राउज़र सत्यापनकर्ता के साथ उसी तरह सत्यापित होती है।

स्थानीय क्रिया डैशबोर्ड

protect-mcp dashboard दृश्यता से प्रवर्तन की ओर बढ़ने के लिए ऑपरेटर दृश्य है:

• टूल इन्वेंटरी: प्रत्येक देखा गया टूल, कॉल गणना, उच्च/मध्यम/निम्न जोखिम, और क्या सक्रिय नीति में एक सटीक नियम, एक वाइल्डकार्ड फ़ॉलबैक, या कोई नियम नहीं है।
• नीति कवरेज: Require approval, Block, या Observe के लिए एक-क्लिक स्थानीय नीति संपादन। परिवर्तनों की समीक्षा के बाद रैपर को पुनः आरंभ करें।
• सटीक-क्रिया अनुमोदन कतार: मानव द्वारा अनुमोदन, अस्वीकृति, संपादन, या अधिग्रहण से पहले सटीक टूल, क्रिया, गंतव्य, संपादित पेलोड पूर्वावलोकन, पेलोड हैश, नीति आधार, और कारण कैप्चर।
• रसीद श्रृंखला: अनुरोध आईडी हस्ताक्षरित रसीद हैश के साथ सहसंबद्ध, ताकि एक ऑडिट समीक्षक देख सके कि किन निर्णयों के पास क्रिप्टोग्राफिक प्रमाण है।
• ऑडिट निर्यात: हस्ताक्षरित रसीदें मौजूद होने पर ऑफ़लाइन-सत्यापन योग्य ऑडिट बंडल डाउनलोड करता है। यदि केवल अहस्ताक्षरित स्थानीय लॉग मौजूद हैं, तो डैशबोर्ड बताता है कि पहले हस्ताक्षरण सक्षम किया जाना चाहिए।

लाइव डेस्कटॉप फ़ॉलबैक अनुमोदनों के लिए, डैशबोर्ड को रैपर द्वारा प्रिंट किए गए स्थानीय गेटवे अनुमोदन एंडपॉइंट और नॉनस के साथ प्रारंभ करें:```bash npx protect-mcp dashboard --open
--approval-endpoint http://127.0.0.1:9876
--approval-nonce "$PROTECT_MCP_APPROVAL_NONCE"

`Approve` उन flags के मौजूद होने पर लाइव local gateway को forward करता है।
`Deny`, `Edit`, और `Take over` locally approval-resolution records के रूप में
दर्ज किए जाते हैं; इन्हें operator instruction के रूप में उपयोग करें और आवश्यकता
पड़ने पर tool को दोबारा चलाएँ।

### Paid Boundary MVP: digest anchoring, not data upload

Local self-signed receipts मुफ़्त और offline-verifiable रहते हैं। Paid boundary
यह स्वतंत्र प्रमाण है कि ScopeBlind ने किसी org identity के अंतर्गत किसी समय
एक receipt digest देखा, बिना raw prompt, tool payload, output, private key, या
raw receipt प्राप्त किए।```bash
# Create or refresh a local org identity and public-key directory.
npx protect-mcp registry init --org "Meridian Global Macro" --billing-account acct_meridian

# Local preview: writes a digest registry and shareable static verifier page.
npx protect-mcp registry anchor

# Hosted mode: uploads receipt digests only for independent anchoring.
SCOPEBLIND_TOKEN=... npx protect-mcp registry anchor \
  --hosted \
  --endpoint https://api.scopeblind.com \
  --verifier-base https://legate.scopeblind.com

The local preview is deliberately labeled local-preview-not-independent. Hosted mode anchors only receipt hashes, request ids, org public keys, and billing metadata. It does not upload raw receipts or sensitive context.

Killer Demo: shadow to policy to proof

protect-mcp killer-demo generates a complete three-minute sales/demo pack:```bash npx protect-mcp killer-demo --dir ./scopeblind-demo

यह मॉक फाइलसिस्टम, GitHub, ईमेल, और PMS गतिविधि बनाता है; शैडो मोड में जोखिम भरी कॉल दिखाता है; एक पॉलिसी पैक लागू करता है; एक संवेदनशील PMS बुकिंग के लिए अनुमोदन की आवश्यकता होती है; गेटवे के माध्यम से निष्पादित करता है; एक हस्ताक्षरित रसीद लिखता है; सिद्ध करता है कि मूल रसीद सत्यापित होती है; सिद्ध करता है कि छेड़छाड़ की गई रसीद विफल होती है; और एक चयनात्मक प्रकटीकरण पैकेज बनाता है जो संवेदनशील संदर्भ को छिपाता है जबकि न्यूनतम प्रमाण दिखाता है।

पहले जनरेट किया गया `DEMO-RUNBOOK.md` खोलें। फिर ग्राहक को सटीक अनुक्रम के माध्यम से ले जाने के लिए मुद्रित डैशबोर्ड कमांड चलाएँ।

### Selective Disclosure v0

कमिटमेंट-मोड रसीदें हर फ़ील्ड को स्पष्ट रूप में उजागर करने के बजाय एक `committed_fields_root` ले जा सकती हैं। बाद में, धारक केवल चयनित फ़ील्ड का खुलासा कर सकता है:```bash
npx protect-mcp verify-disclosure \
  --receipt ./receipts/selective-disclosure.receipt.json \
  --disclosure ./receipts/selective-disclosure.tool-only.json

The verifier checks the parent receipt hash, Ed25519 signature, commitment root, and each disclosed field's Merkle proof. It then explains which fields were disclosed and which committed fields remain hidden. This is salted commitment disclosure, not full zero-knowledge, but it makes the privacy claim concrete: auditors can verify selected facts without receiving the full tool payload or sensitive desk context.

Prove a claim over the record (position-blind attestations)

You can prove a CLAIM over your record without revealing it. Mint a signed, position-blind attestation over the whole record that discloses only per-decision categories (a receipt digest, the verdict, capability tags), never your tool inputs, outputs, or data:```bash

"No action reached the network across the record":

npx protect-mcp claim --no net.egress

other predicates:

--only fs.read,fs.write all actions were confined to these capabilities

--no-verdict blocked no action was blocked

--count blocked how many were blocked

कोई भी इसे ऑफ़लाइन सत्यापित करता है, केवल श्रेणियाँ देखता है, कभी सामग्री नहीं:```bash
npx protect-mcp verify-claim claim-<id>.json

The verifier disclosed सेट पर एक Merkle root की पुनर्गणना करता है और predicate की स्वतंत्र रूप से पुनर्गणना करता है, इसलिए disclosure दिए जाने पर issuer claim के बारे में झूठ नहीं बोल सकता। claim के digest को सार्वजनिक, append-only ScopeBlind transparency log में रिकॉर्ड करने के लिए --anchor जोड़ें, ताकि एक counterparty जो आप पर भरोसा नहीं करता, पुष्टि कर सके कि disclosed सेट पूर्ण है और चुपचाप दोबारा काटा नहीं गया था (केवल hash भेजा जाता है; रिकॉर्ड स्थानीय रहता है):```bash npx protect-mcp claim --no net.egress --anchor

यह एक जवाबदेह, स्थिति-अंध सत्यापन है, पूर्ण शून्य-ज्ञान नहीं: यह आकार प्रकट करता है, सामग्री नहीं।

## 60 सेकंड में आज़माएँ (किसी एजेंट की आवश्यकता नहीं)

[![दो मिनट की डेमो फ़िल्म देखें](https://assets.kitploit.com/production/public/readmes/13151/01d856d6ca762bf76992ad56ab4c05824f272e9d98d62516a8f53bb90bce0db5.jpg)](https://legate.scopeblind.com/record)

[legate.scopeblind.com/record](https://legate.scopeblind.com/record) पर दो मिनट की फ़िल्म देखें, फिर इसे अपनी खुद की कॉपी के विरुद्ध दोबारा चलाएँ:```bash
npx protect-mcp sample     # seed a labeled sample record (8 decisions: 1 blocked, 2 payments)
npx protect-mcp record     # open it: signatures verified in your browser

npx protect-mcp claim --payment-under 100 --anchor --output payments-under-100.json
npx protect-mcp verify-claim payments-under-100.json
npx protect-mcp anchor-record

जनरेट किए गए demo-tampered.jsonl को रिकॉर्ड पेज में डालें ताकि साइनिंग के बाद किए गए संपादन को पकड़ा जाता हुआ देखा जा सके। sample किसी मौजूदा रिकॉर्ड को छूने से इनकार करता है, इसलिए इसे एक खाली फ़ोल्डर में चलाएँ। जब आप असली चीज़ के लिए तैयार हों, तो नीचे दिए गए गेट को जोड़ें और वही कमांड आपके एजेंट के अपने रिकॉर्ड के विरुद्ध चलेंगी।

Claude Code hook quickstart```bash

Generate hook config and a sample Cedar policy.

npx protect-mcp init-hooks

Serve the Claude Code hook gate in enforce mode. It runs a restraint self-test

first and refuses to start if it cannot prove it denies a forbidden vector.

npx protect-mcp serve --enforce --cedar ./cedar

एक-शॉट मूल्यांकन, जिस तरह से एक PreToolUse हुक इसे कॉल करता है। Exit code 2 का अर्थ है अस्वीकार
(टूल अवरुद्ध है); exit 0 का अर्थ है अनुमति:```bash
npx protect-mcp evaluate --cedar ./cedar --tool Bash --input '{"command":"rm"}'
echo $?   # 2  -> denied, fail-closed

npx protect-mcp evaluate --cedar ./cedar --tool Read --input '{"path":"README.md"}'
echo $?   # 0  -> allowed

एक अनुपस्थित या लोड न होने वाली नीति इनकार करती है (exit 2) जब तक कि आप स्पष्ट रूप से --fail-on-missing-policy false पास न करें।

Claude Code hooks

protect-mcp init-hooks आपके लिए एक .claude/settings.json लिखता है। गेट को हाथ से वायर करने के लिए, आपको जिन दो क्रियाओं की आवश्यकता है वे हैं evaluate (PreToolUse, exit 2 पर ब्लॉक करता है) और sign (PostToolUse, एक रसीद रिकॉर्ड करता है)। संस्करण को पिन करें ताकि एक Claude Code सत्र हमेशा वही गेट चलाए जिसका आपने परीक्षण किया:```json { "hooks": { "PreToolUse": [ { "matcher": "", "hooks": [ { "type": "command", "command": "npx [email protected] evaluate --cedar ./cedar --tool "$TOOL_NAME" --input "$TOOL_INPUT"" } ] } ], "PostToolUse": [ { "matcher": "", "hooks": [ { "type": "command", "command": "npx [email protected] sign --tool "$TOOL_NAME" --receipts ./receipts --key ./keys/gateway.json" } ] } ] } }

### नीति निर्णय को स्वयं हस्ताक्षरित करें

0.13.0 से, `sign` नीति का मूल्यांकन कर सकता है और बिना शर्त अनुमति के बजाय रसीद में वास्तविक निर्णय दर्ज कर सकता है। नीति निर्देशिका और वही इनपुट और संदर्भ पास करें जो हुक `evaluate` को पास करेगा:```bash
npx [email protected] sign --cedar ./cedar --tool Bash \
  --input '{"command":"rm -rf /"}' --context '{"command_pattern":"rm -rf"}' \
  --receipts ./receipts --key ./keys/gateway.json

The receipt payload then carries decision (allow or deny), reason (cedar_allow or cedar_deny), and policy_digest (the acta-policy-digest-v1 digest of the policy set), and cites draft-farley-acta-signed-receipts-03. The command prints the decision and digest on stdout. A deny is still signed: the receipt is the record of the decision, not permission to proceed.

Two Cedar action models are supported. The runtime gate evaluates Action::"MCP::Tool::call" with the tool as the resource, which is what the policies in cedar/ expect and what sign --cedar uses by default. Policies that name the tool as the action (action == Action::"Bash"), such as the published conformance policy in agent-governance-testvectors, need --action-model tool. evaluate accepts the same flag.

evaluate exits 2 on deny so Claude Code blocks the tool call, and 0 on allow. sign is best-effort: it appends an Ed25519-signed receipt when a key is configured, and if no signer is available it records an honest unsigned line ("signed": false) rather than failing the tool.

Use it in other agents (Codex, Cursor, Gemini, Hermes)

The same fail-closed gate runs as a tool hook in any agent that supports them. Add --format <host> so the verb reads that host's hook payload from stdin and denies in its contract:```bash

the PreToolUse / before-tool command for each host

npx -y protect-mcp@latest evaluate --format codex --cedar ./cedar # OpenAI Codex npx -y protect-mcp@latest evaluate --format gemini --cedar ./cedar # Gemini CLI BeforeTool npx -y protect-mcp@latest evaluate --format cursor --cedar ./cedar # Cursor beforeShellExecution npx -y protect-mcp@latest evaluate --format hermes --cedar ./cedar # Hermes pre_tool_call

प्रत्येक को post-tool event पर receipts के लिए `sign --format <host>` के साथ जोड़ें। महत्वपूर्ण मामला **Hermes** है, जो hook exit codes को अनदेखा करता है और verdict को stdout से पढ़ता है, इसलिए `--format hermes` exit 2 के बजाय `{"decision":"block"}` के माध्यम से deny करता है (एक raw exit-2 वहाँ चुपचाप fail open हो जाएगा)। `--format` के बिना, verbs `--tool`/`--input` flags को ठीक वैसे ही पढ़ते हैं जैसे ऊपर Claude Code section में हैं।

## एक policy लिखें

Cedar policies उस directory में रहती हैं जिसे आप `--cedar` के साथ point करते हैं। एक `forbid` rule deny करता है, एक `permit` rule allow करता है। tool input में किसी value से match करने के लिए, `.contains()` idiom का उपयोग करें:```cedar
// Allow read-only tools.
permit(
  principal,
  action == Action::"MCP::Tool::call",
  resource == Tool::"Read"
);

// Deny dangerous shell commands by matching the command against a list.
forbid(
  principal,
  action == Action::"MCP::Tool::call",
  resource == Tool::"Bash"
) when {
  ["rm", "dd", "mkfs"].contains(context.command)
};

// Block destructive tools outright.
forbid(
  principal,
  action == Action::"MCP::Tool::call",
  resource == Tool::"delete_file"
);

खतरा: किसी स्ट्रिंग को सूची से मिलाने के लिए context.command in ["rm", "dd"] न लिखें। in एंटिटी पदानुक्रमों के लिए है, स्ट्रिंग सदस्यता के लिए नहीं। Cedar इस अभिव्यक्ति को एक प्रकार त्रुटि मानता है और पूरे forbid नियम को चुपचाप त्याग देता है, जो (fail-open गेट के अंतर्गत) एक अवशिष्ट permit को खड़ा छोड़ देता है। यह नीचे दिए गए एडवाइज़री के पीछे का सटीक दोष है। इसके बजाय [...].contains(context.command) का उपयोग करें। 0.7.0 से गेट उस त्रुटि पर अनुमति देने के बजाय मना कर देता है, और एक CI ट्रिपवायर परीक्षण बिल्ड को विफल कर देता है यदि पैटर्न किसी शिप किए गए पॉलिसी में फिर से पेश किया जाता है। देखें GHSA-hm46-7j72-rpv9।

स्टार्टर पॉलिसी पैक

अधिकांश टीमों को पहले दिन से Cedar शून्य से नहीं लिखना चाहिए। एक स्टार्टर पैक इंस्टॉल करें, शैडो मोड में चलाएँ, रसीदों का निरीक्षण करें, फिर कसें या लागू करें:```bash npx protect-mcp policy-packs list npx protect-mcp policy-packs show secrets-safe npx protect-mcp policy-packs install filesystem-safe --dir ./cedar npx protect-mcp policy-packs install all --dir ./cedar npx protect-mcp serve --cedar ./cedar

अंतर्निहित पैक:

- `filesystem-safe`: विनाशकारी फ़ाइल क्रियाएँ और गुप्त-जैसे पथ पढ़ना।
- `git-safe`: ज़बरदस्ती पुश, हार्ड रीसेट, विनाशकारी सफ़ाई, रेपो हटाना।
- `email-safe`: ड्राफ़्ट बनाने की अनुमति, बिना निगरानी भेजने को अवरुद्ध करें।
- `database-safe`: पढ़ने-केंद्रित DB मुद्रा, लेखन/एडमिन SQL को अवरुद्ध करें।
- `cloud-spend-safe`: स्पष्ट क्लाउड खर्च निर्माण और अवसंरचना विनाश।
- `secrets-safe`: सामान्य फ़ाइल, env, शेल, और क्लाउड गुप्त निष्कासन।
- `finance-mandate-safe`: बुकिंग प्रवाह में प्रतिबंधित-सूची और एकाग्रता उल्लंघन।

## रसीद सत्यापित करें

रसीदें हस्ताक्षरित होती हैं और सार्वजनिक कुंजी वाले किसी भी व्यक्ति द्वारा ऑफ़लाइन सत्यापन योग्य होती हैं। कोई
नेटवर्क नहीं, कोई विक्रेता नहीं, ScopeBlind पर कोई भरोसा नहीं:```bash
npx @veritasacta/verify ./receipts/receipts.jsonl --format jsonl
# Exit 0 = valid, non-zero = tampered or malformed

npx protect-mcp bundle --output audit.json आपकी रसीदों और सार्वजनिक साइनिंग कुंजी का एक स्व-निहित, ऑफ़लाइन-सत्यापन योग्य ऑडिट बंडल निर्यात करता है।

सुरक्षा

protect-mcp 0.7.0 डिज़ाइन द्वारा फेल-क्लोज़्ड है। किसी भी नीति-मूल्यांकन त्रुटि, अनुपस्थित इंजन, या मूल्यांकन के समय त्रुटि देने वाली नीति पर, निर्णय DENY होता है, allow नहीं। serve --enforce और doctor एक बूट स्व-परीक्षण चलाते हैं जो साबित करता है कि गेट किसी ज्ञात-निषिद्ध वेक्टर को अस्वीकार करता है, इससे पहले कि उस पर भरोसा किया जाए, और यदि ऐसा नहीं कर सकता तो आर्म होने से इंकार कर देता है।

प्रभावित संस्करण: 0.5.x और 0.6.x। वे लाइनें फेल ओपन होती हैं (मूल्यांकन त्रुटि पर वे ALLOW लौटाती हैं) और पिन किए गए इंजन के विरुद्ध Cedar का सही मूल्यांकन नहीं करतीं, इसलिए एक forbid नियम ब्लॉक करने में विफल हो सकता है। >= 0.7.0 पर अपग्रेड करें।

विवरण और उपचार: GHSA-hm46-7j72-rpv9। किसी भेद्यता की रिपोर्ट करने के लिए, SECURITY.md देखें।

कमांड

पूर्ण फ़्लैग संदर्भ के लिए npx protect-mcp --help चलाएँ।

लिंक

• प्रोटोकॉल (IETF): draft-farley-acta-signed-receipts
• CHANGELOG
• npm
• scopeblind.com

MIT लाइसेंस प्राप्त। ScopeBlind द्वारा निर्मित।