@kya-os/mcp-i-core 1.2.3-canary.6 → 1.3.0

package/src/__tests__/integration.test.ts

@@ -0,0 +1,281 @@
+/**
+ * Integration tests demonstrating full runtime usage
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { MCPIRuntimeBase } from '../runtime/base';
+import {
+  MemoryStorageProvider,
+  MemoryNonceCacheProvider,
+  MemoryIdentityProvider
+} from '../providers/memory';
+import { MockCryptoProvider, MockClockProvider, MockFetchProvider } from './utils/mock-providers';
+
+describe('Integration Tests', () => {
+  let runtime: MCPIRuntimeBase;
+  let cryptoProvider: MockCryptoProvider;
+  let clockProvider: MockClockProvider;
+  let fetchProvider: MockFetchProvider;
+
+  beforeEach(async () => {
+    // Set up providers
+    cryptoProvider = new MockCryptoProvider();
+    clockProvider = new MockClockProvider();
+    fetchProvider = new MockFetchProvider();
+
+    // Create runtime with real memory providers
+    runtime = new MCPIRuntimeBase({
+      cryptoProvider,
+      clockProvider,
+      fetchProvider,
+      storageProvider: new MemoryStorageProvider(),
+      nonceCacheProvider: new MemoryNonceCacheProvider(),
+      identityProvider: new MemoryIdentityProvider(cryptoProvider),
+      environment: 'development',
+      timestampSkewSeconds: 120,
+      sessionTtlMinutes: 30,
+      audit: {
+        enabled: true,
+        includePayloads: true
+      }
+    });
+
+    await runtime.initialize();
+  });
+
+  describe('Full handshake and tool execution flow', () => {
+    it('should complete full authentication and tool execution cycle', async () => {
+      // Step 1: Client initiates handshake
+      const handshakeRequest = {
+        clientDid: 'did:key:zclient789',
+        audience: 'https://app.example.com'
+      };
+
+      const handshakeResponse = await runtime.handleHandshake(handshakeRequest);
+      
+      expect(handshakeResponse.sessionId).toBeDefined();
+      expect(handshakeResponse.agentDid).toMatch(/^did:key:z/);
+      expect(handshakeResponse.signature).toBeDefined();
+      expect(handshakeResponse.capabilities).toContain('identity');
+
+      // Step 2: Get session and issue nonce
+      const session = await runtime.getCurrentSession();
+      expect(session).toBeDefined();
+      
+      const nonce = await runtime.issueNonce(session!.id);
+      session!.nonce = nonce;
+
+      // Step 3: Execute tool with session
+      const toolHandler = async (args: any) => {
+        return { 
+          message: `Hello ${args.name}!`,
+          timestamp: Date.now()
+        };
+      };
+
+      const result = await runtime.processToolCall(
+        'greetingTool',
+        { name: 'Alice' },
+        toolHandler,
+        session
+      );
+
+      expect(result.message).toBe('Hello Alice!');
+
+      // Step 4: Verify proof was created
+      const proof = runtime.getLastProof();
+      expect(proof).toBeDefined();
+      expect(proof.nonce).toBe(nonce);
+      expect(proof.sessionId).toBe(session!.id);
+      expect(proof.audience).toBe('https://app.example.com');
+
+      // Step 5: Set up DID resolution for verification
+      const identity = await runtime.getIdentity();
+      fetchProvider.setDIDDocument(identity.did, {
+        '@context': ['https://www.w3.org/ns/did/v1'],
+        id: identity.did,
+        verificationMethod: [{
+          id: `${identity.did}#key-1`,
+          type: 'Ed25519VerificationKey2020',
+          controller: identity.did,
+          publicKeyBase64: identity.publicKey
+        }]
+      });
+
+      // Step 6: Clear nonce cache to simulate fresh verification
+      // In real-world usage, verification would happen on a different system
+      const nonceCacheProvider = (runtime as any).nonceCache as MemoryNonceCacheProvider;
+      await nonceCacheProvider.destroy();
+      
+      // Step 7: Verify the proof
+      const isValid = await runtime.verifyProof(result, proof);
+      expect(isValid).toBe(true);
+    });
+  });
+
+  describe('Session expiry handling', () => {
+    it('should handle expired sessions correctly', async () => {
+      // Create session
+      await runtime.handleHandshake({
+        clientDid: 'did:key:zclient',
+        audience: 'https://app.example.com'
+      });
+
+      // Verify session exists
+      let session = await runtime.getCurrentSession();
+      expect(session).toBeDefined();
+
+      // Advance time past expiry
+      clockProvider.setTime(Date.now() + (31 * 60 * 1000));
+
+      // Session should now be expired
+      session = await runtime.getCurrentSession();
+      expect(session).toBeNull();
+    });
+  });
+
+  describe('Key rotation flow', () => {
+    it('should handle key rotation and maintain functionality', async () => {
+      // Get initial identity
+      const oldIdentity = await runtime.getIdentity();
+      expect(oldIdentity.did).toMatch(/^did:key:z/);
+
+      // Create session with old identity
+      const handshakeResponse = await runtime.handleHandshake({
+        clientDid: 'did:key:zclient',
+        audience: 'https://app.example.com'
+      });
+      expect(handshakeResponse.agentDid).toBe(oldIdentity.did);
+
+      // Rotate keys
+      const newIdentity = await runtime.rotateKeys();
+      expect(newIdentity.did).not.toBe(oldIdentity.did);
+
+      // New handshakes should use new identity
+      const newHandshakeResponse = await runtime.handleHandshake({
+        clientDid: 'did:key:zclient2',
+        audience: 'https://app2.example.com'
+      });
+      expect(newHandshakeResponse.agentDid).toBe(newIdentity.did);
+    });
+  });
+
+  describe('Well-known endpoints', () => {
+    it('should provide identity discovery endpoints', async () => {
+      const handler = runtime.createWellKnownHandler({
+        serviceName: 'Test MCP Service',
+        serviceEndpoint: 'https://mcp.example.com'
+      });
+
+      // Test DID document endpoint
+      const didDocResponse = await handler('/.well-known/did.json');
+      expect(didDocResponse).toBeDefined();
+      expect(didDocResponse.body).toBeDefined();
+
+      const didDoc = JSON.parse(didDocResponse.body);
+      expect(didDoc.id).toMatch(/^did:key:z/);
+      expect(didDoc.verificationMethod).toHaveLength(1);
+      expect(didDoc.verificationMethod[0].type).toBe('Ed25519VerificationKey2020');
+
+      // Test MCP identity endpoint
+      const mcpIdentity = await handler('/.well-known/mcp-identity');
+      expect(mcpIdentity).toBeDefined();
+      expect(mcpIdentity.did).toBe(didDoc.id);
+      expect(mcpIdentity.serviceName).toBe('Test MCP Service');
+      expect(mcpIdentity.serviceEndpoint).toBe('https://mcp.example.com');
+    });
+  });
+
+  describe('Nonce replay protection', () => {
+    it('should prevent nonce reuse', async () => {
+      // Create a proof with a specific nonce
+      const nonce = await runtime.issueNonce('session123');
+      const data = { test: 'data' };
+      const proof = await runtime.createProof(data, { nonce });
+
+      // First use of nonce should fail (already in cache from issueNonce)
+      const isValid = await runtime.verifyProof(data, proof);
+      expect(isValid).toBe(false);
+
+      // Create proof with fresh nonce
+      const freshProof = await runtime.createProof(data);
+      
+      // Set up DID resolution
+      const identity = await runtime.getIdentity();
+      fetchProvider.setDIDDocument(identity.did, {
+        verificationMethod: [{
+          publicKeyBase64: identity.publicKey
+        }]
+      });
+
+      // Clear nonce cache to simulate fresh verification
+      const nonceCacheProvider = (runtime as any).nonceCache as MemoryNonceCacheProvider;
+      await nonceCacheProvider.destroy();
+      
+      // Fresh nonce should verify successfully
+      const isValidFresh = await runtime.verifyProof(data, freshProof);
+      expect(isValidFresh).toBe(true);
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should handle network errors gracefully', async () => {
+      // Set up fetch to fail
+      fetchProvider.resolveDID = async () => {
+        throw new Error('Network error');
+      };
+
+      const data = { test: 'data' };
+      const proof = await runtime.createProof(data);
+
+      // Verification should fail gracefully
+      const isValid = await runtime.verifyProof(data, proof);
+      expect(isValid).toBe(false);
+    });
+
+    it('should handle malformed DID documents', async () => {
+      const identity = await runtime.getIdentity();
+      
+      // Set up malformed DID document
+      fetchProvider.setDIDDocument(identity.did, {
+        // Missing verificationMethod
+      });
+
+      const data = { test: 'data' };
+      const proof = await runtime.createProof(data);
+
+      // Should fail verification due to missing public key
+      const isValid = await runtime.verifyProof(data, proof);
+      expect(isValid).toBe(false);
+    });
+  });
+
+  describe('Debug endpoint', () => {
+    it('should provide debug information in development', async () => {
+      const debugEndpoint = runtime.createDebugEndpoint();
+      expect(debugEndpoint).toBeDefined();
+
+      const debugInfo = await debugEndpoint!();
+      expect(debugInfo).toBeDefined();
+      expect(debugInfo.identity).toBeDefined();
+      expect(debugInfo.identity.did).toMatch(/^did:key:z/);
+      expect(debugInfo.config.environment).toBe('development');
+      expect(debugInfo.timestamp).toBe(clockProvider.now());
+    });
+
+    it('should be disabled in production', () => {
+      const prodRuntime = new MCPIRuntimeBase({
+        cryptoProvider,
+        clockProvider,
+        fetchProvider,
+        storageProvider: new MemoryStorageProvider(),
+        nonceCacheProvider: new MemoryNonceCacheProvider(),
+        identityProvider: new MemoryIdentityProvider(cryptoProvider),
+        environment: 'production'
+      });
+
+      const debugEndpoint = prodRuntime.createDebugEndpoint();
+      expect(debugEndpoint).toBeNull();
+    });
+  });
+});

package/src/__tests__/providers/base.test.ts

@@ -0,0 +1,173 @@
+/**
+ * Tests for Base Provider Classes
+ * 
+ * These tests verify that the abstract base classes are properly defined
+ * and that implementations must provide all required methods.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  CryptoProvider,
+  ClockProvider,
+  FetchProvider,
+  StorageProvider,
+  NonceCacheProvider,
+  IdentityProvider
+} from '../../providers/base';
+
+describe('Base Provider Classes', () => {
+  describe('CryptoProvider', () => {
+    it('should be defined as a class', () => {
+      expect(CryptoProvider).toBeDefined();
+      expect(typeof CryptoProvider).toBe('function');
+    });
+
+    it('should require implementation of abstract methods', () => {
+      // TypeScript abstract methods don't exist at runtime
+      // They're enforced at compile-time, not runtime
+      class TestCrypto extends CryptoProvider {}
+      const instance = new TestCrypto();
+
+      // These methods are undefined because they're abstract
+      expect(instance.sign).toBeUndefined();
+      expect(instance.verify).toBeUndefined();
+      expect(instance.generateKeyPair).toBeUndefined();
+      expect(instance.hash).toBeUndefined();
+      expect(instance.randomBytes).toBeUndefined();
+    });
+
+    it('should work when properly implemented', async () => {
+      class TestCrypto extends CryptoProvider {
+        async sign(data: Uint8Array, privateKey: string): Promise<Uint8Array> {
+          return new Uint8Array([1, 2, 3]);
+        }
+        async verify(data: Uint8Array, signature: Uint8Array, publicKey: string): Promise<boolean> {
+          return true;
+        }
+        async generateKeyPair(): Promise<{ privateKey: string; publicKey: string }> {
+          return { privateKey: 'test-private', publicKey: 'test-public' };
+        }
+        async hash(data: Uint8Array): Promise<Uint8Array> {
+          return new Uint8Array([4, 5, 6]);
+        }
+        async randomBytes(length: number): Promise<Uint8Array> {
+          return new Uint8Array(length);
+        }
+      }
+
+      const instance = new TestCrypto();
+      expect(await instance.sign(new Uint8Array(), '')).toEqual(new Uint8Array([1, 2, 3]));
+      expect(await instance.verify(new Uint8Array(), new Uint8Array(), '')).toBe(true);
+      expect(await instance.generateKeyPair()).toEqual({ privateKey: 'test-private', publicKey: 'test-public' });
+      expect(await instance.hash(new Uint8Array())).toEqual(new Uint8Array([4, 5, 6]));
+      expect(await instance.randomBytes(5)).toHaveLength(5);
+    });
+  });
+
+  describe('ClockProvider', () => {
+    it('should be defined as a class', () => {
+      expect(ClockProvider).toBeDefined();
+      expect(typeof ClockProvider).toBe('function');
+    });
+
+    it('should require implementation of abstract methods', () => {
+      class TestClock extends ClockProvider {}
+      const instance = new TestClock();
+
+      expect(instance.now).toBeUndefined();
+      expect(instance.isWithinSkew).toBeUndefined();
+      expect(instance.hasExpired).toBeUndefined();
+      expect(instance.calculateExpiry).toBeUndefined();
+      expect(instance.format).toBeUndefined();
+    });
+  });
+
+  describe('FetchProvider', () => {
+    it('should be defined as a class', () => {
+      expect(FetchProvider).toBeDefined();
+      expect(typeof FetchProvider).toBe('function');
+    });
+
+    it('should require implementation of abstract methods', () => {
+      class TestFetch extends FetchProvider {}
+      const instance = new TestFetch();
+
+      expect(instance.resolveDID).toBeUndefined();
+      expect(instance.fetchStatusList).toBeUndefined();
+      expect(instance.fetchDelegationChain).toBeUndefined();
+      expect(instance.fetch).toBeUndefined();
+    });
+  });
+
+  describe('StorageProvider', () => {
+    it('should be defined as a class', () => {
+      expect(StorageProvider).toBeDefined();
+      expect(typeof StorageProvider).toBe('function');
+    });
+
+    it('should require implementation of abstract methods', () => {
+      class TestStorage extends StorageProvider {}
+      const instance = new TestStorage();
+
+      expect(instance.get).toBeUndefined();
+      expect(instance.set).toBeUndefined();
+      expect(instance.delete).toBeUndefined();
+      expect(instance.exists).toBeUndefined();
+      expect(instance.list).toBeUndefined();
+    });
+  });
+
+  describe('NonceCacheProvider', () => {
+    it('should be defined as a class', () => {
+      expect(NonceCacheProvider).toBeDefined();
+      expect(typeof NonceCacheProvider).toBe('function');
+    });
+
+    it('should require implementation of abstract methods', () => {
+      class TestNonceCache extends NonceCacheProvider {}
+      const instance = new TestNonceCache();
+
+      expect(instance.has).toBeUndefined();
+      expect(instance.add).toBeUndefined();
+      expect(instance.cleanup).toBeUndefined();
+      expect(instance.destroy).toBeUndefined();
+    });
+  });
+
+  describe('IdentityProvider', () => {
+    it('should be defined as a class', () => {
+      expect(IdentityProvider).toBeDefined();
+      expect(typeof IdentityProvider).toBe('function');
+    });
+
+    it('should require implementation of abstract methods', () => {
+      class TestIdentity extends IdentityProvider {}
+      const instance = new TestIdentity();
+
+      expect(instance.getIdentity).toBeUndefined();
+      expect(instance.saveIdentity).toBeUndefined();
+      expect(instance.rotateKeys).toBeUndefined();
+      expect(instance.deleteIdentity).toBeUndefined();
+    });
+  });
+
+  describe('AgentIdentity interface', () => {
+    it('should have proper type structure', () => {
+      const validIdentity = {
+        did: 'did:key:z123',
+        kid: 'did:key:z123#key-1',
+        privateKey: 'private-key',
+        publicKey: 'public-key',
+        createdAt: new Date().toISOString(),
+        type: 'development' as const,
+        metadata: { foo: 'bar' }
+      };
+
+      // Type checking is done at compile time
+      // This test just verifies the shape is correct
+      expect(validIdentity.did).toBe('did:key:z123');
+      expect(validIdentity.type).toBe('development');
+      expect(validIdentity.metadata).toEqual({ foo: 'bar' });
+    });
+  });
+});