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

package/dist/runtime/utils/server.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INJECTED_CONFIG = exports.injectedTools = void 0;
+exports.configureServer = configureServer;
+exports.loadTools = loadTools;
+exports.createServer = createServer;
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const tools_1 = require("./tools");
+// @ts-expect-error: injected by compiler
+exports.injectedTools = INJECTED_TOOLS;
+exports.INJECTED_CONFIG = {
+    // TODO get from project config
+    name: "MCP Server",
+    version: "0.0.1",
+    capabilities: {
+        tools: {
+            listChanged: true,
+        },
+    },
+};
+/** Loads tools and injects them into the server */
+async function configureServer(server, toolModules) {
+    (0, tools_1.addToolsToServer)(server, toolModules);
+    // TODO: implement addResourcesToServer, addPromptsToServer
+    return server;
+}
+function loadTools() {
+    const toolModules = new Map();
+    const toolPromises = Object.keys(exports.injectedTools).map((path) => exports.injectedTools[path]().then((toolModule) => {
+        toolModules.set(path, toolModule);
+    }));
+    return [toolPromises, toolModules];
+}
+async function createServer() {
+    const server = new index_js_1.Server(exports.INJECTED_CONFIG);
+    const [toolPromises, toolModules] = loadTools();
+    await Promise.all(toolPromises);
+    return configureServer(server, toolModules);
+}

package/dist/runtime/utils/tools.d.ts

@@ -0,0 +1,8 @@
+import { Server as McpServer } from "@modelcontextprotocol/sdk/server/index.js";
+import { ZodTypeAny } from "zod";
+import { ToolFile } from "./server";
+export type ZodRawShape = {
+    [k: string]: ZodTypeAny;
+};
+/** Loads tools and injects them into the server */
+export declare function addToolsToServer(server: McpServer, toolModules: Map<string, ToolFile>): McpServer;

package/dist/runtime/utils/tools.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addToolsToServer = addToolsToServer;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+/** Validates if a value is a valid Zod schema object */
+function isZodRawShape(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const obj = value;
+    return Object.entries(obj).every(([key, val]) => {
+        if (typeof key !== "string")
+            return false;
+        if (typeof val !== "object" || val === null)
+            return false;
+        if (!("parse" in val) || typeof val.parse !== "function")
+            return false;
+        return true;
+    });
+}
+function pathToName(path) {
+    const fileName = path.split("/").pop() || path;
+    return fileName.replace(/\.[^/.]+$/, "");
+}
+/** Loads tools and injects them into the server */
+function addToolsToServer(server, toolModules) {
+    // Collect all tools and their handlers
+    const tools = [];
+    const toolHandlers = new Map();
+    toolModules.forEach((toolModule, path) => {
+        const defaultName = pathToName(path);
+        const toolConfig = {
+            name: defaultName,
+            description: "No description provided",
+        };
+        let toolSchema = {};
+        const { default: handler, metadata, schema } = toolModule;
+        if (typeof metadata === "object" && metadata !== null) {
+            Object.assign(toolConfig, metadata);
+        }
+        // Validate and ensure schema is properly typed
+        if (isZodRawShape(schema)) {
+            Object.assign(toolSchema, schema);
+        }
+        else if (schema !== undefined && schema !== null) {
+            console.warn(`Invalid schema for tool "${toolConfig.name}" at ${path}. Expected Record<string, z.ZodType>`);
+        }
+        // Make sure tools has annotations with a title
+        if (toolConfig.annotations === undefined) {
+            toolConfig.annotations = {};
+        }
+        if (toolConfig.annotations.title === undefined) {
+            toolConfig.annotations.title = toolConfig.name;
+        }
+        // Create tool definition for MCP
+        const tool = {
+            name: toolConfig.name,
+            description: toolConfig.description,
+            inputSchema: {
+                type: "object",
+                properties: Object.fromEntries(Object.entries(toolSchema).map(([key, zodType]) => [
+                    key,
+                    { type: "string" }, // Simplified - in real implementation, convert Zod to JSON Schema
+                ])),
+            },
+        };
+        tools.push(tool);
+        toolHandlers.set(toolConfig.name, handler);
+    });
+    // Register tools/list handler
+    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async (request) => {
+        return {
+            tools: tools,
+        };
+    });
+    // Register tools/call handler
+    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const handler = toolHandlers.get(name);
+        if (!handler) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Tool "${name}" not found`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        try {
+            const result = await handler(args || {});
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: typeof result === "string" ? result : JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error executing tool "${name}": ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    return server;
+}

package/dist/runtime/verifier-middleware.d.ts

@@ -0,0 +1,76 @@
+import type { Request, Response, NextFunction } from "express";
+import type { ProofMeta } from "@kya-os/contracts/proof";
+import type { Receipt } from "@kya-os/contracts/registry";
+import { type StructuredError } from "@kya-os/contracts/verifier";
+/**
+ * Verifier middleware for proof and receipt validation
+ */
+export interface VerifierConfig {
+    /**
+     * Enable receipt verification
+     */
+    receiptVerification?: boolean;
+    /**
+     * Enable delegation checking
+     */
+    delegationChecking?: boolean;
+    /**
+     * KTA base URL
+     */
+    ktaBaseUrl?: string;
+    /**
+     * Policy toggle for receipt checking
+     */
+    receiptPolicy?: "required" | "optional" | "disabled";
+    /**
+     * Allow mock data for testing
+     */
+    allowMockData?: boolean;
+}
+export interface LocalVerifierResult {
+    success: boolean;
+    headers?: Record<string, string>;
+    error?: StructuredError;
+}
+export interface VerifierContext {
+    proof: ProofMeta;
+    receipt?: Receipt;
+    delegationRef?: string;
+}
+/**
+ * Core verifier implementation
+ */
+export declare class CoreVerifier {
+    private config;
+    private receiptVerifier;
+    private delegationManager;
+    constructor(config?: VerifierConfig);
+    /**
+     * Verify proof with optional receipt checking
+     */
+    verify(context: VerifierContext): Promise<LocalVerifierResult>;
+    /**
+     * Verify proof signature (placeholder implementation)
+     */
+    private verifySignature;
+    /**
+     * Verify delegation status
+     */
+    private verifyDelegation;
+    /**
+     * Check if receipt verification should be performed
+     */
+    private shouldVerifyReceipt;
+    /**
+     * Generate trusted headers for successful verification
+     */
+    private generateHeaders;
+}
+/**
+ * Cloudflare Worker verifier
+ */
+export declare function verifyWorker(request: Request, config?: VerifierConfig): Promise<LocalVerifierResult>;
+/**
+ * Express verifier middleware
+ */
+export declare function verifyExpress(config?: VerifierConfig): (req: Request, res: Response, next: NextFunction) => Promise<Response<any, Record<string, any>> | undefined>;

package/dist/runtime/verifier-middleware.js

@@ -0,0 +1,322 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreVerifier = void 0;
+exports.verifyWorker = verifyWorker;
+exports.verifyExpress = verifyExpress;
+const verifier_1 = require("@kya-os/contracts/verifier");
+const merkle_verifier_1 = require("../storage/merkle-verifier");
+const delegation_1 = require("../storage/delegation");
+/**
+ * Core verifier implementation
+ */
+class CoreVerifier {
+    config;
+    receiptVerifier;
+    delegationManager;
+    constructor(config = {}) {
+        this.config = config;
+        this.receiptVerifier = (0, merkle_verifier_1.createReceiptVerifier)({
+            enabled: config.receiptVerification !== false,
+            ktaBaseUrl: config.ktaBaseUrl,
+            allowMockData: config.allowMockData,
+        });
+        this.delegationManager = (0, delegation_1.createDelegationManager)({
+            ktaBaseURL: config.ktaBaseUrl || "https://knowthat.ai",
+        });
+    }
+    /**
+     * Verify proof with optional receipt checking
+     */
+    async verify(context) {
+        try {
+            // 1. Verify proof signature (placeholder - would use actual crypto verification)
+            const signatureValid = await this.verifySignature(context.proof);
+            if (!signatureValid) {
+                return {
+                    success: false,
+                    error: {
+                        code: "XMCP_I_EBADPROOF",
+                        message: "Invalid proof signature",
+                        httpStatus: 403,
+                    },
+                };
+            }
+            // 2. Check delegation if present
+            if (context.proof.delegationRef &&
+                this.config.delegationChecking !== false) {
+                const delegationValid = await this.verifyDelegation(context.proof.delegationRef);
+                if (!delegationValid) {
+                    return {
+                        success: false,
+                        error: {
+                            code: "XMCP_I_EBADPROOF",
+                            message: "Delegation revoked or invalid",
+                            httpStatus: 403,
+                        },
+                    };
+                }
+            }
+            // 3. Verify receipt if present and policy requires it
+            if (context.receipt && this.shouldVerifyReceipt()) {
+                const receiptResult = await this.receiptVerifier.verify(context.receipt);
+                if (!receiptResult.valid) {
+                    return {
+                        success: false,
+                        error: {
+                            code: "XMCP_I_ERECEIPT",
+                            message: `Receipt verification failed: ${receiptResult.error}`,
+                            httpStatus: 403,
+                        },
+                    };
+                }
+            }
+            // 4. Generate trusted headers
+            const headers = this.generateHeaders(context.proof);
+            return {
+                success: true,
+                headers,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: {
+                    code: "XMCP_I_EVERIFY",
+                    message: error instanceof Error ? error.message : "Verification failed",
+                    httpStatus: 500,
+                },
+            };
+        }
+    }
+    /**
+     * Verify proof signature (placeholder implementation)
+     */
+    async verifySignature(proof) {
+        // TODO: Implement actual Ed25519 signature verification
+        // This is a placeholder that checks basic proof structure
+        return !!(proof.did &&
+            proof.kid &&
+            proof.ts &&
+            proof.nonce &&
+            proof.audience &&
+            proof.sessionId &&
+            proof.requestHash &&
+            proof.responseHash);
+    }
+    /**
+     * Verify delegation status
+     */
+    async verifyDelegation(delegationRef) {
+        try {
+            return await this.delegationManager.isActive(delegationRef);
+        }
+        catch (error) {
+            console.warn("Delegation verification failed:", error);
+            return false;
+        }
+    }
+    /**
+     * Check if receipt verification should be performed
+     */
+    shouldVerifyReceipt() {
+        const policy = this.config.receiptPolicy || "optional";
+        return (policy === "required" ||
+            (policy === "optional" && this.config.receiptVerification !== false));
+    }
+    /**
+     * Generate trusted headers for successful verification
+     */
+    generateHeaders(proof) {
+        const headers = {
+            [verifier_1.AGENT_HEADERS.DID]: proof.did,
+            [verifier_1.AGENT_HEADERS.KEY_ID]: proof.kid,
+            [verifier_1.AGENT_HEADERS.SESSION]: proof.sessionId,
+            [verifier_1.AGENT_HEADERS.CONFIDENCE]: "verified",
+            [verifier_1.AGENT_HEADERS.VERIFIED_AT]: Math.floor(Date.now() / 1000).toString(),
+        };
+        if (proof.scopeId) {
+            headers[verifier_1.AGENT_HEADERS.SCOPES] = proof.scopeId;
+        }
+        if (proof.delegationRef) {
+            headers[verifier_1.AGENT_HEADERS.DELEGATION_REF] = proof.delegationRef;
+        }
+        // Add registry URL for traceability
+        const ktaUrl = this.config.ktaBaseUrl || "https://knowthat.ai";
+        headers[verifier_1.AGENT_HEADERS.REGISTRY] =
+            `${ktaUrl}/agents/${encodeURIComponent(proof.did)}`;
+        return headers;
+    }
+}
+exports.CoreVerifier = CoreVerifier;
+/**
+ * Cloudflare Worker verifier
+ */
+async function verifyWorker(request, config) {
+    try {
+        // Extract proof from request headers or body
+        const proof = await extractProofFromRequest(request);
+        if (!proof) {
+            return {
+                success: false,
+                error: {
+                    code: "XMCP_I_ENOIDENTITY",
+                    message: "No proof found in request",
+                    httpStatus: 401,
+                },
+            };
+        }
+        // Extract receipt if present
+        const receipt = await extractReceiptFromRequest(request);
+        const verifier = new CoreVerifier(config);
+        return await verifier.verify({ proof, receipt: receipt || undefined });
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: {
+                code: "XMCP_I_EVERIFY",
+                message: error instanceof Error ? error.message : "Verification failed",
+                httpStatus: 500,
+            },
+        };
+    }
+}
+/**
+ * Express verifier middleware
+ */
+function verifyExpress(config) {
+    return async (req, res, next) => {
+        try {
+            // Extract proof from request
+            const proof = await extractProofFromExpressRequest(req);
+            if (!proof) {
+                return res.status(401).json({
+                    code: "XMCP_I_ENOIDENTITY",
+                    message: "No proof found in request",
+                });
+            }
+            // Extract receipt if present
+            const receipt = await extractReceiptFromExpressRequest(req);
+            const verifier = new CoreVerifier(config);
+            const result = await verifier.verify({
+                proof,
+                receipt: receipt || undefined,
+            });
+            if (!result.success) {
+                return res.status(result.error.httpStatus).json({
+                    code: result.error.code,
+                    message: result.error.message,
+                    details: result.error.details,
+                });
+            }
+            // Set headers and context
+            if (result.headers) {
+                Object.entries(result.headers).forEach(([key, value]) => {
+                    res.setHeader(key, value);
+                });
+                // Set ctx.agent for MCP recipients
+                req.ctx = req.ctx || {};
+                req.ctx.agent = {
+                    did: result.headers[verifier_1.AGENT_HEADERS.DID],
+                    keyId: result.headers[verifier_1.AGENT_HEADERS.KEY_ID],
+                    session: result.headers[verifier_1.AGENT_HEADERS.SESSION],
+                    scopes: result.headers[verifier_1.AGENT_HEADERS.SCOPES]?.split(",") || [],
+                    delegationRef: result.headers[verifier_1.AGENT_HEADERS.DELEGATION_REF],
+                    confidence: result.headers[verifier_1.AGENT_HEADERS.CONFIDENCE],
+                    verifiedAt: parseInt(result.headers[verifier_1.AGENT_HEADERS.VERIFIED_AT]),
+                };
+            }
+            next();
+        }
+        catch (error) {
+            res.status(500).json({
+                code: "XMCP_I_EVERIFY",
+                message: error instanceof Error ? error.message : "Verification failed",
+            });
+        }
+    };
+}
+/**
+ * Extract proof from Worker request
+ */
+async function extractProofFromRequest(request) {
+    // TODO: Implement actual proof extraction from request
+    // This would typically look for proof in headers or request body
+    // Placeholder implementation
+    let proofHeader = null;
+    // Handle both Fetch API Request and Node.js IncomingMessage
+    if (typeof request.headers.get === "function") {
+        // Fetch API Request
+        proofHeader = request.headers.get("X-XMCP-I-Proof");
+    }
+    else {
+        // Node.js IncomingMessage
+        const header = request.headers["x-xmcp-i-proof"];
+        proofHeader = Array.isArray(header) ? header[0] : header;
+    }
+    if (!proofHeader) {
+        return null;
+    }
+    try {
+        return JSON.parse(proofHeader);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Extract receipt from Worker request
+ */
+async function extractReceiptFromRequest(request) {
+    // TODO: Implement actual receipt extraction from request
+    // This would typically look for receipt reference in headers
+    let receiptRef = null;
+    // Handle both Fetch API Request and Node.js IncomingMessage
+    if (typeof request.headers.get === "function") {
+        // Fetch API Request
+        receiptRef = request.headers.get("X-XMCP-I-Receipt-Ref");
+    }
+    else {
+        // Node.js IncomingMessage
+        const header = request.headers["x-xmcp-i-receipt-ref"];
+        receiptRef = Array.isArray(header) ? header[0] : header;
+    }
+    if (!receiptRef) {
+        return null;
+    }
+    // TODO: Fetch receipt by reference from storage
+    return null;
+}
+/**
+ * Extract proof from Express request
+ */
+async function extractProofFromExpressRequest(req) {
+    // TODO: Implement actual proof extraction from Express request
+    // This would typically look for proof in headers or request body
+    const proofHeader = req.headers["x-xmcp-i-proof"];
+    if (!proofHeader) {
+        return null;
+    }
+    try {
+        const headerValue = Array.isArray(proofHeader)
+            ? proofHeader[0]
+            : proofHeader;
+        return JSON.parse(headerValue);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Extract receipt from Express request
+ */
+async function extractReceiptFromExpressRequest(req) {
+    // TODO: Implement actual receipt extraction from Express request
+    // This would typically look for receipt reference in headers
+    const receiptRef = req.headers["x-xmcp-i-receipt-ref"];
+    if (!receiptRef) {
+        return null;
+    }
+    // TODO: Fetch receipt by reference from storage
+    return null;
+}