@kya-os/mcp-i-core 1.3.12 → 1.3.14

package/src/__tests__/integration.test.ts

@@ -1,281 +0,0 @@
-/**
- * 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

@@ -1,173 +0,0 @@
-/**
- * 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' });
-    });
-  });
-});