@sebastienrousseau/crypto-mcp 0.0.0-stage → 0.0.8

package/LICENSE

@@ -0,0 +1,8 @@
+This project is dual-licensed under either of:
+
+  * Apache License, Version 2.0 — see LICENSE-APACHE
+  * MIT license — see LICENSE-MIT
+
+at your option.
+
+SPDX-License-Identifier: Apache-2.0 OR MIT

package/README.md

@@ -1,3 +1,139 @@
-# Temporary Holding Version
+<!-- SPDX-License-Identifier: Apache-2.0 OR MIT -->
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# `@sebastienrousseau/crypto-mcp`
+
+> Model Context Protocol (MCP) Server for the Crypto Service Suite — exposing cryptographic operations, post-quantum primitives, and key management to AI assistants and agentic workflows.
+
+[![npm version](https://img.shields.io/npm/v/@sebastienrousseau/crypto-mcp.svg)](https://www.npmjs.com/package/@sebastienrousseau/crypto-mcp)
+[![License](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue.svg)](LICENSE)
+[![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen.svg)](https://github.com/sebastienrousseau/crypto-service)
+
+---
+
+## Overview
+
+`@sebastienrousseau/crypto-mcp` implements the **Model Context Protocol (MCP)** specification, turning the Crypto Service Suite into a secure, tool-enabled cryptographic runtime for AI agents and LLM-driven environments (including Cursor, Antigravity, Claude Desktop, VS Code, and Zed).
+
+Instead of relying on fragile shell scripts or unverified LLM math, agents invoke cryptographically verified tools backed by `@sebastienrousseau/crypto-lib`, `@sebastienrousseau/crypto-kms`, and `@sebastienrousseau/crypto-wasm`.
+
+---
+
+## Features
+
+- **Standard MCP Protocol**: Full compliance with the Model Context Protocol JSON-RPC 2.0 specification via stdio transport.
+- **Post-Quantum Cryptography (PQC)**: Tools for NIST FIPS 203 (ML-KEM / Kyber), FIPS 204 (ML-DSA), and hybrid X25519 + ML-KEM key encapsulation.
+- **Classical Primitives**: RSA-2048/4096, ECC (P-256, P-384, P-521, secp256k1), Ed25519, OpenPGP (RFC 4880/9580), and AES-256-GCM / ChaCha20-Poly1305.
+- **Envelope Encryption**: Direct orchestration of multi-cloud Key Management Systems (AWS KMS, GCP KMS, Azure Key Vault, HashiCorp Vault).
+- **Cryptographic Bill of Materials (CBOM)**: Automated discovery and inventory of cryptographic assets for DORA Articles 9/13 and CRA compliance.
+- **Zero Runtime Dependencies**: Lightweight, secure stdio architecture operating with strict input schema validation.
+
+---
+
+## Installation
+
+```bash
+# Global installation for MCP client configuration
+npm install -g @sebastienrousseau/crypto-mcp
+
+# Or use with npx directly
+npx @sebastienrousseau/crypto-mcp
+```
+
+---
+
+## Configuration
+
+### Claude Desktop / Cursor / Antigravity (`mcpServers` config)
+
+Add the server to your `claude_desktop_config.json` or `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "crypto-service": {
+      "command": "npx",
+      "args": ["-y", "@sebastienrousseau/crypto-mcp"]
+    }
+  }
+}
+```
+
+---
+
+## Tools Exposed
+
+| Tool Name             | Description                                                   | Key Parameters                                        |
+| --------------------- | ------------------------------------------------------------- | ----------------------------------------------------- |
+| `crypto_generate_key` | Generate classical or post-quantum keypairs                   | `type` (rsa, ecc, ed25519, ml-kem-768), `passphrase`  |
+| `crypto_encrypt`      | Encrypt data with symmetric, asymmetric, or hybrid algorithms | `data`, `key`, `algorithm`, `armor`                   |
+| `crypto_decrypt`      | Decrypt encrypted ciphertexts or armored blocks               | `ciphertext`, `key`, `passphrase`                     |
+| `crypto_sign`         | Create cryptographic signatures (clearsign, detached, raw)    | `data`, `privateKey`, `passphrase`, `detached`        |
+| `crypto_verify`       | Verify digital signatures against public keys                 | `data`, `signature`, `publicKey`                      |
+| `crypto_hash`         | Compute cryptographic hashes or post-quantum signatures       | `data`, `algorithm` (sha256, sha512, blake2b, blake3) |
+| `crypto_kms_wrap`     | Wrap a local data encryption key using cloud KMS              | `provider` (aws, gcp, azure, vault), `keyId`, `dek`   |
+| `crypto_kms_unwrap`   | Unwrap a wrapped data encryption key using cloud KMS          | `provider`, `keyId`, `wrappedKey`                     |
+| `crypto_inspect_key`  | Parse armored OpenPGP keys or PEM certificates                | `keyData`                                             |
+| `crypto_audit_cbom`   | Audit a directory for cryptographic assets and produce CBOM   | `targetPath`, `format` (cyclonedx, spdx, summary)     |
+
+---
+
+## Resources Exposed
+
+- `crypto://standards/pqc`: Complete NIST FIPS 203, 204, 205 specification parameters and CNSA 2.0 migration timelines.
+- `crypto://algorithms/matrix`: Comprehensive security strength, key size, and deprecation matrix.
+
+---
+
+## Prompts Exposed
+
+- `pqc-migration-plan`: Guided analysis prompt to evaluate legacy cryptographic risk and produce a phased transition roadmap.
+- `dora-compliance-check`: Fiduciary audit checklist reviewing cryptographic agility, third-party risk, and CBOM completeness under Regulation (EU) 2022/2554.
+
+---
+
+## Security & Memory Hygiene
+
+`@sebastienrousseau/crypto-mcp` enforces strict separation of concerns:
+
+- **No Private Key Retention**: Private keys and sensitive plaintext inputs are processed in-memory and never cached across MCP requests.
+- **Input Validation**: Strict JSON schema bounds on all inputs prevent buffer overflow and injection attacks.
+- **Stdio Transport Isolation**: The server communicates over standard input/output with zero open network ports.
+
+---
+
+## Development
+
+```bash
+pnpm --filter @sebastienrousseau/crypto-mcp run build
+pnpm --filter @sebastienrousseau/crypto-mcp run test
+pnpm --filter @sebastienrousseau/crypto-mcp run lint
+pnpm --filter @sebastienrousseau/crypto-mcp run format
+```
+
+All 18 packages in the Crypto Service workspace maintain a **100% coverage floor** across statements, branches, functions, and lines.
+
+---
+
+## Documentation
+
+- [Full Suite Documentation](https://docs.crypto-service.co/)
+- [API Reference (TypeDoc)](https://docs.crypto-service.co/packages/crypto-mcp/)
+- [Developer Guide](../../DEVELOPMENT.md)
+- [Security Policy](../../SECURITY.md)
+- [Architecture & Design](../../ARCHITECTURE.md)
+
+---
+
+## Stability guarantees
+
+Versions advance strictly one step at a time on the `0.0.x` line (`v0.0.1` → `v0.0.2` → `v0.0.3` ... → `v0.0.999` → `v0.1.0`). Work for every release iteration begins on a dedicated `feat/v<version>` branch.
+
+All 18 packages in the workspace move in lockstep. Public API signatures, cipher output formats, and serialization schemas are strictly versioned. Breaking changes to serialized formats or algorithm defaults are considered major breaking changes. Minimum toolchain upgrades (e.g. Node.js LTS floor) are governed by [POLICIES.md](../../docs/POLICIES.md).
+
+---
+
+## License
+
+Dual-licensed under [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0) or [MIT](https://opensource.org/licenses/MIT), at your option.
+
+Copyright (c) 2022-2026 Sebastien Rousseau and The Crypto Service Suite contributors.

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function run(): void;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAKA,wBAAgB,GAAG,IAAI,IAAI,CAG1B"}

package/dist/cli.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const server_1 = require("./server");
+function run() {
+    const server = new server_1.CryptoMcpServer();
+    server.listenStdio(process.stdin, process.stdout);
+}
+if (require.main === module) {
+    run();
+}
+//# sourceMappingURL=cli.js.map

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./types";
+export * from "./tools";
+export * from "./resources";
+export * from "./prompts";
+export * from "./server";
+export * from "./cli";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,OAAO,CAAC"}

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./tools"), exports);
+__exportStar(require("./resources"), exports);
+__exportStar(require("./prompts"), exports);
+__exportStar(require("./server"), exports);
+__exportStar(require("./cli"), exports);
+//# sourceMappingURL=index.js.map

package/dist/prompts/index.d.ts

@@ -0,0 +1,4 @@
+import { MCPPrompt, MCPGetPromptResult } from "../types";
+export declare const PROMPTS: MCPPrompt[];
+export declare function getPrompt(name: string, args?: Record<string, string>): Promise<MCPGetPromptResult>;
+//# sourceMappingURL=index.d.ts.map

package/dist/prompts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/prompts/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAEzD,eAAO,MAAM,OAAO,EAAE,SAAS,EA2B9B,CAAC;AAEF,wBAAsB,SAAS,CAC7B,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GAChC,OAAO,CAAC,kBAAkB,CAAC,CAkC7B"}

package/dist/prompts/index.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROMPTS = void 0;
+exports.getPrompt = getPrompt;
+exports.PROMPTS = [
+    {
+        name: "pqc-migration-plan",
+        description: "Generate a phased Post-Quantum Cryptography (PQC) migration roadmap tailored to an enterprise repository or architecture.",
+        arguments: [
+            {
+                name: "targetSystem",
+                description: "Name or architecture description of the system being migrated (e.g. 'Wholesale Payment Gateway' or 'API Microservices').",
+                required: true,
+            },
+        ],
+    },
+    {
+        name: "dora-compliance-check",
+        description: "Generate a fiduciary audit checklist for DORA Articles 9 and 13 cryptographic resilience and CBOM tracking.",
+        arguments: [
+            {
+                name: "organizationType",
+                description: "Type of financial entity (e.g. 'Credit Institution', 'Payment Service Provider', 'Investment Firm').",
+                required: false,
+            },
+        ],
+    },
+];
+async function getPrompt(name, args = {}) {
+    if (name === "pqc-migration-plan") {
+        const target = args.targetSystem || "Enterprise Application";
+        return {
+            description: `Post-Quantum Cryptography Migration Plan for ${target}`,
+            messages: [
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: `Please design a 4-phase Post-Quantum Cryptography (PQC) migration plan for ${target} in accordance with NIST FIPS 203/204/205 standards and NSA CNSA 2.0 timelines:\n\n1. Cryptographic Asset Discovery & CBOM Generation\n2. Hybrid Key Exchange (X25519MLKEM768 in TLS 1.3 per RFC 10024; hybrid X25519 + ML-KEM-768 for data at rest)\n3. Hardware & Memory Zeroization Audit (Wasm linear memory vs V8 GC heap)\n4. Complete Deprecation of Classical Public Key Infrastructure.`,
+                    },
+                },
+            ],
+        };
+    }
+    if (name === "dora-compliance-check") {
+        const org = args.organizationType || "Financial Entity";
+        return {
+            description: `DORA Articles 9 & 13 Cryptographic Resilience Audit for ${org}`,
+            messages: [
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: `Perform a DORA Regulation (EU) 2022/2554 compliance evaluation for ${org}:\n\n- Article 9: Technical cryptographic measures, encryption-in-transit, encryption-at-rest, and key management lifecycle.\n- Article 13: Continuous cryptographic agility and supply chain dependency auditing.\n- Cryptographic Bill of Materials (CBOM) inventory completeness in CycloneDX 1.6 format.`,
+                    },
+                },
+            ],
+        };
+    }
+    throw new Error(`Prompt not found: ${name}`);
+}
+//# sourceMappingURL=index.js.map

package/dist/resources/index.d.ts

@@ -0,0 +1,4 @@
+import { MCPResource, MCPReadResourceResult } from "../types";
+export declare const RESOURCES: MCPResource[];
+export declare function readResource(uri: string): Promise<MCPReadResourceResult>;
+//# sourceMappingURL=index.d.ts.map

package/dist/resources/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resources/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAE9D,eAAO,MAAM,SAAS,EAAE,WAAW,EAelC,CAAC;AAEF,wBAAsB,YAAY,CAChC,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,qBAAqB,CAAC,CAmMhC"}

package/dist/resources/index.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESOURCES = void 0;
+exports.readResource = readResource;
+exports.RESOURCES = [
+    {
+        uri: "crypto://standards/pqc",
+        name: "NIST Post-Quantum Cryptography Standards & Parameters",
+        description: "Specification parameters for FIPS 203 (ML-KEM), FIPS 204 (ML-DSA), FIPS 205 (SLH-DSA), and FIPS 206 (FN-DSA).",
+        mimeType: "application/json",
+    },
+    {
+        uri: "crypto://algorithms/matrix",
+        name: "Cryptographic Algorithm Security & Deprecation Matrix",
+        description: "Comprehensive security strength, key size, and deprecation schedule for enterprise cryptography.",
+        mimeType: "application/json",
+    },
+];
+async function readResource(uri) {
+    if (uri === "crypto://standards/pqc") {
+        const data = {
+            standards: [
+                {
+                    name: "ML-KEM",
+                    fips: 203,
+                    type: "Key Encapsulation Mechanism",
+                    basis: "Module Learning with Errors (M-LWE)",
+                    variants: [
+                        {
+                            level: 1,
+                            name: "ML-KEM-512",
+                            publicKeyBytes: 800,
+                            ciphertextBytes: 768,
+                            sharedSecretBytes: 32,
+                        },
+                        {
+                            level: 3,
+                            name: "ML-KEM-768",
+                            publicKeyBytes: 1184,
+                            ciphertextBytes: 1088,
+                            sharedSecretBytes: 32,
+                        },
+                        {
+                            level: 5,
+                            name: "ML-KEM-1024",
+                            publicKeyBytes: 1568,
+                            ciphertextBytes: 1568,
+                            sharedSecretBytes: 32,
+                        },
+                    ],
+                },
+                {
+                    name: "ML-DSA",
+                    fips: 204,
+                    type: "Digital Signature",
+                    basis: "Module Learning with Errors (M-LWE)",
+                    variants: [
+                        {
+                            level: 2,
+                            name: "ML-DSA-44",
+                            publicKeyBytes: 1312,
+                            signatureBytes: 2420,
+                        },
+                        {
+                            level: 3,
+                            name: "ML-DSA-65",
+                            publicKeyBytes: 1952,
+                            signatureBytes: 3309,
+                        },
+                        {
+                            level: 5,
+                            name: "ML-DSA-87",
+                            publicKeyBytes: 2592,
+                            signatureBytes: 4627,
+                        },
+                    ],
+                },
+                {
+                    name: "SLH-DSA",
+                    fips: 205,
+                    type: "Stateless Hash-Based Digital Signature",
+                    basis: "Hash Trees (SPHINCS+)",
+                    variants: [
+                        {
+                            level: 1,
+                            name: "SLH-DSA-128s",
+                            publicKeyBytes: 32,
+                            signatureBytes: 7856,
+                        },
+                        {
+                            level: 5,
+                            name: "SLH-DSA-256s",
+                            publicKeyBytes: 64,
+                            signatureBytes: 29792,
+                        },
+                    ],
+                },
+            ],
+            timelines: {
+                nsaCnsa2: {
+                    softwareTransition: 2027,
+                    webAndProtocols: 2030,
+                    legacyDeprecation: 2033,
+                },
+                doraEnforcement: 2025,
+                cyberResilienceAct: 2027,
+            },
+        };
+        return {
+            contents: [
+                {
+                    uri,
+                    mimeType: "application/json",
+                    text: JSON.stringify(data, null, 2),
+                },
+            ],
+        };
+    }
+    if (uri === "crypto://algorithms/matrix") {
+        const matrix = {
+            symmetric: [
+                {
+                    name: "AES-256-GCM",
+                    securityBits: 256,
+                    quantumSafe: true,
+                    recommended: true,
+                },
+                {
+                    name: "ChaCha20-Poly1305",
+                    securityBits: 256,
+                    quantumSafe: true,
+                    recommended: true,
+                },
+                {
+                    name: "3DES",
+                    securityBits: 112,
+                    quantumSafe: false,
+                    recommended: false,
+                    status: "DEPRECATED",
+                },
+            ],
+            asymmetric: [
+                {
+                    name: "ML-KEM-768",
+                    securityBits: 192,
+                    quantumSafe: true,
+                    recommended: true,
+                    standard: "FIPS 203",
+                },
+                {
+                    name: "RSA-2048",
+                    securityBits: 112,
+                    quantumSafe: false,
+                    recommended: false,
+                    status: "PHASING_OUT",
+                },
+                {
+                    name: "RSA-4096",
+                    securityBits: 128,
+                    quantumSafe: false,
+                    recommended: false,
+                    status: "PHASING_OUT",
+                },
+                {
+                    name: "ECDSA (P-256)",
+                    securityBits: 128,
+                    quantumSafe: false,
+                    recommended: false,
+                    status: "PHASING_OUT",
+                },
+                {
+                    name: "Ed25519",
+                    securityBits: 128,
+                    quantumSafe: false,
+                    recommended: false,
+                    status: "PHASING_OUT",
+                },
+            ],
+            hashes: [
+                {
+                    name: "SHA-256",
+                    securityBits: 256,
+                    quantumSafe: true,
+                    status: "SECURE",
+                },
+                {
+                    name: "SHA-512",
+                    securityBits: 512,
+                    quantumSafe: true,
+                    status: "SECURE",
+                },
+                {
+                    name: "SHA-1",
+                    securityBits: 0,
+                    quantumSafe: false,
+                    status: "BROKEN",
+                },
+                { name: "MD5", securityBits: 0, quantumSafe: false, status: "BROKEN" },
+            ],
+        };
+        return {
+            contents: [
+                {
+                    uri,
+                    mimeType: "application/json",
+                    text: JSON.stringify(matrix, null, 2),
+                },
+            ],
+        };
+    }
+    throw new Error(`Resource not found: ${uri}`);
+}
+//# sourceMappingURL=index.js.map

package/dist/server.d.ts

@@ -0,0 +1,11 @@
+import { JSONRPCRequest, JSONRPCResponse } from "./types";
+export declare const SERVER_VERSION: string;
+export declare class CryptoMcpServer {
+    private initialized;
+    private readonly name;
+    private readonly version;
+    isInitialized(): boolean;
+    handleRequest(request: JSONRPCRequest): Promise<JSONRPCResponse>;
+    listenStdio(input?: NodeJS.ReadableStream, output?: NodeJS.WritableStream): void;
+}
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,cAAc,EAAE,eAAe,EAAuB,MAAM,SAAS,CAAC;AAU/E,eAAO,MAAM,cAAc,EAAE,MAIpB,CAAC;AAEV,qBAAa,eAAe;IAC1B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAoB;IACzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkB;IAKnC,aAAa,IAAI,OAAO;IAOlB,aAAa,CACxB,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,eAAe,CAAC;IAuGpB,WAAW,CAChB,KAAK,GAAE,MAAM,CAAC,cAA8B,EAC5C,MAAM,GAAE,MAAM,CAAC,cAA+B,GAC7C,IAAI;CAwBR"}

package/dist/server.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoMcpServer = exports.SERVER_VERSION = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_readline_1 = __importDefault(require("node:readline"));
+const tools_1 = require("./tools");
+const resources_1 = require("./resources");
+const prompts_1 = require("./prompts");
+exports.SERVER_VERSION = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(__dirname, "..", "package.json"), "utf8")).version;
+class CryptoMcpServer {
+    initialized = false;
+    name = "crypto-service";
+    version = exports.SERVER_VERSION;
+    isInitialized() {
+        return this.initialized;
+    }
+    async handleRequest(request) {
+        const id = request.id ?? null;
+        if (!request.jsonrpc || request.jsonrpc !== "2.0") {
+            return {
+                jsonrpc: "2.0",
+                id,
+                error: {
+                    code: -32600,
+                    message: "Invalid Request: jsonrpc must be '2.0'",
+                },
+            };
+        }
+        try {
+            switch (request.method) {
+                case "initialize": {
+                    this.initialized = true;
+                    const result = {
+                        protocolVersion: "2024-11-05",
+                        capabilities: {
+                            tools: {},
+                            resources: {},
+                            prompts: {},
+                        },
+                        serverInfo: {
+                            name: this.name,
+                            version: this.version,
+                        },
+                    };
+                    return { jsonrpc: "2.0", id, result };
+                }
+                case "ping": {
+                    return { jsonrpc: "2.0", id, result: {} };
+                }
+                case "tools/list": {
+                    return { jsonrpc: "2.0", id, result: { tools: tools_1.TOOLS } };
+                }
+                case "tools/call": {
+                    const params = request.params;
+                    const toolName = params ? String(params.name) : "";
+                    const toolArgs = params && params.arguments
+                        ? params.arguments
+                        : {};
+                    const result = await (0, tools_1.executeTool)(toolName, toolArgs);
+                    return { jsonrpc: "2.0", id, result };
+                }
+                case "resources/list": {
+                    return { jsonrpc: "2.0", id, result: { resources: resources_1.RESOURCES } };
+                }
+                case "resources/read": {
+                    const params = request.params;
+                    const uri = params ? String(params.uri) : "";
+                    const result = await (0, resources_1.readResource)(uri);
+                    return { jsonrpc: "2.0", id, result };
+                }
+                case "prompts/list": {
+                    return { jsonrpc: "2.0", id, result: { prompts: prompts_1.PROMPTS } };
+                }
+                case "prompts/get": {
+                    const params = request.params;
+                    const promptName = params ? String(params.name) : "";
+                    const promptArgs = params && params.arguments
+                        ? params.arguments
+                        : {};
+                    const result = await (0, prompts_1.getPrompt)(promptName, promptArgs);
+                    return { jsonrpc: "2.0", id, result };
+                }
+                default:
+                    return {
+                        jsonrpc: "2.0",
+                        id,
+                        error: {
+                            code: -32601,
+                            message: `Method not found: ${request.method}`,
+                        },
+                    };
+            }
+        }
+        catch (err) {
+            return {
+                jsonrpc: "2.0",
+                id,
+                error: {
+                    code: -32603,
+                    message: err.message,
+                },
+            };
+        }
+    }
+    listenStdio(input = process.stdin, output = process.stdout) {
+        const rl = node_readline_1.default.createInterface({
+            input,
+            output: undefined,
+            terminal: false,
+        });
+        rl.on("line", async (line) => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            try {
+                const req = JSON.parse(trimmed);
+                const res = await this.handleRequest(req);
+                output.write(JSON.stringify(res) + "\n");
+            }
+            catch (e) {
+                const parseError = {
+                    jsonrpc: "2.0",
+                    id: null,
+                    error: { code: -32700, message: "Parse error: invalid JSON" },
+                };
+                output.write(JSON.stringify(parseError) + "\n");
+            }
+        });
+    }
+}
+exports.CryptoMcpServer = CryptoMcpServer;
+//# sourceMappingURL=server.js.map

package/dist/tools/cbom.d.ts

@@ -0,0 +1,3 @@
+import { ToolHandler } from "./result";
+export declare const auditCbom: ToolHandler;
+//# sourceMappingURL=cbom.d.ts.map

package/dist/tools/cbom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cbom.d.ts","sourceRoot":"","sources":["../../src/tools/cbom.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAc,MAAM,UAAU,CAAC;AAqCnD,eAAO,MAAM,SAAS,EAAE,WAevB,CAAC"}