@kya-os/mcp-i 1.2.6 → 1.2.8

package/dist/runtime/transports/stdio/index.js

@@ -15,7 +15,7 @@ class StdioTransport {
         try {
             this.mcpServer.connect(this.transport);
             if (this.debug) {
-                console.log("[STDIO] MCP Server running with STDIO transport");
+                console.error("[STDIO] MCP Server running with STDIO transport");
             }
             this.setupShutdownHandlers();
         }
@@ -29,7 +29,7 @@ class StdioTransport {
     setupShutdownHandlers() {
         const shutdownHandler = () => {
             if (this.debug) {
-                console.log("[STDIO] Shutting down STDIO transport");
+                console.error("[STDIO] Shutting down STDIO transport");
             }
             process.exit(0);
         };
@@ -38,7 +38,7 @@ class StdioTransport {
     }
     shutdown() {
         if (this.debug) {
-            console.log("[STDIO] Shutting down STDIO transport");
+            console.error("[STDIO] Shutting down STDIO transport");
         }
         process.exit(0);
     }

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

@@ -1,19 +1,21 @@
 import { Server as McpServer } from "@modelcontextprotocol/sdk/server/index.js";
+import { Implementation } from "@modelcontextprotocol/sdk/types.js";
 export type ToolFile = {
     metadata: unknown;
     schema: unknown;
     default: (args: Record<string, unknown>) => Promise<unknown> | unknown;
 };
 export declare const injectedTools: Record<string, () => Promise<ToolFile>>;
-export declare const INJECTED_CONFIG: {
-    readonly name: "MCP Server";
-    readonly version: "0.0.1";
-    readonly capabilities: {
-        readonly tools: {
-            readonly listChanged: true;
-        };
+export declare const SERVER_INFO: Implementation;
+export declare const SERVER_CAPABILITIES: {
+    capabilities: {
+        tools: {};
     };
 };
+declare global {
+    var __MCPI_SERVER_INSTANCE__: McpServer | undefined;
+    var __MCPI_SERVER_CREATED__: boolean | undefined;
+}
 /** Loads tools and injects them into the server */
 export declare function configureServer(server: McpServer, toolModules: Map<string, ToolFile>): Promise<McpServer>;
 export declare function loadTools(): readonly [Promise<void>[], Map<string, ToolFile>];

package/dist/runtime/utils/server.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.INJECTED_CONFIG = exports.injectedTools = void 0;
+exports.SERVER_CAPABILITIES = exports.SERVER_INFO = exports.injectedTools = void 0;
 exports.configureServer = configureServer;
 exports.loadTools = loadTools;
 exports.createServer = createServer;
@@ -8,32 +8,73 @@ 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
+// Parse identity config from injected variable
+// @ts-expect-error: injected by compiler
+const rawIdentityConfig = typeof IDENTITY_CONFIG !== "undefined" ? IDENTITY_CONFIG : undefined;
+const identityConfig = rawIdentityConfig
+    ? JSON.parse(rawIdentityConfig)
+    : undefined;
+// Server info (first parameter to Server constructor)
+exports.SERVER_INFO = {
     name: "MCP Server",
     version: "0.0.1",
+};
+// Server capabilities (second parameter to Server constructor)
+exports.SERVER_CAPABILITIES = {
     capabilities: {
-        tools: {
-            listChanged: true,
-        },
+        tools: {},
     },
 };
+if (typeof global !== 'undefined') {
+    global.__MCPI_SERVER_CREATED__ = global.__MCPI_SERVER_CREATED__ || false;
+}
 /** Loads tools and injects them into the server */
 async function configureServer(server, toolModules) {
-    (0, tools_1.addToolsToServer)(server, toolModules);
+    await (0, tools_1.addToolsToServer)(server, toolModules, identityConfig);
     // 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) => {
+    // Debug: log what tools are being injected
+    const toolPaths = Object.keys(exports.injectedTools);
+    console.error("[loadTools] Injected tool paths:", toolPaths);
+    const toolPromises = toolPaths.map((path) => exports.injectedTools[path]().then((toolModule) => {
+        console.error("[loadTools] Loaded tool from path:", path);
         toolModules.set(path, toolModule);
     }));
     return [toolPromises, toolModules];
 }
 async function createServer() {
-    const server = new index_js_1.Server(exports.INJECTED_CONFIG);
+    console.error("[createServer] Starting server creation");
+    // Guard against double initialization using global scope
+    // This ensures singleton even if webpack creates multiple module instances
+    if (typeof global !== 'undefined' && global.__MCPI_SERVER_CREATED__) {
+        console.error("[createServer] Server already exists, returning cached instance");
+        if (global.__MCPI_SERVER_INSTANCE__) {
+            return global.__MCPI_SERVER_INSTANCE__;
+        }
+    }
+    console.error("[createServer] Creating new McpServer");
+    console.error("[createServer] SERVER_INFO constant:", JSON.stringify(exports.SERVER_INFO));
+    console.error("[createServer] SERVER_CAPABILITIES constant:", JSON.stringify(exports.SERVER_CAPABILITIES));
+    console.error("[createServer] Calling: new McpServer(SERVER_INFO, SERVER_CAPABILITIES)");
+    const server = new index_js_1.Server(exports.SERVER_INFO, exports.SERVER_CAPABILITIES);
+    console.error("[createServer] Server created successfully");
+    // Debug: Verify what the server actually received
+    const serverAny = server;
+    console.error("[createServer] Actual server._serverInfo:", JSON.stringify(serverAny._serverInfo || "undefined"));
+    console.error("[createServer] Actual server._capabilities:", JSON.stringify(serverAny._capabilities || "undefined"));
+    console.error("[createServer] Loading tools...");
     const [toolPromises, toolModules] = loadTools();
     await Promise.all(toolPromises);
-    return configureServer(server, toolModules);
+    console.error("[createServer] Tools loaded, configuring server");
+    const configuredServer = await configureServer(server, toolModules);
+    console.error("[createServer] Server configured successfully");
+    // Store in global scope
+    if (typeof global !== 'undefined') {
+        global.__MCPI_SERVER_CREATED__ = true;
+        global.__MCPI_SERVER_INSTANCE__ = configuredServer;
+    }
+    return configuredServer;
 }

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

@@ -1,8 +1,25 @@
 import { Server as McpServer } from "@modelcontextprotocol/sdk/server/index.js";
 import { ZodTypeAny } from "zod";
 import { ToolFile } from "./server";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { DetachedProof } from "@kya-os/contracts/proof";
 export type ZodRawShape = {
     [k: string]: ZodTypeAny;
 };
+export type MCPICallToolResult = CallToolResult & {
+    _meta?: {
+        proof?: DetachedProof;
+        [key: string]: unknown;
+    };
+};
+declare global {
+    var __MCPI_HANDLERS_REGISTERED__: boolean | undefined;
+}
 /** Loads tools and injects them into the server */
-export declare function addToolsToServer(server: McpServer, toolModules: Map<string, ToolFile>): McpServer;
+export declare function addToolsToServer(server: McpServer, toolModules: Map<string, ToolFile>, identityConfig?: {
+    enabled: boolean;
+    debug?: boolean;
+    environment?: string;
+    devIdentityPath?: string;
+    privacyMode?: boolean;
+}): Promise<McpServer>;

package/dist/runtime/utils/tools.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addToolsToServer = addToolsToServer;
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const proof_1 = require("../proof");
+const identity_1 = require("../identity");
 /** Validates if a value is a valid Zod schema object */
 function isZodRawShape(value) {
     if (typeof value !== "object" || value === null) {
@@ -22,8 +24,43 @@ function pathToName(path) {
     const fileName = path.split("/").pop() || path;
     return fileName.replace(/\.[^/.]+$/, "");
 }
+if (typeof global !== 'undefined') {
+    global.__MCPI_HANDLERS_REGISTERED__ = global.__MCPI_HANDLERS_REGISTERED__ || false;
+}
 /** Loads tools and injects them into the server */
-function addToolsToServer(server, toolModules) {
+async function addToolsToServer(server, toolModules, identityConfig) {
+    // Guard against double registration using global scope
+    // Set this IMMEDIATELY to prevent race conditions
+    if (typeof global !== 'undefined') {
+        if (global.__MCPI_HANDLERS_REGISTERED__) {
+            console.error("[MCPI] Handlers already registered, skipping duplicate registration");
+            return server;
+        }
+        // Mark as registered RIGHT NOW before doing anything else
+        global.__MCPI_HANDLERS_REGISTERED__ = true;
+    }
+    console.error("[MCPI] Registering handlers for the first time");
+    // Initialize identity manager if identity is enabled
+    let identityManager = null;
+    if (identityConfig?.enabled) {
+        try {
+            identityManager = new identity_1.IdentityManager({
+                environment: identityConfig.environment ||
+                    "development",
+                devIdentityPath: identityConfig.devIdentityPath,
+            });
+            // Ensure identity exists (loads or generates it)
+            const identity = await identityManager.ensureIdentity();
+            if (identityConfig.debug) {
+                console.error(`[MCPI] Identity enabled - DID: ${identity.did}`);
+                console.error(`[MCPI] Identity path: ${identityConfig.devIdentityPath || '.mcpi/identity.json'}`);
+            }
+        }
+        catch (error) {
+            console.error("[MCPI] Failed to initialize identity:", error);
+            // Continue without identity if initialization fails
+        }
+    }
     // Collect all tools and their handlers
     const tools = [];
     const toolHandlers = new Map();
@@ -67,6 +104,8 @@ function addToolsToServer(server, toolModules) {
         tools.push(tool);
         toolHandlers.set(toolConfig.name, handler);
     });
+    // Debug: log server state before registering handler
+    console.error("[MCPI] About to register tools/list handler");
     // Register tools/list handler
     server.setRequestHandler(types_js_1.ListToolsRequestSchema, async (request) => {
         return {
@@ -89,8 +128,10 @@ function addToolsToServer(server, toolModules) {
             };
         }
         try {
+            // Execute the tool handler
             const result = await handler(args || {});
-            return {
+            // Build base response
+            const baseResponse = {
                 content: [
                     {
                         type: "text",
@@ -98,6 +139,55 @@ function addToolsToServer(server, toolModules) {
                     },
                 ],
             };
+            // If identity is enabled, generate cryptographic proof
+            if (identityManager) {
+                try {
+                    // Ensure identity exists
+                    const identity = await identityManager.ensureIdentity();
+                    // Create a session context for this request
+                    const toolRequest = {
+                        method: name,
+                        params: args || {},
+                    };
+                    const toolResponse = {
+                        data: result,
+                    };
+                    // Create a session context for standalone tool calls
+                    // In a full implementation, this would use proper handshake
+                    // TODO: Use proper handshake
+                    const timestamp = Math.floor(Date.now() / 1000);
+                    const session = {
+                        sessionId: `tool-${Date.now()}`,
+                        nonce: `${Date.now()}`,
+                        audience: "client",
+                        createdAt: timestamp,
+                        timestamp,
+                        lastActivity: timestamp,
+                        ttlMinutes: 30,
+                    };
+                    // Generate proof using the proof generator
+                    const proofGen = new proof_1.ProofGenerator(identity);
+                    const proof = await proofGen.generateProof(toolRequest, toolResponse, session);
+                    if (identityConfig?.debug) {
+                        console.error(`[MCPI] Generated proof for tool "${name}" - DID: ${proof.meta.did}`);
+                    }
+                    // Return response with proof metadata
+                    return {
+                        ...baseResponse,
+                        _meta: {
+                            proof,
+                        },
+                    };
+                }
+                catch (proofError) {
+                    if (identityConfig?.debug) {
+                        console.error(`[MCPI] Failed to generate proof for tool "${name}":`, proofError);
+                    }
+                    // Return base response without proof if generation fails
+                    return baseResponse;
+                }
+            }
+            return baseResponse;
         }
         catch (error) {
             return {
@@ -111,5 +201,6 @@ function addToolsToServer(server, toolModules) {
             };
         }
     });
+    console.error("[MCPI] Handlers registered successfully");
     return server;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kya-os/mcp-i",
-  "version": "1.2.6",
+  "version": "1.2.8",
   "description": "The TypeScript MCP framework with identity features built-in",
   "type": "commonjs",
   "main": "dist/index.js",