@kya-os/mcp-i 0.1.0-alpha.3.9 → 1.2.0

package/dist/runtime/__tests__/identity.test.js

@@ -0,0 +1,164 @@
+"use strict";
+/**
+ * Tests for Identity Management System
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const identity_js_1 = require("../identity.js");
+// Mock environment variables
+const originalEnv = process.env;
+(0, vitest_1.describe)("IdentityManager", () => {
+    let tempDir;
+    let identityManager;
+    (0, vitest_1.beforeEach)(async () => {
+        // Create temp directory for tests
+        tempDir = (0, path_1.join)(process.cwd(), ".test-mcpi");
+        await (0, promises_1.mkdir)(tempDir, { recursive: true });
+        // Reset environment
+        process.env = { ...originalEnv };
+        delete process.env.AGENT_PRIVATE_KEY;
+        delete process.env.AGENT_KEY_ID;
+        delete process.env.AGENT_DID;
+        delete process.env.KYA_VOUCHED_API_KEY;
+    });
+    (0, vitest_1.afterEach)(async () => {
+        // Cleanup
+        try {
+            if ((0, fs_1.existsSync)(tempDir)) {
+                await (0, promises_1.rmdir)(tempDir, { recursive: true });
+            }
+        }
+        catch (error) {
+            // Ignore cleanup errors
+        }
+        // Restore environment
+        process.env = originalEnv;
+    });
+    (0, vitest_1.describe)("Development Environment", () => {
+        (0, vitest_1.beforeEach)(() => {
+            identityManager = new identity_js_1.IdentityManager({
+                environment: "development",
+                devIdentityPath: (0, path_1.join)(tempDir, "identity.json"),
+            });
+        });
+        (0, vitest_1.it)("should generate new identity when none exists", async () => {
+            const identity = await identityManager.ensureIdentity();
+            (0, vitest_1.expect)(identity).toBeDefined();
+            (0, vitest_1.expect)(identity.did).toMatch(/^did:web:localhost:3000:agents:key-[a-f0-9]{8}$/);
+            (0, vitest_1.expect)(identity.keyId).toMatch(/^key-[a-f0-9]{8}$/);
+            (0, vitest_1.expect)(identity.privateKey).toBeTruthy();
+            (0, vitest_1.expect)(identity.publicKey).toBeTruthy();
+            (0, vitest_1.expect)(identity.createdAt).toBeTruthy();
+            // Verify keys are base64 encoded
+            (0, vitest_1.expect)(() => Buffer.from(identity.privateKey, "base64")).not.toThrow();
+            (0, vitest_1.expect)(() => Buffer.from(identity.publicKey, "base64")).not.toThrow();
+        });
+        (0, vitest_1.it)("should load existing identity from file", async () => {
+            // Generate first identity
+            const identity1 = await identityManager.ensureIdentity();
+            // Create new manager instance
+            const identityManager2 = new identity_js_1.IdentityManager({
+                environment: "development",
+                devIdentityPath: (0, path_1.join)(tempDir, "identity.json"),
+            });
+            // Should load the same identity
+            const identity2 = await identityManager2.ensureIdentity();
+            (0, vitest_1.expect)(identity2.did).toBe(identity1.did);
+            (0, vitest_1.expect)(identity2.keyId).toBe(identity1.keyId);
+            (0, vitest_1.expect)(identity2.privateKey).toBe(identity1.privateKey);
+            (0, vitest_1.expect)(identity2.publicKey).toBe(identity1.publicKey);
+        });
+        (0, vitest_1.it)("should cache identity after first load", async () => {
+            const identity1 = await identityManager.ensureIdentity();
+            const identity2 = await identityManager.ensureIdentity();
+            (0, vitest_1.expect)(identity1).toBe(identity2); // Same object reference
+        });
+        (0, vitest_1.it)("should regenerate identity if file is corrupted", async () => {
+            const identityPath = (0, path_1.join)(tempDir, "identity.json");
+            // Write corrupted file
+            await import("fs/promises").then((fs) => fs.writeFile(identityPath, "invalid json", "utf-8"));
+            // Should generate new identity
+            const identity = await identityManager.ensureIdentity();
+            (0, vitest_1.expect)(identity).toBeDefined();
+            (0, vitest_1.expect)(identity.did).toMatch(/^did:web:localhost:3000:agents:key-[a-f0-9]{8}$/);
+        });
+        (0, vitest_1.it)("should validate identity correctly", async () => {
+            const identity = await identityManager.ensureIdentity();
+            const isValid = await identityManager.validateIdentity(identity);
+            (0, vitest_1.expect)(isValid).toBe(true);
+        });
+        (0, vitest_1.it)("should reject invalid identity", async () => {
+            const invalidIdentity = {
+                did: "invalid-did",
+                keyId: "key-1",
+                privateKey: "invalid-key",
+                publicKey: "invalid-key",
+                createdAt: new Date().toISOString(),
+            };
+            const isValid = await identityManager.validateIdentity(invalidIdentity);
+            (0, vitest_1.expect)(isValid).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)("Production Environment", () => {
+        (0, vitest_1.beforeEach)(() => {
+            identityManager = new identity_js_1.IdentityManager({
+                environment: "production",
+            });
+        });
+        (0, vitest_1.it)("should load identity from environment variables", async () => {
+            // Set up environment variables
+            process.env.AGENT_PRIVATE_KEY = Buffer.from("test-private-key-32-bytes-long!!").toString("base64");
+            process.env.AGENT_KEY_ID = "key-prod-123";
+            process.env.AGENT_DID = "did:web:example.com:agents:my-agent";
+            process.env.KYA_VOUCHED_API_KEY = "test-api-key";
+            const identity = await identityManager.ensureIdentity();
+            (0, vitest_1.expect)(identity.did).toBe("did:web:example.com:agents:my-agent");
+            (0, vitest_1.expect)(identity.keyId).toBe("key-prod-123");
+            (0, vitest_1.expect)(identity.privateKey).toBe(process.env.AGENT_PRIVATE_KEY);
+            (0, vitest_1.expect)(identity.publicKey).toBeTruthy();
+        });
+        (0, vitest_1.it)("should fail fast when environment variables are missing", async () => {
+            // Only set some variables
+            process.env.AGENT_DID = "did:web:example.com:agents:my-agent";
+            process.env.AGENT_KEY_ID = "key-prod-123";
+            await (0, vitest_1.expect)(identityManager.ensureIdentity()).rejects.toThrow(vitest_1.expect.objectContaining({
+                message: vitest_1.expect.stringContaining("Missing required environment variables"),
+                code: identity_js_1.IDENTITY_ERRORS.ENOIDENTITY,
+            }));
+        });
+        (0, vitest_1.it)("should list all missing environment variables", async () => {
+            const error = await identityManager.ensureIdentity().catch((e) => e);
+            (0, vitest_1.expect)(error.message).toContain("AGENT_PRIVATE_KEY, AGENT_KEY_ID, AGENT_DID, KYA_VOUCHED_API_KEY");
+        });
+    });
+    (0, vitest_1.describe)("Configuration", () => {
+        (0, vitest_1.it)("should use single public DID by default", () => {
+            const manager = new identity_js_1.IdentityManager();
+            const config = manager.getConfig();
+            (0, vitest_1.expect)(config.privacyMode).toBe(false);
+        });
+        (0, vitest_1.it)("should allow privacy mode configuration", () => {
+            const manager = new identity_js_1.IdentityManager({
+                environment: "development",
+                privacyMode: true,
+            });
+            const config = manager.getConfig();
+            (0, vitest_1.expect)(config.privacyMode).toBe(true);
+        });
+        (0, vitest_1.it)("should clear cache when requested", async () => {
+            const manager = new identity_js_1.IdentityManager({
+                environment: "development",
+                devIdentityPath: (0, path_1.join)(tempDir, "identity.json"),
+            });
+            const identity1 = await manager.ensureIdentity();
+            manager.clearCache();
+            const identity2 = await manager.ensureIdentity();
+            // Should be different object references but same content
+            (0, vitest_1.expect)(identity1).not.toBe(identity2);
+            (0, vitest_1.expect)(identity1.did).toBe(identity2.did);
+        });
+    });
+});

package/dist/runtime/__tests__/mcpi-runtime.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for XMCP-I Runtime Integration
+ */
+export {};

package/dist/runtime/__tests__/mcpi-runtime.test.js

@@ -0,0 +1,372 @@
+"use strict";
+/**
+ * Tests for XMCP-I Runtime Integration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const mcpi_runtime_js_1 = require("../mcpi-runtime.js");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+(0, vitest_1.describe)("MCPIRuntime", () => {
+    let runtime;
+    let mockLogFunction;
+    (0, vitest_1.beforeEach)(async () => {
+        mockLogFunction = vitest_1.vi.fn();
+        // Mock console.log to avoid noise in tests
+        vitest_1.vi.spyOn(console, "log").mockImplementation(() => { });
+        vitest_1.vi.spyOn(console, "error").mockImplementation(() => { });
+    });
+    (0, vitest_1.afterEach)(async () => {
+        if (runtime) {
+            await runtime.cleanup();
+        }
+        // Cleanup test directory
+        try {
+            if ((0, fs_1.existsSync)(".test-mcpi")) {
+                await (0, promises_1.rmdir)(".test-mcpi", { recursive: true });
+            }
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.describe)("Runtime Initialization", () => {
+        (0, vitest_1.it)("should initialize successfully with default config", async () => {
+            runtime = new mcpi_runtime_js_1.MCPIRuntime({
+                identity: {
+                    environment: "development",
+                    devIdentityPath: ".test-mcpi/identity.json",
+                },
+                audit: {
+                    logFunction: mockLogFunction,
+                },
+            });
+            await runtime.initialize();
+            const stats = runtime.getStats();
+            (0, vitest_1.expect)(stats.identity.did).toBeTruthy();
+            (0, vitest_1.expect)(stats.identity.keyId).toBeTruthy();
+            (0, vitest_1.expect)(stats.runtime.initialized).toBe(true);
+        });
+        (0, vitest_1.it)("should initialize with well-known endpoints", async () => {
+            runtime = new mcpi_runtime_js_1.MCPIRuntime({
+                identity: {
+                    environment: "development",
+                    devIdentityPath: ".test-mcpi/identity.json",
+                },
+                wellKnown: {
+                    environment: "development",
+                    baseUrl: "http://localhost:3000",
+                },
+            });
+            await runtime.initialize();
+            const stats = runtime.getStats();
+            (0, vitest_1.expect)(stats.runtime.wellKnownEnabled).toBe(true);
+            const handler = runtime.getWellKnownHandler();
+            (0, vitest_1.expect)(handler).toBeDefined();
+            (0, vitest_1.expect)(handler.handleDIDDocument).toBeTypeOf("function");
+            (0, vitest_1.expect)(handler.handleAgentDocument).toBeTypeOf("function");
+        });
+        (0, vitest_1.it)("should fail initialization without well-known config when accessing handler", async () => {
+            runtime = new mcpi_runtime_js_1.MCPIRuntime({
+                identity: {
+                    environment: "development",
+                    devIdentityPath: ".test-mcpi/identity.json",
+                },
+            });
+            await runtime.initialize();
+            (0, vitest_1.expect)(() => runtime.getWellKnownHandler()).toThrow("Well-known endpoints not configured");
+        });
+    });
+    (0, vitest_1.describe)("Handshake Validation", () => {
+        (0, vitest_1.beforeEach)(async () => {
+            runtime = new mcpi_runtime_js_1.MCPIRuntime({
+                identity: {
+                    environment: "development",
+                    devIdentityPath: ".test-mcpi/identity.json",
+                },
+                audit: {
+                    logFunction: mockLogFunction,
+                },
+            });
+            await runtime.initialize();
+        });
+        (0, vitest_1.it)("should validate correct handshake", async () => {
+            const request = {
+                nonce: "test-nonce-123",
+                audience: "example.com",
+                timestamp: Math.floor(Date.now() / 1000),
+            };
+            const session = await runtime.validateHandshake(request);
+            (0, vitest_1.expect)(session).toBeTruthy();
+            (0, vitest_1.expect)(session.audience).toBe("example.com");
+            (0, vitest_1.expect)(session.nonce).toBe("test-nonce-123");
+            (0, vitest_1.expect)(session.sessionId).toMatch(/^sess_/);
+        });
+        (0, vitest_1.it)("should reject invalid handshake", async () => {
+            const request = {
+                nonce: "test-nonce-old",
+                audience: "example.com",
+                timestamp: Math.floor(Date.now() / 1000) - 200, // Too old
+            };
+            const session = await runtime.validateHandshake(request);
+            (0, vitest_1.expect)(session).toBeNull();
+        });
+    });
+    (0, vitest_1.describe)("Tool Call Processing", () => {
+        let mockSession;
+        (0, vitest_1.beforeEach)(async () => {
+            runtime = new mcpi_runtime_js_1.MCPIRuntime({
+                identity: {
+                    environment: "development",
+                    devIdentityPath: ".test-mcpi/identity.json",
+                },
+                audit: {
+                    logFunction: mockLogFunction,
+                },
+            });
+            await runtime.initialize();
+            // Create a valid session
+            const handshakeRequest = {
+                nonce: "test-nonce-123",
+                audience: "example.com",
+                timestamp: Math.floor(Date.now() / 1000),
+            };
+            mockSession = await runtime.validateHandshake(handshakeRequest);
+        });
+        (0, vitest_1.it)("should process tool call with proof generation", async () => {
+            const toolRequest = {
+                method: "test-tool",
+                params: { input: "hello" },
+            };
+            const mockToolHandler = vitest_1.vi.fn().mockResolvedValue({ output: "world" });
+            const response = await runtime.processToolCall(toolRequest, mockSession, mockToolHandler);
+            (0, vitest_1.expect)(mockToolHandler).toHaveBeenCalledWith(toolRequest);
+            (0, vitest_1.expect)(response.data).toEqual({ output: "world" });
+            (0, vitest_1.expect)(response.meta?.proof).toBeDefined();
+            (0, vitest_1.expect)(response.meta?.proof?.meta.did).toBeTruthy();
+            (0, vitest_1.expect)(response.meta?.proof?.jws).toBeTruthy();
+        });
+        (0, vitest_1.it)("should include scope and delegation in proof", async () => {
+            const toolRequest = {
+                method: "test-tool",
+                params: { input: "hello" },
+            };
+            const mockToolHandler = vitest_1.vi.fn().mockResolvedValue({ output: "world" });
+            const response = await runtime.processToolCall(toolRequest, mockSession, mockToolHandler, {
+                scopeId: "orders.create",
+                delegationRef: "delegation-123",
+            });
+            (0, vitest_1.expect)(response.meta?.proof?.meta.scopeId).toBe("orders.create");
+            (0, vitest_1.expect)(response.meta?.proof?.meta.delegationRef).toBe("delegation-123");
+        });
+        (0, vitest_1.it)("should log audit record on tool call", async () => {
+            const toolRequest = {
+                method: "test-tool",
+                params: { input: "hello" },
+            };
+            const mockToolHandler = vitest_1.vi.fn().mockResolvedValue({ output: "world" });
+            await runtime.processToolCall(toolRequest, mockSession, mockToolHandler);
+            (0, vitest_1.expect)(mockLogFunction).toHaveBeenCalled();
+            const auditLine = mockLogFunction.mock.calls[0][0];
+            (0, vitest_1.expect)(auditLine).toContain("audit.v1");
+            (0, vitest_1.expect)(auditLine).toContain("verified=yes");
+        });
+        (0, vitest_1.it)("should handle tool call errors", async () => {
+            const toolRequest = {
+                method: "failing-tool",
+                params: { input: "hello" },
+            };
+            const mockToolHandler = vitest_1.vi
+                .fn()
+                .mockRejectedValue(new Error("Tool failed"));
+            await (0, vitest_1.expect)(runtime.processToolCall(toolRequest, mockSession, mockToolHandler)).rejects.toThrow("Tool failed");
+            // Should still log audit record with verified=no
+            (0, vitest_1.expect)(mockLogFunction).toHaveBeenCalled();
+            const auditLine = mockLogFunction.mock.calls[0][0];
+            (0, vitest_1.expect)(auditLine).toContain("verified=no");
+        });
+        (0, vitest_1.it)("should fail if runtime not initialized", async () => {
+            const uninitializedRuntime = new mcpi_runtime_js_1.MCPIRuntime();
+            const toolRequest = {
+                method: "test-tool",
+                params: { input: "hello" },
+            };
+            const mockToolHandler = vitest_1.vi.fn().mockResolvedValue({ output: "world" });
+            await (0, vitest_1.expect)(uninitializedRuntime.processToolCall(toolRequest, mockSession, mockToolHandler)).rejects.toThrow("Runtime not initialized");
+        });
+    });
+    (0, vitest_1.describe)("Runtime Statistics", () => {
+        (0, vitest_1.beforeEach)(async () => {
+            runtime = new mcpi_runtime_js_1.MCPIRuntime({
+                identity: {
+                    environment: "development",
+                    devIdentityPath: ".test-mcpi/identity.json",
+                },
+                wellKnown: {
+                    environment: "development",
+                    baseUrl: "http://localhost:3000",
+                },
+            });
+            await runtime.initialize();
+        });
+        (0, vitest_1.it)("should provide comprehensive statistics", () => {
+            const stats = runtime.getStats();
+            (0, vitest_1.expect)(stats.identity.did).toBeTruthy();
+            (0, vitest_1.expect)(stats.identity.keyId).toBeTruthy();
+            (0, vitest_1.expect)(stats.identity.environment).toBe("development");
+            (0, vitest_1.expect)(stats.session.activeSessions).toBe(0);
+            (0, vitest_1.expect)(stats.audit.enabled).toBe(true);
+            (0, vitest_1.expect)(stats.runtime.initialized).toBe(true);
+            (0, vitest_1.expect)(stats.runtime.wellKnownEnabled).toBe(true);
+        });
+    });
+    (0, vitest_1.describe)("Runtime Environment Checks", () => {
+        (0, vitest_1.it)("should pass environment checks in Node.js ≥18.18", async () => {
+            // This test runs in Node.js, so it should pass
+            runtime = new mcpi_runtime_js_1.MCPIRuntime({
+                identity: {
+                    environment: "development",
+                    devIdentityPath: ".test-mcpi/identity.json",
+                },
+            });
+            await (0, vitest_1.expect)(runtime.initialize()).resolves.not.toThrow();
+        });
+        (0, vitest_1.it)("should detect Node.js environment", async () => {
+            runtime = new mcpi_runtime_js_1.MCPIRuntime({
+                identity: {
+                    environment: "development",
+                    devIdentityPath: ".test-mcpi/identity.json",
+                },
+            });
+            await runtime.initialize();
+            const stats = runtime.getStats();
+            (0, vitest_1.expect)(stats.runtime.initialized).toBe(true);
+        });
+    });
+});
+(0, vitest_1.describe)("Runtime Factory", () => {
+    let runtime;
+    (0, vitest_1.afterEach)(async () => {
+        if (runtime) {
+            await runtime.cleanup();
+        }
+        // Cleanup test directory
+        try {
+            if ((0, fs_1.existsSync)(".test-mcpi")) {
+                await (0, promises_1.rmdir)(".test-mcpi", { recursive: true });
+            }
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    });
+    (0, vitest_1.beforeEach)(() => {
+        // Mock console.log to avoid noise in tests
+        vitest_1.vi.spyOn(console, "log").mockImplementation(() => { });
+        vitest_1.vi.spyOn(console, "error").mockImplementation(() => { });
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.describe)("forDevelopment", () => {
+        (0, vitest_1.it)("should create development runtime", async () => {
+            runtime = await mcpi_runtime_js_1.RuntimeFactory.forDevelopment({
+                identity: {
+                    devIdentityPath: ".test-mcpi/identity.json",
+                },
+            });
+            const stats = runtime.getStats();
+            (0, vitest_1.expect)(stats.identity.environment).toBe("development");
+            (0, vitest_1.expect)(stats.runtime.initialized).toBe(true);
+        });
+        (0, vitest_1.it)("should enable verify link in development", async () => {
+            runtime = await mcpi_runtime_js_1.RuntimeFactory.forDevelopment({
+                identity: {
+                    devIdentityPath: ".test-mcpi/identity.json",
+                },
+            });
+            // Should not throw and should be initialized
+            (0, vitest_1.expect)(runtime.getStats().runtime.initialized).toBe(true);
+        });
+    });
+    (0, vitest_1.describe)("forProduction", () => {
+        (0, vitest_1.it)("should create production runtime with env vars", async () => {
+            // Mock production environment variables
+            const originalEnv = process.env;
+            process.env.AGENT_PRIVATE_KEY = Buffer.from("test-private-key-32-bytes-long!!").toString("base64");
+            process.env.AGENT_KEY_ID = "key-prod-123";
+            process.env.AGENT_DID = "did:web:example.com:agents:prod-agent";
+            process.env.KYA_VOUCHED_API_KEY = "test-api-key";
+            try {
+                runtime = await mcpi_runtime_js_1.RuntimeFactory.forProduction();
+                const stats = runtime.getStats();
+                (0, vitest_1.expect)(stats.identity.environment).toBe("production");
+                (0, vitest_1.expect)(stats.identity.did).toBe("did:web:example.com:agents:prod-agent");
+                (0, vitest_1.expect)(stats.runtime.initialized).toBe(true);
+            }
+            finally {
+                // Restore environment
+                process.env = originalEnv;
+            }
+        });
+    });
+    (0, vitest_1.describe)("forTesting", () => {
+        (0, vitest_1.it)("should create testing runtime", async () => {
+            runtime = await mcpi_runtime_js_1.RuntimeFactory.forTesting();
+            const stats = runtime.getStats();
+            (0, vitest_1.expect)(stats.identity.environment).toBe("development");
+            (0, vitest_1.expect)(stats.audit.enabled).toBe(false); // Disabled in tests
+            (0, vitest_1.expect)(stats.runtime.initialized).toBe(true);
+        });
+        (0, vitest_1.it)("should use test identity path", async () => {
+            runtime = await mcpi_runtime_js_1.RuntimeFactory.forTesting();
+            // Should be initialized without errors
+            (0, vitest_1.expect)(runtime.getStats().runtime.initialized).toBe(true);
+        });
+    });
+});
+(0, vitest_1.describe)("createMCPIRuntime", () => {
+    let runtime;
+    (0, vitest_1.afterEach)(async () => {
+        if (runtime) {
+            await runtime.cleanup();
+        }
+        // Cleanup test directory
+        try {
+            if ((0, fs_1.existsSync)(".test-mcpi")) {
+                await (0, promises_1.rmdir)(".test-mcpi", { recursive: true });
+            }
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    });
+    (0, vitest_1.beforeEach)(() => {
+        // Mock console.log to avoid noise in tests
+        vitest_1.vi.spyOn(console, "log").mockImplementation(() => { });
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.it)("should create and initialize runtime", async () => {
+        runtime = await (0, mcpi_runtime_js_1.createMCPIRuntime)({
+            identity: {
+                environment: "development",
+                devIdentityPath: ".test-mcpi/identity.json",
+            },
+        });
+        (0, vitest_1.expect)(runtime.getStats().runtime.initialized).toBe(true);
+    });
+    (0, vitest_1.it)("should create runtime with minimal config", async () => {
+        runtime = await (0, mcpi_runtime_js_1.createMCPIRuntime)({
+            identity: {
+                environment: "development",
+                devIdentityPath: ".test-mcpi/identity.json",
+            },
+        });
+        const stats = runtime.getStats();
+        (0, vitest_1.expect)(stats.runtime.initialized).toBe(true);
+        (0, vitest_1.expect)(stats.identity.did).toBeTruthy();
+    });
+});

package/dist/runtime/__tests__/proof.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for Detached Proof Generation
+ */
+export {};