@kya-os/mcp-i 1.2.7 → 1.2.9

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;
@@ -14,16 +14,20 @@ const rawIdentityConfig = typeof IDENTITY_CONFIG !== "undefined" ? IDENTITY_CONF
 const identityConfig = rawIdentityConfig
     ? JSON.parse(rawIdentityConfig)
     : undefined;
-exports.INJECTED_CONFIG = {
-    // TODO get from project config
+// 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) {
     await (0, tools_1.addToolsToServer)(server, toolModules, identityConfig);
@@ -32,14 +36,45 @@ async function configureServer(server, toolModules) {
 }
 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

@@ -12,9 +12,14 @@ export type MCPICallToolResult = CallToolResult & {
         [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>, identityConfig?: {
     enabled: boolean;
     debug?: boolean;
     environment?: string;
+    devIdentityPath?: string;
+    privacyMode?: boolean;
 }): Promise<McpServer>;

package/dist/runtime/utils/tools.js

@@ -24,19 +24,36 @@ 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 */
 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",
+                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) {
@@ -87,6 +104,8 @@ async function addToolsToServer(server, toolModules, identityConfig) {
         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 {
@@ -135,6 +154,7 @@ async function addToolsToServer(server, toolModules, identityConfig) {
                     };
                     // 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()}`,
@@ -181,5 +201,6 @@ async function addToolsToServer(server, toolModules, identityConfig) {
             };
         }
     });
+    console.error("[MCPI] Handlers registered successfully");
     return server;
 }

package/package.json

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