@kya-os/mcp-i 0.1.0-alpha.3.6 → 0.1.0-alpha.3.8

package/README.md

@@ -18,6 +18,7 @@ v1.0.0 will be released this week.
 - **Build Reputation** - Every interaction is signed and verifiable
 - **Future-Proof** - Ready for the decentralized agent ecosystem
 - **Production-Ready** - Optimized for Lambda, Edge, Next.js, and traditional deployments
+- **Fast Registration** - New CLI endpoint provides 100-200ms registration (10-50x faster!)
 
 **For Directory Maintainers:**
 
@@ -48,7 +49,21 @@ import "@kya-os/mcp-i/auto";
 // That's it! Your server now has cryptographic identity
 ```
 
-### 2. Production Configuration
+### 2. With Progress Tracking (CLI Tools)
+
+```typescript
+import { enableMCPIdentity } from "@kya-os/mcp-i";
+
+const identity = await enableMCPIdentity({
+  name: "My CLI Tool",
+  // Progress callback automatically triggers fast CLI endpoint (100-200ms)
+  onProgress: (event) => {
+    console.log(`${event.stage}: ${event.message}`);
+  }
+});
+```
+
+### 3. Production Configuration
 
 ```typescript
 import { enableMCPIdentity } from "@kya-os/mcp-i";

package/dist/cjs/index.js

@@ -41,6 +41,7 @@ exports.enableMCPIdentity = enableMCPIdentity;
 exports.createMCPMiddleware = createMCPMiddleware;
 const crypto = __importStar(require("./crypto"));
 const storage_1 = require("./storage");
+const platform_info_1 = require("./platform-info");
 const transport_1 = require("./transport");
 const logger_1 = require("./logger");
 const rotation_1 = require("./rotation");
@@ -89,15 +90,19 @@ class MCPIdentity {
         this.timestampTolerance = options.timestampTolerance || 60000;
         this.enableNonceTracking = options.enableNonceTracking !== false;
         this.directories = identity.directories || 'verified';
-        this.storage = storage_1.StorageFactory.create({
-            storage: options.storage,
-            customPath: options.persistencePath,
-            memoryKey: options.memoryKey || this.did,
-            encryptionPassword: options.encryptionPassword
-        });
-        this.transport = transport_1.TransportFactory.create({
-            transport: options.transport
-        });
+        this.storage = (typeof options?.storage === 'object' && 'load' in options.storage)
+            ? options.storage
+            : storage_1.StorageFactory.create({
+                storage: options.storage,
+                customPath: options.persistencePath,
+                memoryKey: options.memoryKey || this.did,
+                encryptionPassword: options.encryptionPassword
+            });
+        this.transport = (typeof options?.transport === 'object' && 'post' in options.transport)
+            ? options.transport
+            : transport_1.TransportFactory.create({
+                transport: options.transport
+            });
         this.precomputed = {
             did: this.did,
             publicKey: this.publicKey,
@@ -136,12 +141,14 @@ class MCPIdentity {
                 });
             }
         }
-        const storage = storage_1.StorageFactory.create({
-            storage: options?.storage,
-            customPath: options?.persistencePath,
-            memoryKey: options?.memoryKey,
-            encryptionPassword: options?.encryptionPassword
-        });
+        const storage = (typeof options?.storage === 'object' && 'load' in options.storage)
+            ? options.storage
+            : storage_1.StorageFactory.create({
+                storage: options?.storage,
+                customPath: options?.persistencePath,
+                memoryKey: options?.memoryKey,
+                encryptionPassword: options?.encryptionPassword
+            });
         if (!identity) {
             identity = await storage.load();
         }
@@ -157,9 +164,11 @@ class MCPIdentity {
             return globalIdentity;
         }
         logger.info('No existing identity found, creating new identity...');
-        const transport = transport_1.TransportFactory.create({
-            transport: options?.transport
-        });
+        const transport = (typeof options?.transport === 'object' && 'post' in options.transport)
+            ? options.transport
+            : transport_1.TransportFactory.create({
+                transport: options?.transport
+            });
         const apiEndpoint = options?.apiEndpoint || 'https://knowthat.ai';
         logger.info('Registering with knowthat.ai...');
         logger.info('Generating cryptographic keys...');
@@ -201,6 +210,8 @@ class MCPIdentity {
                 ...registrationData,
                 apiEndpoint,
                 directories: options?.directories,
+                processingMode: options?.processingMode,
+                registryEndpoint: options?.registryEndpoint,
                 onProgress: options?.onProgress
             });
             options?.onProgress?.({
@@ -566,8 +577,73 @@ function patchMCPServer(identity) {
     catch (error) {
     }
 }
+function determineEndpoint(options) {
+    if (options.registryEndpoint === 'cli')
+        return true;
+    if (options.registryEndpoint === 'auto-register')
+        return false;
+    if (options.registryEndpoint === 'auto' || !options.registryEndpoint) {
+        if (options.onProgress)
+            return true;
+        if (options.processingMode === 'sync')
+            return true;
+        if (process.stdout?.isTTY)
+            return true;
+    }
+    return false;
+}
+async function registerViaCLI(transport, options) {
+    const logger = (0, logger_1.getLogger)();
+    logger.debug('Using fast CLI registration endpoint');
+    const response = await transport.post(`${options.apiEndpoint}/api/agents/cli-register`, {
+        name: options.name,
+        description: options.description,
+        repository: options.repository,
+        publicKey: options.publicKey
+    }, {
+        timeout: 5000,
+        headers: {
+            'Content-Type': 'application/json',
+            'User-Agent': `@kya-os/mcp-i/${(0, platform_info_1.generateClientInfo)().sdkVersion}`
+        }
+    });
+    logger.debug(`CLI registration completed in ${response.data.responseTime}ms`);
+    options.onProgress?.({
+        stage: 'registering',
+        progress: 80,
+        message: 'Registration successful',
+        data: {
+            did: response.data.did,
+            claimUrl: response.data.claimUrl
+        }
+    });
+    return {
+        success: response.data.success,
+        did: response.data.did,
+        agent: {
+            id: response.data.agent.id,
+            slug: response.data.agent.slug,
+            name: response.data.agent.name,
+            url: response.data.agent.url,
+            claimUrl: response.data.claimUrl
+        },
+        keys: response.data.keys || {
+            publicKey: options.publicKey || '',
+            privateKey: undefined
+        }
+    };
+}
 async function autoRegister(transport, options) {
     const logger = (0, logger_1.getLogger)();
+    const shouldUseCLI = determineEndpoint(options);
+    if (shouldUseCLI) {
+        try {
+            return await registerViaCLI(transport, options);
+        }
+        catch (error) {
+            logger.debug(`CLI registration failed: ${error.message}, falling back to auto-register`);
+        }
+    }
     try {
         const requestBody = {
             metadata: {
@@ -579,18 +655,19 @@ async function autoRegister(transport, options) {
                 isDraft: options.isDraft,
                 directories: options.directories || 'verified'
             },
-            clientInfo: {
-                sdkVersion: '0.1.0-alpha.2.5',
-                language: 'typescript',
-                platform: typeof process !== 'undefined' ? 'node' : 'browser'
-            }
+            clientInfo: (0, platform_info_1.generateClientInfo)({
+                processingMode: options.processingMode === 'auto' ? undefined : options.processingMode,
+                customMetadata: {
+                    source: 'auto-register'
+                }
+            })
         };
         logger.debug('Sending registration request to:', `${options.apiEndpoint}/api/agents/auto-register`);
         const response = await transport.post(`${options.apiEndpoint}/api/agents/auto-register`, requestBody, {
             timeout: 30000,
             headers: {
                 'Content-Type': 'application/json',
-                'User-Agent': '@kya-os/mcp-i/0.1.0-alpha.2.5'
+                'User-Agent': `@kya-os/mcp-i/${requestBody.clientInfo.sdkVersion}`
             }
         });
         logger.debug('Registration response received:', {

package/dist/cjs/platform-info.d.ts

@@ -0,0 +1,36 @@
+export interface ClientInfo {
+    sdkVersion: string;
+    language: string;
+    platform: string;
+    runtime?: {
+        name: string;
+        version?: string;
+        environment?: string;
+    };
+    processingMode?: 'sync' | 'async';
+    metadata?: Record<string, any>;
+}
+export interface PlatformInfo {
+    platform: string;
+    runtime: string;
+    version?: string;
+    environment?: string;
+    capabilities: {
+        fileSystem: boolean;
+        asyncRuntime: boolean;
+        persistentStorage: boolean;
+        longRunning: boolean;
+    };
+}
+export declare function detectPlatform(): PlatformInfo;
+export declare function generateClientInfo(options?: {
+    processingMode?: 'sync' | 'async';
+    customMetadata?: Record<string, any>;
+}): ClientInfo;
+export declare function getPlatformRecommendations(platformInfo?: PlatformInfo): {
+    storage: "file" | "memory" | "auto";
+    transport: "fetch" | "axios" | "auto";
+    processingMode: "sync" | "async";
+    logLevel: "debug" | "info" | "warn" | "error" | "silent";
+};
+export declare function getCachedPlatformInfo(): PlatformInfo;

package/dist/cjs/platform-info.js

@@ -0,0 +1,274 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPlatform = detectPlatform;
+exports.generateClientInfo = generateClientInfo;
+exports.getPlatformRecommendations = getPlatformRecommendations;
+exports.getCachedPlatformInfo = getCachedPlatformInfo;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function getSdkVersion() {
+    try {
+        const strategies = [
+            () => {
+                if (typeof require !== 'undefined') {
+                    try {
+                        return require('../package.json').version;
+                    }
+                    catch {
+                        const packagePath = path.join(process.cwd(), 'node_modules', '@kya-os', 'mcp-i', 'package.json');
+                        if (fs.existsSync(packagePath)) {
+                            return JSON.parse(fs.readFileSync(packagePath, 'utf-8')).version;
+                        }
+                    }
+                }
+                throw new Error('require not available');
+            },
+            () => {
+                const possiblePaths = [
+                    path.join(__dirname, '..', 'package.json'),
+                    path.join(__dirname, '..', '..', 'package.json'),
+                    path.join(process.cwd(), 'packages', 'mcp-i', 'package.json')
+                ];
+                for (const packagePath of possiblePaths) {
+                    if (fs.existsSync(packagePath)) {
+                        return JSON.parse(fs.readFileSync(packagePath, 'utf-8')).version;
+                    }
+                }
+                throw new Error('package.json not found');
+            },
+            () => '0.1.0-alpha.3.6'
+        ];
+        for (const strategy of strategies) {
+            try {
+                return strategy();
+            }
+            catch {
+            }
+        }
+    }
+    catch {
+    }
+    return '0.1.0';
+}
+function detectPlatform() {
+    try {
+        if (typeof window !== 'undefined' && typeof window.document !== 'undefined') {
+            return {
+                platform: 'browser',
+                runtime: 'browser',
+                capabilities: {
+                    fileSystem: false,
+                    asyncRuntime: true,
+                    persistentStorage: true,
+                    longRunning: false
+                }
+            };
+        }
+    }
+    catch {
+    }
+    if (typeof Deno !== 'undefined') {
+        return {
+            platform: 'deno',
+            runtime: 'deno',
+            version: Deno.version?.deno,
+            capabilities: {
+                fileSystem: true,
+                asyncRuntime: true,
+                persistentStorage: true,
+                longRunning: true
+            }
+        };
+    }
+    if (typeof Bun !== 'undefined') {
+        return {
+            platform: 'bun',
+            runtime: 'bun',
+            version: Bun.version,
+            capabilities: {
+                fileSystem: true,
+                asyncRuntime: true,
+                persistentStorage: true,
+                longRunning: true
+            }
+        };
+    }
+    if (typeof process !== 'undefined' && process.versions?.node) {
+        let environment;
+        if (process.env.VERCEL_EDGE || process.env.EDGE_RUNTIME) {
+            return {
+                platform: 'edge-light',
+                runtime: 'vercel-edge',
+                version: process.versions.node,
+                environment: 'vercel',
+                capabilities: {
+                    fileSystem: false,
+                    asyncRuntime: true,
+                    persistentStorage: false,
+                    longRunning: false
+                }
+            };
+        }
+        if (process.env.CF_WORKERS || (typeof globalThis !== 'undefined' && globalThis.caches)) {
+            return {
+                platform: 'edge-light',
+                runtime: 'cloudflare-workers',
+                environment: 'cloudflare',
+                capabilities: {
+                    fileSystem: false,
+                    asyncRuntime: true,
+                    persistentStorage: true,
+                    longRunning: false
+                }
+            };
+        }
+        if (process.env.AWS_LAMBDA_FUNCTION_NAME || process.env.LAMBDA_TASK_ROOT) {
+            environment = 'lambda';
+            return {
+                platform: 'node',
+                runtime: 'node',
+                version: process.versions.node,
+                environment,
+                capabilities: {
+                    fileSystem: true,
+                    asyncRuntime: true,
+                    persistentStorage: false,
+                    longRunning: false
+                }
+            };
+        }
+        if (process.env.VERCEL && !process.env.VERCEL_EDGE) {
+            environment = 'vercel-functions';
+        }
+        if (process.env.NETLIFY) {
+            environment = 'netlify-functions';
+        }
+        if (process.env.DOCKER_CONTAINER) {
+            environment = 'docker';
+        }
+        else {
+            try {
+                if (fs.existsSync('/proc/1/cgroup') && fs.readFileSync('/proc/1/cgroup', 'utf-8').includes('docker')) {
+                    environment = 'docker';
+                }
+            }
+            catch {
+            }
+        }
+        if (process.env.NEXT_RUNTIME) {
+            environment = `nextjs-${process.env.NEXT_RUNTIME}`;
+        }
+        return {
+            platform: 'node',
+            runtime: 'node',
+            version: process.versions.node,
+            environment,
+            capabilities: {
+                fileSystem: true,
+                asyncRuntime: true,
+                persistentStorage: true,
+                longRunning: environment !== 'lambda' && environment !== 'vercel-functions'
+            }
+        };
+    }
+    return {
+        platform: 'unknown',
+        runtime: 'unknown',
+        capabilities: {
+            fileSystem: false,
+            asyncRuntime: true,
+            persistentStorage: false,
+            longRunning: false
+        }
+    };
+}
+function generateClientInfo(options) {
+    const platformInfo = detectPlatform();
+    const sdkVersion = getSdkVersion();
+    let defaultProcessingMode = 'sync';
+    if (!platformInfo.capabilities.longRunning || platformInfo.platform === 'edge-light') {
+        defaultProcessingMode = 'async';
+    }
+    const clientInfo = {
+        sdkVersion,
+        language: 'javascript',
+        platform: platformInfo.platform,
+        processingMode: options?.processingMode || defaultProcessingMode
+    };
+    if (platformInfo.runtime !== platformInfo.platform) {
+        clientInfo.runtime = {
+            name: platformInfo.runtime,
+            version: platformInfo.version,
+            environment: platformInfo.environment
+        };
+    }
+    if (options?.customMetadata) {
+        clientInfo.metadata = options.customMetadata;
+    }
+    return clientInfo;
+}
+function getPlatformRecommendations(platformInfo) {
+    const info = platformInfo || detectPlatform();
+    const recommendations = {
+        storage: 'auto',
+        transport: 'auto',
+        processingMode: 'sync',
+        logLevel: 'info'
+    };
+    if (!info.capabilities.fileSystem || !info.capabilities.persistentStorage) {
+        recommendations.storage = 'memory';
+    }
+    else {
+        recommendations.storage = 'file';
+    }
+    if (info.platform === 'edge-light' || info.platform === 'browser') {
+        recommendations.transport = 'fetch';
+    }
+    if (!info.capabilities.longRunning) {
+        recommendations.processingMode = 'async';
+    }
+    if (info.environment === 'lambda' || info.platform === 'edge-light') {
+        recommendations.logLevel = 'error';
+    }
+    return recommendations;
+}
+let cachedPlatformInfo = null;
+function getCachedPlatformInfo() {
+    if (!cachedPlatformInfo) {
+        cachedPlatformInfo = detectPlatform();
+    }
+    return cachedPlatformInfo;
+}

package/dist/cjs/registry/knowthat.d.ts

@@ -1,12 +1,16 @@
-import { RegistryAdapter, RegistryPublishData, RegistryPublishResult, RegistryStatus } from '../types';
+import { RegistryAdapter, RegistryPublishData, RegistryPublishResult, RegistryStatus, MCPIdentityOptions } from '../types';
 import { Transport } from '../transport';
 export declare class KnowThatRegistry implements RegistryAdapter {
     name: string;
     type: 'primary' | 'secondary';
     private endpoint;
     private transport;
-    constructor(endpoint?: string, transport?: Transport);
+    private options?;
+    constructor(endpoint?: string, transport?: Transport, options?: MCPIdentityOptions);
+    private publishViaCLI;
+    private shouldUseCLIEndpoint;
     publish(data: RegistryPublishData): Promise<RegistryPublishResult>;
+    private publishViaAutoRegister;
     verify(did: string): Promise<boolean>;
     getStatus(did: string): Promise<RegistryStatus>;
     private extractAgentSlug;

package/dist/cjs/registry/knowthat.js

@@ -4,16 +4,89 @@ exports.KnowThatRegistry = void 0;
 const transport_1 = require("../transport");
 const polling_1 = require("../polling");
 const logger_1 = require("../logger");
+const platform_info_1 = require("../platform-info");
 class KnowThatRegistry {
-    constructor(endpoint = 'https://knowthat.ai', transport) {
+    constructor(endpoint = 'https://knowthat.ai', transport, options) {
         this.name = 'knowthat';
         this.type = 'primary';
         this.endpoint = endpoint;
         this.transport = transport || transport_1.TransportFactory.create();
+        this.options = options;
+    }
+    async publishViaCLI(data) {
+        const logger = (0, logger_1.getLogger)();
+        try {
+            logger.debug('Using fast CLI registration endpoint');
+            const response = await this.transport.post(`${this.endpoint}/api/agents/cli-register`, {
+                name: data.name,
+                description: data.description,
+                repository: data.repository,
+                publicKey: data.publicKey
+            }, {
+                timeout: 5000,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'User-Agent': `@kya-os/mcp-i/${(0, platform_info_1.generateClientInfo)().sdkVersion}`
+                }
+            });
+            logger.debug(`CLI registration completed in ${response.data.responseTime}ms`);
+            if (response.data.keys && !data.publicKey) {
+                logger.warn(response.data.keys.warning || 'Server generated keys - store them securely!');
+            }
+            return {
+                success: true,
+                registryAgentId: response.data.agent.id,
+                profileUrl: response.data.agent.url,
+                claimUrl: response.data.claimUrl,
+                claimToken: response.data.claimToken,
+                generatedKeys: response.data.keys
+            };
+        }
+        catch (error) {
+            logger.debug(`CLI registration failed: ${error.message}`);
+            throw error;
+        }
+    }
+    shouldUseCLIEndpoint() {
+        if (this.options?.registryEndpoint === 'cli')
+            return true;
+        if (this.options?.registryEndpoint === 'auto-register')
+            return false;
+        if (this.options?.registryEndpoint === 'auto' || !this.options?.registryEndpoint) {
+            if (this.options?.onProgress)
+                return true;
+            if (this.options?.processingMode === 'sync')
+                return true;
+            if (process.stdout?.isTTY)
+                return true;
+        }
+        return false;
     }
     async publish(data) {
+        const logger = (0, logger_1.getLogger)();
+        const useCLI = this.shouldUseCLIEndpoint();
+        if (useCLI) {
+            try {
+                return await this.publishViaCLI(data);
+            }
+            catch (error) {
+                logger.debug('CLI endpoint failed, falling back to auto-register');
+            }
+        }
+        return await this.publishViaAutoRegister(data);
+    }
+    async publishViaAutoRegister(data) {
         const logger = (0, logger_1.getLogger)();
         try {
+            const clientInfo = (0, platform_info_1.generateClientInfo)({
+                processingMode: this.options?.processingMode === 'auto'
+                    ? undefined
+                    : this.options?.processingMode || 'sync',
+                customMetadata: {
+                    source: 'mcp-i-sdk'
+                }
+            });
+            logger.debug(`Generated client info: ${JSON.stringify(clientInfo)}`);
             const response = await this.transport.post(`${this.endpoint}/api/agents/auto-register`, {
                 metadata: {
                     name: data.name,
@@ -21,19 +94,17 @@ class KnowThatRegistry {
                     repository: data.repository,
                     version: '1.0.0'
                 },
-                clientInfo: {
-                    sdkVersion: '0.2.0',
-                    language: 'typescript',
-                    platform: 'node'
-                },
+                clientInfo,
                 publicKey: data.publicKey || undefined
             }, {
                 timeout: 30000,
                 headers: {
                     'Content-Type': 'application/json',
-                    'User-Agent': '@kya-os/mcp-i/0.2.0'
+                    'User-Agent': `@kya-os/mcp-i/${clientInfo.sdkVersion}`
                 }
             });
+            logger.debug(`Registration response status: ${response.status}`);
+            logger.debug(`Registration response data: ${JSON.stringify(response.data, null, 2)}`);
             if (response.status === 202 && (0, polling_1.isAsyncRegistrationResponse)(response.data)) {
                 logger.debug('Got async registration response, polling for completion...');
                 const result = await (0, polling_1.pollRegistrationStatus)(response.data.status, this.transport, {