protect-mcp 0.1.1 → 0.2.1

package/dist/cli.mjs

@@ -1,27 +1,35 @@
 #!/usr/bin/env node
 import {
   ProtectGateway,
-  loadPolicy
-} from "./chunk-L3QWKSGY.mjs";
+  initSigning,
+  loadPolicy,
+  validateCredentials
+} from "./chunk-ZCKNFULF.mjs";
 
 // src/cli.ts
 function printHelp() {
   process.stderr.write(`
-@scopeblind/protect-mcp \u2014 Security gateway for MCP servers
+protect-mcp \u2014 Shadow-mode security gateway for MCP servers
 
 Usage:
   protect-mcp [options] -- <command> [args...]
+  protect-mcp init [--dir <path>]
 
 Options:
-  --policy <path>   Policy JSON file (default: allow-all)
+  --policy <path>   Policy/config JSON file (default: allow-all)
   --slug <slug>     ScopeBlind tenant slug (optional)
-  --enforce         Enable enforcement mode (default: observe-only)
+  --enforce         Enable enforcement mode (default: shadow mode)
   --verbose         Enable debug logging to stderr
   --help            Show this help
 
+Commands:
+  init              Generate config template, Ed25519 keypair, and sample policy
+
 Examples:
   protect-mcp -- node my-server.js
-  protect-mcp --policy policy.json --enforce -- node my-server.js
+  protect-mcp --policy protect-mcp.json -- node my-server.js
+  protect-mcp --policy protect-mcp.json --enforce -- node my-server.js
+  protect-mcp init
 
 `);
 }
@@ -64,20 +72,133 @@ function parseArgs(argv) {
   }
   return { policyPath, slug, enforce, verbose, childCommand };
 }
+async function handleInit(argv) {
+  const { writeFileSync, existsSync, mkdirSync } = await import("fs");
+  const { join } = await import("path");
+  let dir = process.cwd();
+  const dirIdx = argv.indexOf("--dir");
+  if (dirIdx !== -1 && argv[dirIdx + 1]) {
+    dir = argv[dirIdx + 1];
+  }
+  const configPath = join(dir, "protect-mcp.json");
+  const keysDir = join(dir, "keys");
+  const keyPath = join(keysDir, "gateway.json");
+  if (existsSync(configPath)) {
+    process.stderr.write(`[PROTECT_MCP] Config already exists at ${configPath}
+`);
+    process.stderr.write("[PROTECT_MCP] Delete it first if you want to regenerate.\n");
+    process.exit(1);
+  }
+  let keypair;
+  try {
+    const artifacts = await import("@veritasacta/artifacts");
+    keypair = artifacts.generateKeypair();
+  } catch {
+    const { randomBytes } = await import("crypto");
+    const { ed25519 } = await import("./ed25519-EDO4K4EP.mjs");
+    const { bytesToHex } = await import("./utils-IDWBSHJU.mjs");
+    const privateKey = randomBytes(32);
+    const publicKey = ed25519.getPublicKey(privateKey);
+    keypair = {
+      privateKey: bytesToHex(privateKey),
+      publicKey: bytesToHex(publicKey),
+      kid: "generated"
+    };
+  }
+  if (!existsSync(keysDir)) {
+    mkdirSync(keysDir, { recursive: true });
+  }
+  writeFileSync(keyPath, JSON.stringify({
+    privateKey: keypair.privateKey,
+    publicKey: keypair.publicKey,
+    kid: keypair.kid,
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    warning: "KEEP THIS FILE SECRET. Never commit to version control."
+  }, null, 2) + "\n");
+  const gitignorePath = join(keysDir, ".gitignore");
+  if (!existsSync(gitignorePath)) {
+    writeFileSync(gitignorePath, "# Never commit signing keys\n*.json\n");
+  }
+  const config = {
+    tools: {
+      "*": {
+        rate_limit: "100/hour"
+      },
+      "delete_file": {
+        block: true,
+        min_tier: "privileged"
+      },
+      "write_file": {
+        min_tier: "signed-known",
+        rate_limit: "10/minute"
+      },
+      "read_file": {
+        rate_limit: "50/minute"
+      }
+    },
+    default_tier: "unknown",
+    signing: {
+      key_path: "./keys/gateway.json",
+      issuer: "protect-mcp",
+      enabled: true
+    },
+    credentials: {
+      _example_api: {
+        inject: "header",
+        name: "Authorization",
+        value_env: "EXAMPLE_API_KEY",
+        _comment: "Remove the underscore prefix and set EXAMPLE_API_KEY in your environment"
+      }
+    }
+  };
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  process.stderr.write(`
+${bold("protect-mcp initialized!")}
+
+Created:
+  ${configPath}     Config with shadow mode + optional local signing
+  ${keyPath}       Ed25519 signing keypair
+
+${bold("Next steps:")}
+  1. Edit protect-mcp.json to match your MCP server's tools
+  2. Set any credential environment variables
+  3. Run: protect-mcp --policy protect-mcp.json -- <your-mcp-server>
+
+${bold("Your gateway public key:")}
+  ${keypair.publicKey}
+
+${bold("Key ID (kid):")}
+  ${keypair.kid}
+
+Shadow mode is the default \u2014 all tool calls are logged and nothing is blocked.
+Run with the generated policy file if you also want local signed receipts. Add --enforce when ready.
+`);
+}
+function bold(s) {
+  return process.env.NO_COLOR ? s : `\x1B[1m${s}\x1B[0m`;
+}
 async function main() {
   const args = process.argv.slice(2);
   if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
     printHelp();
     process.exit(0);
   }
+  if (args[0] === "init") {
+    await handleInit(args.slice(1));
+    process.exit(0);
+  }
   const { policyPath, slug, enforce, verbose, childCommand } = parseArgs(args);
   let policy = null;
   let policyDigest = "none";
+  let credentials;
+  let signing;
   if (policyPath) {
     try {
       const loaded = loadPolicy(policyPath);
       policy = loaded.policy;
       policyDigest = loaded.digest;
+      credentials = loaded.credentials;
+      signing = loaded.signing;
       if (verbose) {
         process.stderr.write(`[PROTECT_MCP] Loaded policy from ${policyPath} (digest: ${policyDigest})
 `);
@@ -88,6 +209,20 @@ async function main() {
       process.exit(1);
     }
   }
+  if (signing) {
+    const warnings = await initSigning(signing);
+    for (const w of warnings) {
+      process.stderr.write(`[PROTECT_MCP] Warning: ${w}
+`);
+    }
+  }
+  if (credentials) {
+    const warnings = validateCredentials(credentials);
+    for (const w of warnings) {
+      process.stderr.write(`[PROTECT_MCP] Warning: ${w}
+`);
+    }
+  }
   const config = {
     command: childCommand[0],
     args: childCommand.slice(1),
@@ -95,7 +230,9 @@ async function main() {
     policyDigest,
     slug,
     enforce,
-    verbose
+    verbose,
+    signing,
+    credentials
   };
   const gateway = new ProtectGateway(config);
   await gateway.start();