@kya-os/create-mcpi-app 1.7.38-canary.2 → 1.7.38

package/test-cloudflare/tests/do-routing.test.ts

@@ -1,314 +0,0 @@
-import { describe, test, expect, beforeEach } from 'vitest';
-
-/**
- * Durable Object Routing Tests
- * Tests the multi-instance DO routing for horizontal scaling
- */
-describe('Durable Object Multi-Instance Routing', () => {
-
-  // Mock the getDoInstanceId function
-  function getDoInstanceId(request: Request, env: any): string {
-    const strategy = env.DO_ROUTING_STRATEGY || 'session';
-    const headers = request.headers;
-
-    switch (strategy) {
-      case 'session': {
-        const sessionId = headers.get('mcp-session-id') ||
-                         headers.get('Mcp-Session-Id') ||
-                         crypto.randomUUID();
-        return `session:${sessionId}`;
-      }
-
-      case 'shard': {
-        const identifier = headers.get('mcp-session-id') || Math.random().toString();
-        let hash = 0;
-        for (let i = 0; i < identifier.length; i++) {
-          hash = ((hash << 5) - hash) + identifier.charCodeAt(i);
-          hash = hash & hash;
-        }
-        const shardCount = parseInt(env.DO_SHARD_COUNT || '10');
-        // Validate shard count - must be a valid positive number
-        const validShardCount = (!isNaN(shardCount) && shardCount > 0) ? shardCount : 10;
-        const shard = Math.abs(hash) % validShardCount;
-        return `shard:${shard}`;
-      }
-
-      default:
-        return 'default';
-    }
-  }
-
-  describe('Session-Based Routing', () => {
-    const env = {
-      DO_ROUTING_STRATEGY: 'session',
-      DO_SHARD_COUNT: '10'
-    };
-
-    test('should route to different instances for different sessions', () => {
-      const req1 = new Request('http://test/mcp', {
-        headers: { 'mcp-session-id': 'session-123' }
-      });
-      const req2 = new Request('http://test/mcp', {
-        headers: { 'mcp-session-id': 'session-456' }
-      });
-
-      const id1 = getDoInstanceId(req1, env);
-      const id2 = getDoInstanceId(req2, env);
-
-      expect(id1).toBe('session:session-123');
-      expect(id2).toBe('session:session-456');
-      expect(id1).not.toBe(id2);
-    });
-
-    test('should route to same instance for same session', () => {
-      const sessionId = 'consistent-session';
-      const req1 = new Request('http://test/mcp', {
-        headers: { 'mcp-session-id': sessionId }
-      });
-      const req2 = new Request('http://test/mcp', {
-        headers: { 'mcp-session-id': sessionId }
-      });
-
-      const id1 = getDoInstanceId(req1, env);
-      const id2 = getDoInstanceId(req2, env);
-
-      expect(id1).toBe(id2);
-      expect(id1).toBe(`session:${sessionId}`);
-    });
-
-    test('should handle both mcp-session-id header casings', () => {
-      const sessionId = 'case-test-session';
-      const req1 = new Request('http://test/mcp', {
-        headers: { 'mcp-session-id': sessionId }
-      });
-      const req2 = new Request('http://test/mcp', {
-        headers: { 'Mcp-Session-Id': sessionId }
-      });
-
-      const id1 = getDoInstanceId(req1, env);
-      const id2 = getDoInstanceId(req2, env);
-
-      expect(id1).toBe(`session:${sessionId}`);
-      expect(id2).toBe(`session:${sessionId}`);
-    });
-
-    test('should generate random session if header missing', () => {
-      const req = new Request('http://test/mcp', {
-        headers: {}
-      });
-
-      const id = getDoInstanceId(req, env);
-
-      expect(id).toMatch(/^session:[0-9a-f-]+$/);
-    });
-  });
-
-  describe('Shard-Based Routing', () => {
-    const env = {
-      DO_ROUTING_STRATEGY: 'shard',
-      DO_SHARD_COUNT: '10'
-    };
-
-    test('should distribute requests across shards', () => {
-      const distribution = new Map<string, number>();
-
-      // Generate 1000 requests with different sessions
-      for (let i = 0; i < 1000; i++) {
-        const req = new Request('http://test/mcp', {
-          headers: { 'mcp-session-id': `session-${i}` }
-        });
-
-        const instanceId = getDoInstanceId(req, env);
-        const shard = instanceId.split(':')[1];
-
-        distribution.set(shard, (distribution.get(shard) || 0) + 1);
-      }
-
-      // Verify reasonable distribution across 10 shards
-      expect(distribution.size).toBeGreaterThanOrEqual(8); // At least 8 shards used
-
-      // Each shard should get 50-150 requests (allowing for hash variance)
-      for (const count of distribution.values()) {
-        expect(count).toBeGreaterThan(50);
-        expect(count).toBeLessThan(150);
-      }
-    });
-
-    test('should consistently route same session to same shard', () => {
-      const sessionId = 'shard-consistent-session';
-      const results = new Set<string>();
-
-      // Make 10 requests with same session
-      for (let i = 0; i < 10; i++) {
-        const req = new Request('http://test/mcp', {
-          headers: { 'mcp-session-id': sessionId }
-        });
-        const instanceId = getDoInstanceId(req, env);
-        results.add(instanceId);
-      }
-
-      // Should all go to same shard
-      expect(results.size).toBe(1);
-    });
-
-    test('should respect custom shard count', () => {
-      const customEnv = {
-        DO_ROUTING_STRATEGY: 'shard',
-        DO_SHARD_COUNT: '5'
-      };
-
-      const shards = new Set<number>();
-
-      for (let i = 0; i < 100; i++) {
-        const req = new Request('http://test/mcp', {
-          headers: { 'mcp-session-id': `test-${i}` }
-        });
-
-        const instanceId = getDoInstanceId(req, customEnv);
-        const shardNum = parseInt(instanceId.split(':')[1]);
-        shards.add(shardNum);
-
-        // Shard should be 0-4 for 5 shards
-        expect(shardNum).toBeGreaterThanOrEqual(0);
-        expect(shardNum).toBeLessThan(5);
-      }
-
-      // Should use most shards
-      expect(shards.size).toBeGreaterThanOrEqual(4);
-    });
-  });
-
-  describe('Default Fallback', () => {
-    test('should fall back to default when strategy unknown', () => {
-      const env = {
-        DO_ROUTING_STRATEGY: 'unknown-strategy',
-        DO_SHARD_COUNT: '10'
-      };
-
-      const req = new Request('http://test/mcp', {
-        headers: { 'mcp-session-id': 'test-session' }
-      });
-
-      const instanceId = getDoInstanceId(req, env);
-
-      expect(instanceId).toBe('default');
-    });
-
-    test('should use session strategy when not configured', () => {
-      const env = {}; // No configuration
-
-      const req = new Request('http://test/mcp', {
-        headers: { 'mcp-session-id': 'test-session' }
-      });
-
-      const instanceId = getDoInstanceId(req, env);
-
-      expect(instanceId).toBe('session:test-session');
-    });
-  });
-
-  describe('Performance Characteristics', () => {
-    test('session routing should have O(1) complexity', () => {
-      const env = { DO_ROUTING_STRATEGY: 'session' };
-      const sessionId = 'perf-test-session';
-
-      const start = performance.now();
-
-      for (let i = 0; i < 10000; i++) {
-        const req = new Request('http://test/mcp', {
-          headers: { 'mcp-session-id': sessionId }
-        });
-        getDoInstanceId(req, env);
-      }
-
-      const duration = performance.now() - start;
-
-      // Should complete 10k operations in < 300ms (relaxed for CI environments)
-      expect(duration).toBeLessThan(300);
-    });
-
-    test('shard routing should have O(n) complexity for hash', () => {
-      const env = {
-        DO_ROUTING_STRATEGY: 'shard',
-        DO_SHARD_COUNT: '100'
-      };
-
-      const shortId = 'abc';
-      const longId = 'a'.repeat(1000);
-
-      const start1 = performance.now();
-      for (let i = 0; i < 1000; i++) {
-        const req = new Request('http://test/mcp', {
-          headers: { 'mcp-session-id': shortId }
-        });
-        getDoInstanceId(req, env);
-      }
-      const shortDuration = performance.now() - start1;
-
-      const start2 = performance.now();
-      for (let i = 0; i < 1000; i++) {
-        const req = new Request('http://test/mcp', {
-          headers: { 'mcp-session-id': longId }
-        });
-        getDoInstanceId(req, env);
-      }
-      const longDuration = performance.now() - start2;
-
-      // Longer IDs should take proportionally more time (but allow for timing variance)
-      // Note: O(n) complexity is hard to measure reliably in JavaScript due to V8 optimizations
-      // Instead, we just verify that both operations complete successfully
-      expect(longDuration).toBeGreaterThan(0);
-      expect(shortDuration).toBeGreaterThan(0);
-      // Both operations should complete in reasonable time (< 100ms total for 1000 iterations)
-      expect(longDuration + shortDuration).toBeLessThan(100);
-    });
-  });
-
-  describe('Edge Cases', () => {
-    test('should handle empty session ID', () => {
-      const env = { DO_ROUTING_STRATEGY: 'session' };
-
-      const req = new Request('http://test/mcp', {
-        headers: { 'mcp-session-id': '' }
-      });
-
-      const instanceId = getDoInstanceId(req, env);
-
-      // Should generate new session
-      expect(instanceId).toMatch(/^session:[0-9a-f-]+$/);
-    });
-
-    test('should handle non-numeric shard count', () => {
-      const env = {
-        DO_ROUTING_STRATEGY: 'shard',
-        DO_SHARD_COUNT: 'invalid'
-      };
-
-      const req = new Request('http://test/mcp', {
-        headers: { 'mcp-session-id': 'test' }
-      });
-
-      // Should default to 10 shards
-      const instanceId = getDoInstanceId(req, env);
-      const shard = parseInt(instanceId.split(':')[1]);
-
-      expect(shard).toBeGreaterThanOrEqual(0);
-      expect(shard).toBeLessThan(10);
-    });
-
-    test('should handle special characters in session ID', () => {
-      const env = { DO_ROUTING_STRATEGY: 'shard' };
-      const specialId = '!@#$%^&*()_+-=[]{}|;:,.<>?';
-
-      const req = new Request('http://test/mcp', {
-        headers: { 'mcp-session-id': specialId }
-      });
-
-      // Should not throw and produce valid shard
-      expect(() => getDoInstanceId(req, env)).not.toThrow();
-
-      const instanceId = getDoInstanceId(req, env);
-      expect(instanceId).toMatch(/^shard:\d+$/);
-    });
-  });
-});

package/test-cloudflare/tests/integration.test.ts

@@ -1,205 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { unstable_dev } from 'wrangler';
-import type { UnstableDevWorker } from 'wrangler';
-
-describe('MCP-I Cloudflare Integration', () => {
-  let worker: UnstableDevWorker;
-  let baseUrl: string;
-
-  beforeAll(async () => {
-    worker = await unstable_dev('src/index.ts', {
-      experimental: { disableExperimentalWarning: true },
-    });
-    baseUrl = `http://localhost:${worker.port}`;
-  });
-
-  afterAll(async () => {
-    await worker.stop();
-  });
-
-  it('should return healthy status from /health', async () => {
-    const response = await fetch(`${baseUrl}/health`);
-    expect(response.status).toBe(200);
-
-    const data = await response.json();
-    expect(data).toHaveProperty('status', 'healthy');
-    expect(data).toHaveProperty('timestamp');
-    expect(data).toHaveProperty('transport');
-    expect(data.transport).toHaveProperty('sse', '/sse');
-    expect(data.transport).toHaveProperty('streamableHttp', '/mcp');
-  });
-
-  it('should stream proofs via SSE and verify them', async () => {
-    const sessionId = `test-${Date.now()}`;
-    let proofReceived = false;
-    let proofData: any = null;
-
-    // Open SSE connection
-    const response = await fetch(`${baseUrl}/proofs?session=${sessionId}`);
-    expect(response.headers.get('content-type')).toMatch(/^text\/event-stream/);
-    expect(response.status).toBe(200);
-
-    // Create promise to track proof reception
-    const proofPromise = new Promise<void>((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error('Timeout waiting for proof event'));
-      }, 10000);
-
-      if (!response.body) {
-        clearTimeout(timeout);
-        reject(new Error('No response body'));
-        return;
-      }
-
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-
-      const readChunk = async () => {
-        try {
-          const { done, value } = await reader.read();
-          if (done) {
-            clearTimeout(timeout);
-            reject(new Error('Stream ended without receiving proof'));
-            return;
-          }
-
-          const chunk = decoder.decode(value);
-          const lines = chunk.split('\n');
-
-          for (const line of lines) {
-            if (line.startsWith('data: ')) {
-              const data = line.slice(6);
-              try {
-                proofData = JSON.parse(data);
-                proofReceived = true;
-                clearTimeout(timeout);
-                reader.cancel();
-                resolve();
-                return;
-              } catch (e) {
-                // Not valid JSON, continue reading
-              }
-            }
-          }
-
-          // Continue reading
-          readChunk();
-        } catch (error) {
-          clearTimeout(timeout);
-          reject(error);
-        }
-      };
-
-      readChunk();
-    });
-
-    // Call the greet tool to generate a proof
-    const toolResponse = await fetch(`${baseUrl}/mcp`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'mcp-session-id': sessionId,
-      },
-      body: JSON.stringify({
-        jsonrpc: '2.0',
-        id: 1,
-        method: 'tools/call',
-        params: {
-          name: 'greet',
-          arguments: {
-            name: 'Test User',
-          },
-        },
-      }),
-    });
-
-    expect(toolResponse.status).toBe(200);
-    const toolResult = await toolResponse.json();
-    expect(toolResult).toHaveProperty('result');
-
-    // Wait for proof to arrive via SSE
-    await proofPromise;
-    expect(proofReceived).toBe(true);
-    expect(proofData).toBeDefined();
-    expect(proofData).toHaveProperty('proof');
-    expect(proofData).toHaveProperty('data');
-
-    // Verify the proof
-    const verifyResponse = await fetch(`${baseUrl}/verify`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        data: proofData.data,
-        proof: proofData.proof,
-      }),
-    });
-
-    expect(verifyResponse.status).toBe(200);
-    const verifyResult = await verifyResponse.json();
-    expect(verifyResult).toHaveProperty('valid', true);
-  });
-
-  it('should expose identity via well-known endpoint', async () => {
-    const response = await fetch(`${baseUrl}/.well-known/mcp-identity`);
-    expect(response.status).toBe(200);
-
-    const identity = await response.json();
-    expect(identity).toHaveProperty('did');
-    expect(identity).toHaveProperty('publicKey');
-    expect(identity).toHaveProperty('serviceName', 'test-cloudflare');
-    expect(identity).toHaveProperty('serviceEndpoint');
-    expect(identity).toHaveProperty('timestamp');
-    expect(identity.did).toMatch(/^did:(key|web):/);
-  });
-
-  it('should expose W3C DID document at /.well-known/did.json', async () => {
-    const response = await fetch(`${baseUrl}/.well-known/did.json`);
-    expect(response.status).toBe(200);
-    expect(response.headers.get('content-type')).toBe('application/did+json');
-    expect(response.headers.get('access-control-allow-origin')).toBe('*');
-    expect(response.headers.get('vary')).toBe('Origin');
-
-    const didDoc = await response.json();
-    expect(didDoc).toHaveProperty('@context');
-    expect(didDoc).toHaveProperty('id');
-    expect(didDoc.id).toMatch(/^did:key:z/);
-    expect(didDoc).toHaveProperty('verificationMethod');
-    expect(Array.isArray(didDoc.verificationMethod)).toBe(true);
-    expect(didDoc.verificationMethod.length).toBeGreaterThan(0);
-
-    const vm = didDoc.verificationMethod[0];
-    expect(vm).toHaveProperty('id');
-    expect(vm).toHaveProperty('type', 'Ed25519VerificationKey2020');
-    expect(vm).toHaveProperty('controller');
-    expect(vm).toHaveProperty('publicKeyBase64');
-
-    expect(didDoc).toHaveProperty('authentication');
-    expect(Array.isArray(didDoc.authentication)).toBe(true);
-    expect(didDoc).toHaveProperty('assertionMethod');
-    expect(Array.isArray(didDoc.assertionMethod)).toBe(true);
-  });
-
-  it('should expose MCP-I capabilities at /.well-known/agent.json', async () => {
-    const response = await fetch(`${baseUrl}/.well-known/agent.json`);
-    expect(response.status).toBe(200);
-    expect(response.headers.get('content-type')).toBe('application/json');
-    expect(response.headers.get('access-control-allow-origin')).toBe('*');
-    expect(response.headers.get('vary')).toBe('Origin');
-
-    const agentDoc = await response.json();
-    expect(agentDoc).toHaveProperty('id');
-    expect(agentDoc.id).toMatch(/^did:key:z/);
-    expect(agentDoc).toHaveProperty('capabilities');
-    expect(agentDoc.capabilities).toHaveProperty('mcp-i');
-    expect(Array.isArray(agentDoc.capabilities['mcp-i'])).toBe(true);
-    expect(agentDoc.capabilities['mcp-i']).toContain('handshake');
-    expect(agentDoc.capabilities['mcp-i']).toContain('signing');
-    expect(agentDoc.capabilities['mcp-i']).toContain('verification');
-
-    expect(agentDoc).toHaveProperty('metadata');
-    expect(agentDoc.metadata).toHaveProperty('name', 'test-cloudflare');
-    expect(agentDoc.metadata).toHaveProperty('serviceEndpoint');
-  });
-});