@kya-os/mcp-i 0.1.0 → 1.2.0

package/dist/test/examples/test-usage-example.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Example usage of XMCP-I test infrastructure
+ *
+ * This file demonstrates how to use the test infrastructure for testing
+ * XMCP-I applications without hitting external services.
+ */
+import { MockIdentityProvider } from "../index.js";
+/**
+ * Example: Setting up test environment
+ */
+export declare function setupTestEnvironment(): void;
+/**
+ * Example: Using mock identity provider
+ */
+export declare function exampleMockIdentityProvider(): MockIdentityProvider;
+/**
+ * Example: Testing proof generation and verification
+ */
+export declare function exampleProofTesting(): Promise<{
+    valid: boolean;
+    warnings: string[];
+    session: {
+        valid: boolean;
+        expired: boolean;
+        error?: string | undefined;
+    };
+    signature: {
+        valid: boolean;
+        algorithm: string;
+        error?: string | undefined;
+    };
+    proof: {
+        valid: boolean;
+        structure: boolean;
+        timestamps: boolean;
+        hashes: boolean;
+        error?: string | undefined;
+    };
+    errors: string[];
+    did?: string | undefined;
+    keyId?: string | undefined;
+}>;
+/**
+ * Example: Intercepting KTA calls
+ */
+export declare function exampleKTAInterception(): Promise<{
+    registrationResult: {
+        success: boolean;
+        agentURL: string;
+        agentId: string;
+        agentSlug: string;
+        verificationEndpoint: string;
+        conformanceCapabilities: string[];
+        mirrorStatus: string;
+    };
+    delegationResult: never;
+}>;
+/**
+ * Example: Using test runtime integration
+ */
+export declare function exampleRuntimeIntegration(): {
+    testIdentity: {
+        did: string;
+        keyId: string;
+        privateKey: string;
+        publicKey: string;
+        createdAt: string;
+        lastRotated: string;
+    };
+    sessionContext: {
+        sessionId: string;
+        audience: string;
+        nonce: string;
+        timestamp: number;
+        createdAt: number;
+        lastActivity: number;
+        ttlMinutes: number;
+    };
+};
+/**
+ * Example: Complete test scenario
+ */
+export declare function exampleCompleteTestScenario(): Promise<{
+    mockProvider: MockIdentityProvider;
+    proofResult: {
+        valid: boolean;
+        warnings: string[];
+        session: {
+            valid: boolean;
+            expired: boolean;
+            error?: string | undefined;
+        };
+        signature: {
+            valid: boolean;
+            algorithm: string;
+            error?: string | undefined;
+        };
+        proof: {
+            valid: boolean;
+            structure: boolean;
+            timestamps: boolean;
+            hashes: boolean;
+            error?: string | undefined;
+        };
+        errors: string[];
+        did?: string | undefined;
+        keyId?: string | undefined;
+    };
+    ktaResults: {
+        registrationResult: {
+            success: boolean;
+            agentURL: string;
+            agentId: string;
+            agentSlug: string;
+            verificationEndpoint: string;
+            conformanceCapabilities: string[];
+            mirrorStatus: string;
+        };
+        delegationResult: never;
+    };
+    runtimeResults: {
+        testIdentity: {
+            did: string;
+            keyId: string;
+            privateKey: string;
+            publicKey: string;
+            createdAt: string;
+            lastRotated: string;
+        };
+        sessionContext: {
+            sessionId: string;
+            audience: string;
+            nonce: string;
+            timestamp: number;
+            createdAt: number;
+            lastActivity: number;
+            ttlMinutes: number;
+        };
+    };
+}>;

package/dist/test/examples/test-usage-example.js

@@ -0,0 +1,175 @@
+"use strict";
+/**
+ * Example usage of XMCP-I test infrastructure
+ *
+ * This file demonstrates how to use the test infrastructure for testing
+ * XMCP-I applications without hitting external services.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupTestEnvironment = setupTestEnvironment;
+exports.exampleMockIdentityProvider = exampleMockIdentityProvider;
+exports.exampleProofTesting = exampleProofTesting;
+exports.exampleKTAInterception = exampleKTAInterception;
+exports.exampleRuntimeIntegration = exampleRuntimeIntegration;
+exports.exampleCompleteTestScenario = exampleCompleteTestScenario;
+const index_js_1 = require("../index.js");
+const test_1 = require("@kya-os/contracts/test");
+/**
+ * Example: Setting up test environment
+ */
+function setupTestEnvironment() {
+    // Configure test environment with custom seed
+    (0, index_js_1.configureTestEnvironment)({
+        seed: "my-test-suite",
+        skipKTACalls: true,
+    });
+    // Verify we're in test mode
+    console.log("Test mode:", (0, index_js_1.isTestMode)());
+    // Validate test environment
+    const validation = (0, index_js_1.validateTestEnvironment)();
+    if (!validation.valid) {
+        throw new Error(`Test environment validation failed: ${validation.errors.join(", ")}`);
+    }
+    if (validation.warnings.length > 0) {
+        console.warn("Test environment warnings:", validation.warnings);
+    }
+}
+/**
+ * Example: Using mock identity provider
+ */
+function exampleMockIdentityProvider() {
+    const mockProvider = new index_js_1.MockIdentityProvider();
+    // Generate a custom test identity
+    const customIdentity = (0, index_js_1.generateTestIdentity)("my-custom-test", {
+        did: "did:test:my-custom-agent",
+        keyId: "key-custom-1",
+    });
+    // Set the identity in the provider
+    mockProvider.setIdentity("custom", customIdentity);
+    // Set delegation status
+    mockProvider.setDelegation(`${customIdentity.did}:${customIdentity.keyId}`, "active");
+    // Simulate KTA failures for testing error scenarios
+    mockProvider.simulateKTAFailure("network");
+    return mockProvider;
+}
+/**
+ * Example: Testing proof generation and verification
+ */
+async function exampleProofTesting() {
+    // Create mock request and response data
+    const mockRequest = {
+        method: "tools/call",
+        params: {
+            name: "greet",
+            arguments: { name: "Alice" },
+        },
+    };
+    const mockResponse = {
+        content: [
+            {
+                type: "text",
+                text: "Hello, Alice!",
+            },
+        ],
+    };
+    // Create a mock proof
+    const mockProof = (0, index_js_1.createMockProof)({
+        did: test_1.TEST_DIDS.AGENT_1,
+        keyId: test_1.TEST_KEY_IDS.KEY_TEST_1,
+        request: mockRequest,
+        response: mockResponse,
+        sessionId: "sess_test_example",
+        nonce: "example_nonce",
+        audience: "example.com",
+    });
+    // Verify the proof locally
+    const verificationResult = await (0, index_js_1.verifyProofLocally)(mockProof, mockRequest, mockResponse);
+    console.log("Proof verification result:", {
+        valid: verificationResult.valid,
+        did: verificationResult.did,
+        keyId: verificationResult.keyId,
+        signatureValid: verificationResult.signature.valid,
+        proofValid: verificationResult.proof.valid,
+        sessionValid: verificationResult.session.valid,
+        errors: verificationResult.errors,
+        warnings: verificationResult.warnings,
+    });
+    return verificationResult;
+}
+/**
+ * Example: Intercepting KTA calls
+ */
+async function exampleKTAInterception() {
+    // Mock a KTA registration call
+    const registrationResult = await (0, index_js_1.interceptKTACall)("register", async () => {
+        // This would normally make a real KTA call
+        throw new Error("Should not reach here in test mode");
+    }, async () => {
+        // Custom mock response
+        return {
+            success: true,
+            agentURL: "https://custom-test-kta.example.com/agents/my-agent",
+            agentId: "my-agent",
+            agentSlug: "my-agent",
+            verificationEndpoint: "https://custom-test-kta.example.com/verify/my-agent",
+            conformanceCapabilities: ["handshake", "signing", "verification"],
+            mirrorStatus: "pending",
+        };
+    });
+    console.log("Mock registration result:", registrationResult);
+    // Mock a delegation check
+    const delegationResult = await (0, index_js_1.interceptKTACall)("checkDelegation", async () => {
+        throw new Error("Should not reach here in test mode");
+    });
+    console.log("Mock delegation result:", delegationResult);
+    return { registrationResult, delegationResult };
+}
+/**
+ * Example: Using test runtime integration
+ */
+function exampleRuntimeIntegration() {
+    // Get test identity for runtime use
+    const testIdentity = (0, index_js_1.getTestIdentityForRuntime)("agent1");
+    console.log("Test identity for runtime:", {
+        did: testIdentity.did,
+        keyId: testIdentity.keyId,
+        // Don't log private key in real usage
+    });
+    // Create test session context
+    const sessionContext = (0, index_js_1.createTestSessionContext)({
+        sessionId: "sess_example_123",
+        audience: "my-app.example.com",
+        nonce: "example_nonce_456",
+    });
+    console.log("Test session context:", sessionContext);
+    return { testIdentity, sessionContext };
+}
+/**
+ * Example: Complete test scenario
+ */
+async function exampleCompleteTestScenario() {
+    console.log("=== XMCP-I Test Infrastructure Example ===");
+    // 1. Setup test environment
+    console.log("\n1. Setting up test environment...");
+    setupTestEnvironment();
+    // 2. Configure mock identity provider
+    console.log("\n2. Configuring mock identity provider...");
+    const mockProvider = exampleMockIdentityProvider();
+    // 3. Test proof generation and verification
+    console.log("\n3. Testing proof generation and verification...");
+    const proofResult = await exampleProofTesting();
+    // 4. Test KTA call interception
+    console.log("\n4. Testing KTA call interception...");
+    const ktaResults = await exampleKTAInterception();
+    // 5. Test runtime integration
+    console.log("\n5. Testing runtime integration...");
+    const runtimeResults = exampleRuntimeIntegration();
+    console.log("\n=== Test Infrastructure Example Complete ===");
+    return {
+        mockProvider,
+        proofResult,
+        ktaResults,
+        runtimeResults,
+    };
+}
+// Functions are already exported above

package/dist/test/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Test infrastructure for XMCP-I
+ *
+ * This module provides test utilities for developing and testing XMCP-I applications
+ * without hitting external services like KTA.
+ */
+export * from "./mock-identity-provider";
+export * from "./deterministic-keys";
+export * from "./local-verification";
+export * from "./test-environment";
+export * from "./runtime-integration";

package/dist/test/index.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Test infrastructure for XMCP-I
+ *
+ * This module provides test utilities for developing and testing XMCP-I applications
+ * without hitting external services like KTA.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./mock-identity-provider"), exports);
+__exportStar(require("./deterministic-keys"), exports);
+__exportStar(require("./local-verification"), exports);
+__exportStar(require("./test-environment"), exports);
+__exportStar(require("./runtime-integration"), exports);

package/dist/test/local-verification.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Local verification utilities for offline testing
+ */
+import { type LocalVerificationResult } from "@kya-os/contracts/test";
+/**
+ * Perform local verification of a proof without KTA calls
+ */
+export declare function verifyProofLocally(proof: any, request?: any, response?: any): Promise<LocalVerificationResult>;
+/**
+ * Verify DID document locally (mock implementation)
+ */
+export declare function verifyDIDDocumentLocally(did: string): Promise<{
+    valid: boolean;
+    document?: any;
+    error?: string;
+}>;
+/**
+ * Create a mock proof for testing
+ */
+export declare function createMockProof(options: {
+    did?: string;
+    keyId?: string;
+    request?: any;
+    response?: any;
+    sessionId?: string;
+    nonce?: string;
+    audience?: string;
+}): any;