@mcp-i/core 0.1.0 → 1.1.0-canary.2

package/dist/providers/node-crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-crypto.d.ts","sourceRoot":"","sources":["../../src/providers/node-crypto.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAWH,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAW3C,qBAAa,kBAAmB,SAAQ,cAAc;IAC9C,IAAI,CACR,IAAI,EAAE,UAAU,EAChB,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,UAAU,CAAC;IAgBhB,MAAM,CACV,IAAI,EAAE,UAAU,EAChB,SAAS,EAAE,UAAU,EACrB,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,OAAO,CAAC;IAsBb,eAAe,IAAI,OAAO,CAAC;QAC/B,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IAYI,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAOvC,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;CAGvD"}

package/dist/providers/node-crypto.js

@@ -0,0 +1,69 @@
+/**
+ * Node.js CryptoProvider
+ *
+ * Ed25519 crypto backed by Node.js built-in `node:crypto`.
+ * Use this on any Node.js 20+ server.
+ *
+ * @example
+ * ```typescript
+ * import { NodeCryptoProvider } from '@mcp-i/core/providers';
+ * import { withMCPI } from '@mcp-i/core/middleware';
+ *
+ * await withMCPI(server, { crypto: new NodeCryptoProvider() });
+ * ```
+ */
+import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync, sign, verify, randomBytes, } from "node:crypto";
+import { CryptoProvider } from "./base.js";
+/** PKCS8 DER header for Ed25519 private keys (16 bytes) */
+const ED25519_PKCS8_PREFIX = Buffer.from("302e020100300506032b657004220420", "hex");
+/** SPKI DER header for Ed25519 public keys (12 bytes) */
+const ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
+export class NodeCryptoProvider extends CryptoProvider {
+    async sign(data, privateKeyBase64) {
+        const privateKey = Buffer.from(privateKeyBase64, "base64");
+        // Handle both raw 32-byte and full 64-byte Ed25519 keys
+        const keyBytes = privateKey.length === 64 ? privateKey.subarray(0, 32) : privateKey;
+        const keyObject = createPrivateKey({
+            key: Buffer.concat([ED25519_PKCS8_PREFIX, keyBytes]),
+            format: "der",
+            type: "pkcs8",
+        });
+        return new Uint8Array(sign(null, Buffer.from(data), keyObject));
+    }
+    async verify(data, signature, publicKeyBase64) {
+        try {
+            const keyObject = createPublicKey({
+                key: Buffer.concat([
+                    ED25519_SPKI_PREFIX,
+                    Buffer.from(publicKeyBase64, "base64"),
+                ]),
+                format: "der",
+                type: "spki",
+            });
+            return verify(null, Buffer.from(data), keyObject, Buffer.from(signature));
+        }
+        catch {
+            return false;
+        }
+    }
+    async generateKeyPair() {
+        const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
+            publicKeyEncoding: { type: "spki", format: "der" },
+            privateKeyEncoding: { type: "pkcs8", format: "der" },
+        });
+        return {
+            privateKey: privateKey.subarray(16, 48).toString("base64"),
+            publicKey: publicKey.subarray(12, 44).toString("base64"),
+        };
+    }
+    async hash(data) {
+        const hex = createHash("sha256")
+            .update(Buffer.from(data))
+            .digest("hex");
+        return `sha256:${hex}`;
+    }
+    async randomBytes(length) {
+        return new Uint8Array(randomBytes(length));
+    }
+}
+//# sourceMappingURL=node-crypto.js.map

package/dist/providers/node-crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-crypto.js","sourceRoot":"","sources":["../../src/providers/node-crypto.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mcp-i/core",
-  "version": "0.1.0",
-  "description": "Core library for MCP-I — delegation, proof, and session primitives for Model Context Protocol Identity",
+  "version": "1.1.0-canary.2",
+  "description": "MCP-I protocol reference implementation — delegation, proof, and session for Model Context Protocol Identity",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -62,6 +62,7 @@
     "example:inspector": "npx @modelcontextprotocol/inspector npx tsx examples/node-server/server.ts --stdio"
   },
   "dependencies": {
+    "@mcp-i/core": "^1.1.0-canary.1",
     "jose": "^5.6.3",
     "json-canonicalize": "^2.0.0"
   },
@@ -76,14 +77,18 @@
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@modelcontextprotocol/sdk": "^1.12.1",
+    "@types/express": "^5.0.6",
     "@types/node": "^20.14.9",
     "@typescript-eslint/eslint-plugin": "^8.57.0",
     "@typescript-eslint/parser": "^8.57.0",
     "@vitest/coverage-v8": "^2.0.0",
+    "commander": "^14.0.3",
     "eslint": "^10.0.3",
+    "express": "^5.2.1",
     "typescript": "^5.5.3",
     "typescript-eslint": "^8.57.0",
-    "vitest": "^2.0.0"
+    "vitest": "^2.0.0",
+    "zod": "^4.3.6"
   },
   "keywords": [
     "mcp-i",

package/src/__tests__/integration/mcp-enhance-server.test.ts

@@ -0,0 +1,311 @@
+/**
+ * withMCPI() Integration Tests
+ *
+ * Tests the dream API: `withMCPI(server, { crypto })` auto-registers
+ * the handshake tool and auto-attaches proofs to all tool responses.
+ */
+
+import { describe, it, expect, afterEach } from 'vitest';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+import { z } from 'zod';
+import { withMCPI, generateIdentity } from '../../middleware/with-mcpi-server.js';
+import { NodeCryptoProvider } from '../utils/node-crypto-provider.js';
+
+// ── Helpers ──────────────────────────────────────────────────────
+
+async function createTestPair(options?: {
+  proofAllTools?: boolean;
+  excludeTools?: string[];
+  autoSession?: boolean;
+  registerToolsBeforeWithMCPI?: boolean;
+}) {
+  const crypto = new NodeCryptoProvider();
+  const server = new McpServer(
+    { name: 'withMCPI-test', version: '1.0.0' },
+    { instructions: 'Test server for withMCPI integration' },
+  );
+
+  // Register tools BEFORE withMCPI to test pre-existing tool interception
+  if (options?.registerToolsBeforeWithMCPI) {
+    server.registerTool(
+      'greet',
+      {
+        description: 'Greet someone',
+        inputSchema: { name: z.string() },
+      },
+      async ({ name }) => ({
+        content: [{ type: 'text', text: `Hello, ${name}!` }],
+      }),
+    );
+  }
+
+  const mcpi = await withMCPI(server, {
+    crypto,
+    autoSession: options?.autoSession ?? true,
+    proofAllTools: options?.proofAllTools,
+    excludeTools: options?.excludeTools,
+  });
+
+  // Register tools AFTER withMCPI to test late registration
+  if (!options?.registerToolsBeforeWithMCPI) {
+    server.registerTool(
+      'greet',
+      {
+        description: 'Greet someone',
+        inputSchema: { name: z.string() },
+      },
+      async ({ name }) => ({
+        content: [{ type: 'text', text: `Hello, ${name}!` }],
+      }),
+    );
+  }
+
+  server.registerTool(
+    'add',
+    {
+      description: 'Add two numbers',
+      inputSchema: { a: z.number(), b: z.number() },
+    },
+    async ({ a, b }) => ({
+      content: [{ type: 'text', text: `${a + b}` }],
+    }),
+  );
+
+  const client = new Client(
+    { name: 'withMCPI-test-client', version: '1.0.0' },
+  );
+
+  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+  await server.connect(serverTransport);
+  await client.connect(clientTransport);
+
+  return { client, server, mcpi, crypto };
+}
+
+// ── Tests ──────────────────────────────────────────────────────
+
+describe('withMCPI()', () => {
+  const pairs: Array<{ client: Client; server: McpServer }> = [];
+
+  afterEach(async () => {
+    for (const pair of pairs) {
+      await pair.client.close();
+      await pair.server.close();
+    }
+    pairs.length = 0;
+  });
+
+  async function create(options?: Parameters<typeof createTestPair>[0]) {
+    const pair = await createTestPair(options);
+    pairs.push(pair);
+    return pair;
+  }
+
+  it('auto-registers _mcpi_handshake tool', async () => {
+    const { client } = await create();
+
+    const result = await client.listTools();
+    const toolNames = result.tools.map((t) => t.name);
+
+    expect(toolNames).toContain('_mcpi_handshake');
+  });
+
+  it('auto-proofs all registered tools', async () => {
+    const { client } = await create();
+
+    const result = await client.callTool({
+      name: 'greet',
+      arguments: { name: 'World' },
+    });
+
+    const first = result.content[0] as { type: string; text: string };
+    expect(first.text).toBe('Hello, World!');
+
+    // Proof should be present via auto-session + auto-proof
+    expect(result._meta).toBeDefined();
+    const proof = (result._meta as Record<string, unknown>).proof as {
+      jws: string;
+      meta: Record<string, unknown>;
+    };
+    expect(proof).toBeDefined();
+    expect(proof.jws).toBeDefined();
+    expect(proof.meta.did).toMatch(/^did:key:/);
+    expect(proof.meta.sessionId).toMatch(/^mcpi_/);
+  });
+
+  it('tools registered before withMCPI also get proofs', async () => {
+    const { client } = await create({ registerToolsBeforeWithMCPI: true });
+
+    const result = await client.callTool({
+      name: 'greet',
+      arguments: { name: 'Early Bird' },
+    });
+
+    const first = result.content[0] as { type: string; text: string };
+    expect(first.text).toBe('Hello, Early Bird!');
+
+    expect(result._meta).toBeDefined();
+    const proof = (result._meta as Record<string, unknown>).proof as {
+      jws: string;
+    };
+    expect(proof).toBeDefined();
+    expect(proof.jws).toBeDefined();
+  });
+
+  it('excludeTools skips proof for specified tools', async () => {
+    const { client } = await create({ excludeTools: ['greet'] });
+
+    // 'greet' should NOT have proof
+    const greetResult = await client.callTool({
+      name: 'greet',
+      arguments: { name: 'No Proof' },
+    });
+
+    const greetContent = greetResult.content[0] as { type: string; text: string };
+    expect(greetContent.text).toBe('Hello, No Proof!');
+
+    // _meta may be undefined or proof should not be present
+    const greetProof = (greetResult._meta as Record<string, unknown> | undefined)?.proof;
+    expect(greetProof).toBeUndefined();
+
+    // 'add' should still have proof
+    const addResult = await client.callTool({
+      name: 'add',
+      arguments: { a: 2, b: 3 },
+    });
+
+    expect(addResult._meta).toBeDefined();
+    const addProof = (addResult._meta as Record<string, unknown>).proof as {
+      jws: string;
+    };
+    expect(addProof).toBeDefined();
+    expect(addProof.jws).toBeDefined();
+  });
+
+  it('proofAllTools: false disables auto-proofing', async () => {
+    const { client } = await create({ proofAllTools: false });
+
+    const result = await client.callTool({
+      name: 'greet',
+      arguments: { name: 'No Auto-Proof' },
+    });
+
+    const first = result.content[0] as { type: string; text: string };
+    expect(first.text).toBe('Hello, No Auto-Proof!');
+
+    // No proof — auto-proofing is off
+    const proof = (result._meta as Record<string, unknown> | undefined)?.proof;
+    expect(proof).toBeUndefined();
+  });
+
+  it('handshake establishes session through withMCPI', async () => {
+    const { client, mcpi } = await create({ autoSession: false });
+
+    const result = await client.callTool({
+      name: '_mcpi_handshake',
+      arguments: {
+        nonce: `test-${Date.now()}`,
+        audience: mcpi.identity.did,
+        timestamp: Math.floor(Date.now() / 1000),
+      },
+    });
+
+    const first = result.content[0] as { type: string; text: string };
+    const parsed = JSON.parse(first.text);
+    expect(parsed.success).toBe(true);
+    expect(parsed.sessionId).toMatch(/^mcpi_/);
+    expect(parsed.serverDid).toBe(mcpi.identity.did);
+  });
+
+  it('multiple tools share the same auto-session', async () => {
+    const { client } = await create();
+
+    const result1 = await client.callTool({
+      name: 'greet',
+      arguments: { name: 'Alice' },
+    });
+    const result2 = await client.callTool({
+      name: 'add',
+      arguments: { a: 1, b: 2 },
+    });
+
+    const proof1 = (result1._meta as Record<string, unknown>).proof as {
+      meta: Record<string, unknown>;
+    };
+    const proof2 = (result2._meta as Record<string, unknown>).proof as {
+      meta: Record<string, unknown>;
+    };
+
+    expect(proof1.meta.sessionId).toBe(proof2.meta.sessionId);
+  });
+
+  it('wrapWithDelegation still works alongside withMCPI', async () => {
+    const crypto = new NodeCryptoProvider();
+    const server = new McpServer(
+      { name: 'delegation-test', version: '1.0.0' },
+    );
+
+    const mcpi = await withMCPI(server, { crypto, autoSession: true });
+
+    // Use wrapWithDelegation for a restricted tool
+    const restrictedHandler = mcpi.wrapWithDelegation(
+      'restricted-tool',
+      { scopeId: 'admin:write', consentUrl: 'https://example.com/consent' },
+      async (args) => ({
+        content: [{ type: 'text', text: `Restricted: ${(args as { data: string }).data}` }],
+      }),
+    );
+
+    server.registerTool(
+      'restricted-tool',
+      {
+        description: 'Requires delegation',
+        inputSchema: { data: z.string() },
+      },
+      async (args) => restrictedHandler(args as Record<string, unknown>),
+    );
+
+    const client = new Client({ name: 'delegation-client', version: '1.0.0' });
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    await server.connect(serverTransport);
+    await client.connect(clientTransport);
+    pairs.push({ client, server });
+
+    // Call without delegation — should get needs_authorization
+    const result = await client.callTool({
+      name: 'restricted-tool',
+      arguments: { data: 'test' },
+    });
+
+    const first = result.content[0] as { type: string; text: string };
+    const parsed = JSON.parse(first.text);
+    expect(parsed.error).toBe('needs_authorization');
+    expect(parsed.authorizationUrl).toBe('https://example.com/consent');
+  });
+});
+
+describe('generateIdentity()', () => {
+  it('returns valid DID identity', async () => {
+    const crypto = new NodeCryptoProvider();
+    const identity = await generateIdentity(crypto);
+
+    expect(identity.did).toMatch(/^did:key:z6Mk/);
+    expect(identity.kid).toBe(`${identity.did}#keys-1`);
+    expect(identity.privateKey).toBeDefined();
+    expect(identity.publicKey).toBeDefined();
+    // Keys should be base64 strings
+    expect(() => atob(identity.privateKey)).not.toThrow();
+    expect(() => atob(identity.publicKey)).not.toThrow();
+  });
+
+  it('generates unique identities each call', async () => {
+    const crypto = new NodeCryptoProvider();
+    const id1 = await generateIdentity(crypto);
+    const id2 = await generateIdentity(crypto);
+
+    expect(id1.did).not.toBe(id2.did);
+    expect(id1.privateKey).not.toBe(id2.privateKey);
+  });
+});