@kya-os/mcp-i 0.1.0-alpha.2.7 → 0.1.0-alpha.2.9

package/dist/auto.js

@@ -9,5 +9,8 @@ const logger_1 = require("./logger");
     catch (error) {
         const logger = (0, logger_1.getLogger)();
         logger.error('[MCP-I] Failed to auto-initialize:', error);
+        if (error.stack) {
+            logger.debug('[MCP-I] Error stack:', error.stack);
+        }
     }
 })();

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { MCPIdentityOptions, Challenge, ChallengeResponse, MCPICapabilities, SignedResponse, MCPMiddleware, DirectoryPreference } from './types';
 import { KeyRotationResult, KeyHealth } from './rotation';
 export * from './types';
+export * from './vercel-adapter';
 export { RegistryFactory, REGISTRY_TIERS, resolveRegistries } from './registry';
 export { LoggerFactory, ConsoleLogger, SilentLogger } from './logger';
 export { StorageFactory, MemoryStorage, FileStorage } from './storage';

package/dist/index.js

@@ -44,7 +44,9 @@ const storage_1 = require("./storage");
 const transport_1 = require("./transport");
 const logger_1 = require("./logger");
 const rotation_1 = require("./rotation");
+const vercel_adapter_1 = require("./vercel-adapter");
 __exportStar(require("./types"), exports);
+__exportStar(require("./vercel-adapter"), exports);
 var registry_1 = require("./registry");
 Object.defineProperty(exports, "RegistryFactory", { enumerable: true, get: function () { return registry_1.RegistryFactory; } });
 Object.defineProperty(exports, "REGISTRY_TIERS", { enumerable: true, get: function () { return registry_1.REGISTRY_TIERS; } });
@@ -110,13 +112,24 @@ class MCPIdentity {
         if (globalIdentity) {
             return globalIdentity;
         }
+        const isVercel = process.env.VERCEL || process.env.VERCEL_ENV;
+        const isServerless = isVercel || process.env.AWS_LAMBDA_FUNCTION_NAME || process.env.FUNCTIONS_WORKER_RUNTIME;
+        let identity = null;
+        if (isServerless || options?.storage === 'memory') {
+            identity = (0, vercel_adapter_1.loadIdentityFromEnv)();
+            if (identity) {
+                logger.info('✅ Loaded existing identity from environment variables');
+            }
+        }
         const storage = storage_1.StorageFactory.create({
             storage: options?.storage,
             customPath: options?.persistencePath,
             memoryKey: options?.memoryKey,
             encryptionPassword: options?.encryptionPassword
         });
-        let identity = await storage.load();
+        if (!identity) {
+            identity = await storage.load();
+        }
         if (identity) {
             logger.info('Loaded existing identity:', identity.did);
             globalIdentity = new MCPIdentity(identity, options);
@@ -136,7 +149,7 @@ class MCPIdentity {
             repository: options?.repository,
             publicKey: keyPair.publicKey,
             directories: options?.directories,
-            isDraft: options?.mode === 'development'
+            isDraft: options?.mode !== 'production'
         };
         logger.debug('Registration data:', {
             name: registrationData.name,
@@ -190,17 +203,22 @@ class MCPIdentity {
             directories: options?.directories || 'verified'
         };
         await storage.save(identity);
-        logger.info('✅ Success! Your agent has been registered.');
-        logger.info(`DID: ${response.did}`);
-        logger.info(`Profile: ${response.agent.url}`);
-        if (response.agent.claimUrl) {
-            logger.info(`Claim your agent: ${response.agent.claimUrl}`);
-        }
-        if (options?.directories && options.directories !== 'none') {
-            const dirMessage = options.directories === 'verified'
-                ? 'Your agent will be submitted to all verified directories'
-                : `Your agent will be submitted to: ${options.directories.join(', ')}`;
-            logger.info(dirMessage);
+        if (isServerless) {
+            (0, vercel_adapter_1.showVercelDeveloperInstructions)(identity, response.agent.claimUrl);
+        }
+        else {
+            logger.info('✅ Success! Your agent has been registered.');
+            logger.info(`DID: ${response.did}`);
+            logger.info(`Profile: ${response.agent.url}`);
+            if (response.agent.claimUrl) {
+                logger.info(`Claim your agent: ${response.agent.claimUrl}`);
+            }
+            if (options?.directories && options.directories !== 'none') {
+                const dirMessage = options.directories === 'verified'
+                    ? 'Your agent will be submitted to all verified directories'
+                    : `Your agent will be submitted to: ${options.directories.join(', ')}`;
+                logger.info(dirMessage);
+            }
         }
         globalIdentity = new MCPIdentity(identity, options);
         return globalIdentity;
@@ -421,9 +439,24 @@ async function enableMCPIdentity(options) {
 }
 function createMCPMiddleware(identity) {
     return (server) => {
+        if (!server || typeof server !== 'object') {
+            const logger = (0, logger_1.getLogger)();
+            logger.warn('Invalid MCP Server object passed to middleware');
+            return;
+        }
+        if (!server.setRequestHandler || typeof server.setRequestHandler !== 'function') {
+            const logger = (0, logger_1.getLogger)();
+            logger.warn('MCP Server missing setRequestHandler method');
+            return;
+        }
         const originalSetRequestHandler = server.setRequestHandler.bind(server);
-        const originalConnect = server.connect.bind(server);
+        const originalConnect = server.connect ? server.connect.bind(server) : null;
         server.setRequestHandler = function (method, handler) {
+            if (!method || typeof method !== 'string') {
+                const logger = (0, logger_1.getLogger)();
+                logger.warn('setRequestHandler called with invalid method:', method);
+                return originalSetRequestHandler.call(this, method, handler);
+            }
             const wrappedHandler = async (...args) => {
                 const result = await handler(...args);
                 if (result && typeof result === 'object' && 'content' in result) {
@@ -433,15 +466,17 @@ function createMCPMiddleware(identity) {
             };
             return originalSetRequestHandler(method, wrappedHandler);
         };
-        server.connect = async function (transport) {
-            if (this.serverInfo && this.serverInfo.capabilities) {
-                this.serverInfo.capabilities['mcp-i'] = identity.getCapabilities();
-            }
-            this.setRequestHandler('mcp-i/challenge', async (request) => {
-                return identity.respondToChallenge(request.params);
-            });
-            return originalConnect(transport);
-        };
+        if (originalConnect) {
+            server.connect = async function (transport) {
+                if (this.serverInfo && this.serverInfo.capabilities) {
+                    this.serverInfo.capabilities['mcp-i'] = identity.getCapabilities();
+                }
+                this.setRequestHandler('mcp-i/challenge', async (request) => {
+                    return identity.respondToChallenge(request.params);
+                });
+                return originalConnect.call(this, transport);
+            };
+        }
     };
 }
 function patchMCPServer(identity) {
@@ -455,7 +490,13 @@ function patchMCPServer(identity) {
         const OriginalConstructor = OriginalServer;
         MCPModule.Server = function (...args) {
             const instance = new OriginalConstructor(...args);
-            middleware(instance, identity);
+            try {
+                middleware(instance, identity);
+            }
+            catch (error) {
+                const logger = (0, logger_1.getLogger)();
+                logger.warn('Failed to apply MCP-I middleware:', error);
+            }
             return instance;
         };
         Object.setPrototypeOf(MCPModule.Server, OriginalConstructor);

package/dist/nextjs.d.ts

@@ -0,0 +1,10 @@
+import { MCPIdentity } from './index';
+import { MCPIdentityOptions } from './types';
+export interface NextJSMCPOptions extends Omit<MCPIdentityOptions, 'transport' | 'storage'> {
+    storage?: 'memory';
+    transport?: 'fetch';
+    showSetupInstructions?: boolean;
+}
+export declare function enableMCPIdentityForNextJS(options?: NextJSMCPOptions): Promise<MCPIdentity>;
+export { enableMCPIdentity, MCPIdentity } from './index';
+export * from './types';

package/dist/nextjs.js

@@ -0,0 +1,82 @@
+"use strict";
+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 });
+exports.MCPIdentity = exports.enableMCPIdentity = void 0;
+exports.enableMCPIdentityForNextJS = enableMCPIdentityForNextJS;
+const index_1 = require("./index");
+async function enableMCPIdentityForNextJS(options = {}) {
+    const isProduction = process.env.NODE_ENV === 'production';
+    const isVercel = process.env.VERCEL || process.env.VERCEL_ENV;
+    try {
+        console.log(`\n🚀 Initializing MCP-I for Next.js...`);
+        const identity = await (0, index_1.enableMCPIdentity)({
+            ...options,
+            transport: 'fetch',
+            storage: 'memory',
+            logLevel: options.logLevel || (isProduction ? 'error' : 'info'),
+            mode: isProduction ? 'production' : 'development',
+        });
+        if (!isProduction && options.showSetupInstructions !== false) {
+            console.log('\n✅ MCP-I Ready for Next.js!');
+            console.log(`\n📋 Quick Info:`);
+            console.log(`   Environment: ${isVercel ? 'Vercel' : 'Local'}`);
+            console.log(`   DID: ${identity.did}`);
+            if (isVercel && !process.env.MCP_IDENTITY_DID) {
+                console.log('\n⚠️  Remember to set environment variables in Vercel Dashboard!');
+                console.log('   See console output above for the exact variables to add.');
+            }
+        }
+        return identity;
+    }
+    catch (error) {
+        console.error('\n❌ MCP-I Initialization Failed\n');
+        if (error?.message?.includes('429')) {
+            console.error('📛 Rate Limit Hit');
+            console.error('   You\'ve made too many registration attempts.');
+            console.error('   Wait a few minutes and try again.');
+            console.error('\n💡 Tip: In development, you can use environment variables to persist identity:');
+            console.error('   1. Copy the MCP_IDENTITY_* variables from a successful run');
+            console.error('   2. Add them to your .env.local file');
+        }
+        else if (error?.message?.includes('500') || error?.message?.includes('fetch failed')) {
+            console.error('📛 Server Connection Error');
+            console.error('   Cannot connect to knowthat.ai registry.');
+            console.error('\n💡 Possible causes:');
+            console.error('   - Registry is temporarily down');
+            console.error('   - Network connectivity issues');
+            console.error('   - Firewall blocking outbound connections');
+            console.error('\n💡 Workaround for development:');
+            console.error('   Add to your route: mode: "development" to allow offline mode');
+        }
+        else if (error?.message?.includes('MODULE_NOT_FOUND')) {
+            console.error('📛 Missing Dependencies');
+            console.error('   Make sure all dependencies are installed:');
+            console.error('   npm install @kya-os/mcp-i');
+        }
+        else {
+            console.error('📛 Unexpected Error:', error?.message || error);
+        }
+        if (!isProduction) {
+            console.error('\n🔍 Full Error Details:');
+            console.error(error);
+        }
+        throw error;
+    }
+}
+var index_2 = require("./index");
+Object.defineProperty(exports, "enableMCPIdentity", { enumerable: true, get: function () { return index_2.enableMCPIdentity; } });
+Object.defineProperty(exports, "MCPIdentity", { enumerable: true, get: function () { return index_2.MCPIdentity; } });
+__exportStar(require("./types"), exports);

package/dist/vercel-adapter.d.ts

@@ -0,0 +1,8 @@
+import { MCPIdentityOptions, PersistedIdentity } from './types';
+export interface VercelMCPIdentityOptions extends MCPIdentityOptions {
+    envPrefix?: string;
+    showClaimInstructions?: boolean;
+}
+export declare function loadIdentityFromEnv(prefix?: string): PersistedIdentity | null;
+export declare function generateEnvInstructions(identity: PersistedIdentity, prefix?: string): string;
+export declare function showVercelDeveloperInstructions(identity: PersistedIdentity, claimUrl?: string): void;

package/dist/vercel-adapter.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadIdentityFromEnv = loadIdentityFromEnv;
+exports.generateEnvInstructions = generateEnvInstructions;
+exports.showVercelDeveloperInstructions = showVercelDeveloperInstructions;
+const logger_1 = require("./logger");
+function loadIdentityFromEnv(prefix = 'MCP_IDENTITY_') {
+    const logger = (0, logger_1.getLogger)();
+    try {
+        const did = process.env[`${prefix}DID`];
+        const publicKey = process.env[`${prefix}PUBLIC_KEY`];
+        const privateKey = process.env[`${prefix}PRIVATE_KEY`];
+        const agentId = process.env[`${prefix}AGENT_ID`];
+        const agentSlug = process.env[`${prefix}AGENT_SLUG`];
+        if (did && publicKey && privateKey) {
+            logger.info('📦 Loaded identity from environment variables');
+            return {
+                did,
+                publicKey,
+                privateKey,
+                agentId: agentId || 'unknown',
+                agentSlug: agentSlug || 'unknown',
+                registeredAt: new Date().toISOString(),
+                directories: 'verified'
+            };
+        }
+    }
+    catch (error) {
+        logger.debug('No identity found in environment variables');
+    }
+    return null;
+}
+function generateEnvInstructions(identity, prefix = 'MCP_IDENTITY_') {
+    return `
+# Add these to your Vercel environment variables:
+${prefix}DID="${identity.did}"
+${prefix}PUBLIC_KEY="${identity.publicKey}"
+${prefix}PRIVATE_KEY="${identity.privateKey}"
+${prefix}AGENT_ID="${identity.agentId}"
+${prefix}AGENT_SLUG="${identity.agentSlug}"
+`;
+}
+function showVercelDeveloperInstructions(identity, claimUrl) {
+    const logger = (0, logger_1.getLogger)();
+    console.log('\n');
+    console.log('='.repeat(60));
+    console.log('🎉 MCP-I IDENTITY CREATED SUCCESSFULLY! 🎉');
+    console.log('='.repeat(60));
+    console.log('\n📋 Your Agent Details:\n');
+    console.log(`   DID: ${identity.did}`);
+    console.log(`   Agent ID: ${identity.agentId}`);
+    console.log(`   Profile: https://knowthat.ai/agents/${identity.agentSlug}`);
+    if (claimUrl) {
+        console.log('\n🎯 IMPORTANT: Claim your agent to manage it:');
+        console.log(`   ${claimUrl}`);
+        console.log('\n   This link lets you:');
+        console.log('   - Edit your agent details');
+        console.log('   - Add logos and descriptions');
+        console.log('   - Manage directory listings');
+        console.log('   - View analytics');
+    }
+    console.log('\n⚡ For Vercel Deployment:');
+    console.log('\n1. Add these environment variables in Vercel Dashboard:');
+    console.log(generateEnvInstructions(identity));
+    console.log('2. Your identity will persist across deployments!');
+    console.log('\n' + '='.repeat(60) + '\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kya-os/mcp-i",
-  "version": "0.1.0-alpha.2.7",
+  "version": "0.1.0-alpha.2.9",
   "description": "COMING SOON:Production-ready MCP Identity with automatic registration, key rotation, and optimized performance",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,6 +19,16 @@
       "types": "./dist/registry/index.d.ts",
       "import": "./dist/registry/index.js",
       "require": "./dist/registry/index.js"
+    },
+    "./nextjs": {
+      "types": "./dist/nextjs.d.ts",
+      "import": "./dist/nextjs.js",
+      "require": "./dist/nextjs.js"
+    },
+    "./vercel": {
+      "types": "./dist/vercel-adapter.d.ts",
+      "import": "./dist/vercel-adapter.js",
+      "require": "./dist/vercel-adapter.js"
     }
   },
   "files": [