@kya-os/mcp-i 0.1.0-alpha.3.2 → 0.1.0-alpha.3.4

package/dist/cjs/cli-mode.d.ts

@@ -0,0 +1,16 @@
+import { MCPIdentityOptions, MCPIdentityProgressCallback } from './types.js';
+import { MCPIdentity } from './index.js';
+interface MCPIdentityCLIOptions extends Omit<MCPIdentityOptions, 'logLevel'> {
+    logLevel?: 'debug' | 'info' | 'warn' | 'error' | 'silent';
+    onProgress?: MCPIdentityProgressCallback;
+}
+export declare function enableMCPIdentityCLI(options?: MCPIdentityCLIOptions): Promise<{
+    identity: MCPIdentity;
+    metadata: {
+        isNewIdentity: boolean;
+        did: string;
+        claimUrl?: string;
+        registryUrl: string;
+    };
+}>;
+export type { MCPIdentityProgressEvent, MCPIdentityProgressCallback } from './types.js';

package/dist/cjs/cli-mode.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableMCPIdentityCLI = enableMCPIdentityCLI;
+const index_js_1 = require("./index.js");
+async function enableMCPIdentityCLI(options) {
+    let isNewIdentity = false;
+    let capturedClaimUrl;
+    const wrappedProgress = (event) => {
+        if (event.stage === 'complete' && event.data?.claimUrl) {
+            capturedClaimUrl = event.data.claimUrl;
+        }
+        if (event.stage === 'generating_keys') {
+            isNewIdentity = true;
+        }
+        options?.onProgress?.(event);
+    };
+    const identity = await (0, index_js_1.enableMCPIdentity)({
+        ...options,
+        logLevel: options?.logLevel || 'silent',
+        onProgress: wrappedProgress
+    });
+    const did = identity.did;
+    return {
+        identity,
+        metadata: {
+            isNewIdentity,
+            did,
+            claimUrl: capturedClaimUrl,
+            registryUrl: 'https://knowthat.ai/agents/' + did.split(':').pop()
+        }
+    };
+}

package/dist/cjs/index.d.ts

@@ -8,6 +8,7 @@ export { StorageFactory, MemoryStorage, FileStorage } from './storage';
 export { TransportFactory, RuntimeDetector } from './transport';
 export { KeyRotationManager } from './rotation';
 export { initWithDevExperience, showAgentStatus } from './dev-helper';
+export { pollRegistrationStatus, isAsyncRegistrationResponse } from './polling';
 export declare class MCPIdentity {
     readonly did: string;
     readonly publicKey: string;

package/dist/cjs/index.js

@@ -36,7 +36,7 @@ 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.showAgentStatus = exports.initWithDevExperience = exports.KeyRotationManager = exports.RuntimeDetector = exports.TransportFactory = exports.FileStorage = exports.MemoryStorage = exports.StorageFactory = exports.SilentLogger = exports.ConsoleLogger = exports.LoggerFactory = exports.resolveRegistries = exports.REGISTRY_TIERS = exports.RegistryFactory = void 0;
+exports.MCPIdentity = exports.isAsyncRegistrationResponse = exports.pollRegistrationStatus = exports.showAgentStatus = exports.initWithDevExperience = exports.KeyRotationManager = exports.RuntimeDetector = exports.TransportFactory = exports.FileStorage = exports.MemoryStorage = exports.StorageFactory = exports.SilentLogger = exports.ConsoleLogger = exports.LoggerFactory = exports.resolveRegistries = exports.REGISTRY_TIERS = exports.RegistryFactory = void 0;
 exports.enableMCPIdentity = enableMCPIdentity;
 exports.createMCPMiddleware = createMCPMiddleware;
 const crypto = __importStar(require("./crypto"));
@@ -45,6 +45,7 @@ const transport_1 = require("./transport");
 const logger_1 = require("./logger");
 const rotation_1 = require("./rotation");
 const vercel_adapter_1 = require("./vercel-adapter");
+const polling_1 = require("./polling");
 __exportStar(require("./types"), exports);
 __exportStar(require("./vercel-adapter"), exports);
 var registry_1 = require("./registry");
@@ -67,6 +68,9 @@ Object.defineProperty(exports, "KeyRotationManager", { enumerable: true, get: fu
 var dev_helper_1 = require("./dev-helper");
 Object.defineProperty(exports, "initWithDevExperience", { enumerable: true, get: function () { return dev_helper_1.initWithDevExperience; } });
 Object.defineProperty(exports, "showAgentStatus", { enumerable: true, get: function () { return dev_helper_1.showAgentStatus; } });
+var polling_2 = require("./polling");
+Object.defineProperty(exports, "pollRegistrationStatus", { enumerable: true, get: function () { return polling_2.pollRegistrationStatus; } });
+Object.defineProperty(exports, "isAsyncRegistrationResponse", { enumerable: true, get: function () { return polling_2.isAsyncRegistrationResponse; } });
 let globalIdentity = null;
 class MCPIdentity {
     constructor(identity, options = {}) {
@@ -108,17 +112,28 @@ class MCPIdentity {
         }
     }
     static async init(options) {
-        const logger = options?.logger || (0, logger_1.getLogger)();
+        const logger = options?.logger || (0, logger_1.getLogger)(options?.logLevel);
         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;
+        options?.onProgress?.({
+            stage: 'checking_existing',
+            progress: 10,
+            message: 'Checking for existing identity...'
+        });
         let identity = null;
         if (isServerless || options?.storage === 'memory') {
             identity = (0, vercel_adapter_1.loadIdentityFromEnv)();
             if (identity) {
                 logger.info('✅ Loaded existing identity from environment variables');
+                options?.onProgress?.({
+                    stage: 'complete',
+                    progress: 100,
+                    message: 'Loaded existing identity from environment',
+                    data: { did: identity.did }
+                });
             }
         }
         const storage = storage_1.StorageFactory.create({
@@ -132,6 +147,12 @@ class MCPIdentity {
         }
         if (identity) {
             logger.info('Loaded existing identity:', identity.did);
+            options?.onProgress?.({
+                stage: 'complete',
+                progress: 100,
+                message: 'Loaded existing identity',
+                data: { did: identity.did }
+            });
             globalIdentity = new MCPIdentity(identity, options);
             return globalIdentity;
         }
@@ -142,7 +163,17 @@ class MCPIdentity {
         const apiEndpoint = options?.apiEndpoint || 'https://knowthat.ai';
         logger.info('Registering with knowthat.ai...');
         logger.info('Generating cryptographic keys...');
+        options?.onProgress?.({
+            stage: 'generating_keys',
+            progress: 30,
+            message: 'Generating cryptographic keys...'
+        });
         const keyPair = await crypto.generateKeyPair();
+        options?.onProgress?.({
+            stage: 'generating_keys',
+            progress: 50,
+            message: 'Keys generated successfully'
+        });
         const registrationData = {
             name: options?.name || process.env.MCP_SERVER_NAME || 'Unnamed MCP Server',
             description: options?.description,
@@ -161,10 +192,21 @@ class MCPIdentity {
         });
         let response;
         try {
+            options?.onProgress?.({
+                stage: 'registering',
+                progress: 60,
+                message: 'Registering with KYA-OS network...'
+            });
             response = await autoRegister(transport, {
                 ...registrationData,
                 apiEndpoint,
-                directories: options?.directories
+                directories: options?.directories,
+                onProgress: options?.onProgress
+            });
+            options?.onProgress?.({
+                stage: 'registering',
+                progress: 80,
+                message: 'Registration successful'
             });
         }
         catch (registrationError) {
@@ -202,7 +244,24 @@ class MCPIdentity {
             registeredAt: new Date().toISOString(),
             directories: options?.directories || 'verified'
         };
+        options?.onProgress?.({
+            stage: 'saving',
+            progress: 90,
+            message: 'Saving identity...'
+        });
         await storage.save(identity);
+        options?.onProgress?.({
+            stage: 'complete',
+            progress: 100,
+            message: 'Identity created successfully',
+            data: {
+                did: identity.did,
+                publicKey: identity.publicKey,
+                agentId: identity.agentId,
+                agentSlug: identity.agentSlug,
+                claimUrl: response.agent.claimUrl
+            }
+        });
         if (isServerless) {
             (0, vercel_adapter_1.showVercelDeveloperInstructions)(identity, response.agent.claimUrl);
         }
@@ -537,9 +596,35 @@ async function autoRegister(transport, options) {
         logger.debug('Registration response received:', {
             status: response.status,
             hasData: !!response.data,
-            hasDid: !!response.data?.did,
-            hasAgent: !!response.data?.agent
+            isAsync: response.status === 202
         });
+        if (response.status === 202 && (0, polling_1.isAsyncRegistrationResponse)(response.data)) {
+            logger.info('Registration submitted, waiting for completion...');
+            options.onProgress?.({
+                stage: 'registering',
+                progress: 70,
+                message: 'Registration submitted, processing...',
+                data: { jobId: response.data.jobId }
+            });
+            const result = await (0, polling_1.pollRegistrationStatus)(response.data.status, transport, {
+                pollInterval: 2000,
+                maxPollingTime: 60000,
+                logger,
+                onProgress: (message, progress) => {
+                    options.onProgress?.({
+                        stage: 'registering',
+                        progress: 70 + (progress || 0) * 0.1,
+                        message
+                    });
+                }
+            });
+            logger.debug('Registration completed after polling:', {
+                hasDid: !!result.did,
+                hasAgent: !!result.agent
+            });
+            return result;
+        }
+        logger.debug('Got synchronous registration response');
         return response.data;
     }
     catch (error) {

package/dist/cjs/logger.d.ts

@@ -29,4 +29,4 @@ export declare class LoggerFactory {
     static createSilentLogger(): Logger;
     static reset(): void;
 }
-export declare function getLogger(): Logger;
+export declare function getLogger(logLevel?: LogLevel): Logger;

package/dist/cjs/logger.js

@@ -74,6 +74,12 @@ class LoggerFactory {
 }
 exports.LoggerFactory = LoggerFactory;
 LoggerFactory.instance = new SilentLogger();
-function getLogger() {
+function getLogger(logLevel) {
+    if (logLevel === 'silent') {
+        return new SilentLogger();
+    }
+    else if (logLevel) {
+        return new ConsoleLogger('[MCP-I]', logLevel);
+    }
     return LoggerFactory.getLogger();
 }

package/dist/cjs/nextjs.d.ts

@@ -1,10 +1,10 @@
-import { MCPIdentity } from './index';
-import { MCPIdentityOptions } from './types';
-export interface NextJSMCPOptions extends Omit<MCPIdentityOptions, 'transport' | 'storage'> {
-    storage?: 'memory';
-    transport?: 'fetch';
+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';
+export { enableMCPIdentity, MCPIdentity } from "./index";
+export * from "./types";

package/dist/cjs/nextjs.js

@@ -18,59 +18,60 @@ 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 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',
+            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✅ MCP-I Ready for Next.js!");
             console.log(`\n📋 Quick Info:`);
-            console.log(`   Environment: ${isVercel ? 'Vercel' : 'Local'}`);
+            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.');
+            if (isVercel && !process.env.MCP_IDENTITY_AGENT_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');
+        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:');
+        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 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);
+            console.error("📛 Unexpected Error:", error?.message || error);
         }
         if (!isProduction) {
-            console.error('\n🔍 Full Error Details:');
+            console.error("\n🔍 Full Error Details:");
             console.error(error);
         }
         throw error;

package/dist/cjs/polling.d.ts

@@ -0,0 +1,13 @@
+import { Transport } from './transport';
+import { AutoRegisterResponse } from './types';
+import { Logger } from './logger';
+export declare function pollRegistrationStatus(statusUrl: string, transport: Transport, options?: {
+    pollInterval?: number;
+    maxPollingTime?: number;
+    logger?: Logger;
+    onProgress?: (message: string, progress?: number) => void;
+}): Promise<AutoRegisterResponse>;
+export declare function isAsyncRegistrationResponse(response: any): response is {
+    jobId: string;
+    status: string;
+};

package/dist/cjs/polling.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pollRegistrationStatus = pollRegistrationStatus;
+exports.isAsyncRegistrationResponse = isAsyncRegistrationResponse;
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+async function pollRegistrationStatus(statusUrl, transport, options = {}) {
+    const { pollInterval = 2000, maxPollingTime = 60000, logger, onProgress } = options;
+    const startTime = Date.now();
+    let attempts = 0;
+    logger?.debug(`Starting registration polling: ${statusUrl}`);
+    while (Date.now() - startTime < maxPollingTime) {
+        attempts++;
+        try {
+            const response = await transport.get(statusUrl);
+            const status = response.data;
+            logger?.debug(`Poll attempt ${attempts}: ${status.status}`);
+            const elapsed = Math.floor((Date.now() - startTime) / 1000);
+            const progressMessage = `Registration ${status.status}... (${elapsed}s elapsed)`;
+            if (onProgress) {
+                onProgress(progressMessage, status.progress);
+            }
+            if (status.status === 'completed' && status.result) {
+                logger?.info('Registration completed successfully');
+                return status.result;
+            }
+            if (status.status === 'failed') {
+                const errorMessage = status.error?.message || 'Registration failed';
+                logger?.error(`Registration failed: ${errorMessage}`);
+                throw new Error(errorMessage);
+            }
+            await sleep(pollInterval);
+        }
+        catch (error) {
+            if (error.message && !error.message.includes('ECONNREFUSED')) {
+                throw error;
+            }
+            logger?.debug(`Network error during polling (attempt ${attempts}): ${error.message}`);
+            await sleep(pollInterval);
+        }
+    }
+    const timeoutMessage = `Registration timeout after ${maxPollingTime / 1000} seconds`;
+    logger?.error(timeoutMessage);
+    throw new Error(timeoutMessage);
+}
+function isAsyncRegistrationResponse(response) {
+    return response &&
+        typeof response.jobId === 'string' &&
+        typeof response.status === 'string' &&
+        !response.did;
+}

package/dist/cjs/registry/knowthat.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KnowThatRegistry = void 0;
 const transport_1 = require("../transport");
+const polling_1 = require("../polling");
+const logger_1 = require("../logger");
 class KnowThatRegistry {
     constructor(endpoint = 'https://knowthat.ai', transport) {
         this.name = 'knowthat';
@@ -10,6 +12,7 @@ class KnowThatRegistry {
         this.transport = transport || transport_1.TransportFactory.create();
     }
     async publish(data) {
+        const logger = (0, logger_1.getLogger)();
         try {
             const response = await this.transport.post(`${this.endpoint}/api/agents/auto-register`, {
                 metadata: {
@@ -31,10 +34,27 @@ class KnowThatRegistry {
                     'User-Agent': '@kya-os/mcp-i/0.2.0'
                 }
             });
+            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, {
+                    pollInterval: 2000,
+                    maxPollingTime: 60000,
+                    logger,
+                    onProgress: (message) => {
+                        logger.debug(message);
+                    }
+                });
+                return {
+                    success: true,
+                    registryAgentId: result.agent.id,
+                    profileUrl: result.agent.url
+                };
+            }
+            const syncResponse = response.data;
             return {
                 success: true,
-                registryAgentId: response.data.agent.id,
-                profileUrl: response.data.agent.url
+                registryAgentId: syncResponse.agent.id,
+                profileUrl: syncResponse.agent.url
             };
         }
         catch (error) {

package/dist/cjs/types.d.ts

@@ -33,6 +33,15 @@ export interface RegistryPublishResult {
 }
 export type DirectoryPreference = string[] | 'verified' | 'none';
 export type DirectoryName = 'smithery' | 'glama' | string;
+export interface MCPIdentityProgressEvent {
+    stage: 'checking_existing' | 'generating_keys' | 'registering' | 'saving' | 'complete';
+    progress: number;
+    message?: string;
+    data?: any;
+}
+export interface MCPIdentityProgressCallback {
+    (event: MCPIdentityProgressEvent): void;
+}
 export interface MCPIdentityOptions {
     name?: string;
     description?: string;
@@ -49,6 +58,10 @@ export interface MCPIdentityOptions {
     mode?: 'development' | 'production';
     logger?: Logger;
     logLevel?: 'debug' | 'info' | 'warn' | 'error' | 'silent';
+    onProgress?: MCPIdentityProgressCallback;
+    registrationPollInterval?: number;
+    registrationMaxPollingTime?: number;
+    registrationPollBackoff?: boolean;
 }
 export interface MCPServer {
     setRequestHandler(method: string, handler: Function): void;
@@ -91,6 +104,24 @@ export interface AutoRegisterResponse {
         privateKey?: string;
     };
 }
+export interface AsyncRegistrationResponse {
+    success: boolean;
+    jobId: string;
+    status: string;
+    message: string;
+    estimatedTime: string;
+}
+export interface RegistrationStatusResponse {
+    jobId: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    result?: AutoRegisterResponse;
+    error?: {
+        message: string;
+        code?: string;
+    };
+    progress?: number;
+    estimatedTimeRemaining?: number;
+}
 export interface PersistedIdentity {
     did: string;
     publicKey: string;

package/dist/esm/cli-mode.d.ts

@@ -0,0 +1,52 @@
+/**
+ * CLI Mode for MCP-I Package
+ * @internal - For use by @kya-os/cli package only
+ * @private
+ *
+ * This module provides a specialized interface for the KYA-OS CLI
+ * with enhanced progress reporting and silent logging by default.
+ */
+import { MCPIdentityOptions, MCPIdentityProgressCallback } from './types.js';
+import { MCPIdentity } from './index.js';
+/**
+ * CLI-specific options that extend the base options
+ * @internal
+ */
+interface MCPIdentityCLIOptions extends Omit<MCPIdentityOptions, 'logLevel'> {
+    /**
+     * Log level - defaults to 'silent' for CLI usage
+     */
+    logLevel?: 'debug' | 'info' | 'warn' | 'error' | 'silent';
+    /**
+     * Progress callback is strongly recommended for CLI usage
+     */
+    onProgress?: MCPIdentityProgressCallback;
+}
+/**
+ * Enable MCP Identity with CLI-optimized defaults
+ * @internal - For use by @kya-os/cli package only
+ *
+ * This function:
+ * - Sets silent logging by default
+ * - Provides structured progress events
+ * - Returns additional metadata useful for CLI animations
+ * - Optimizes for the best CLI experience
+ *
+ * @param options Configuration options
+ * @returns MCPIdentity instance with additional CLI metadata
+ */
+export declare function enableMCPIdentityCLI(options?: MCPIdentityCLIOptions): Promise<{
+    identity: MCPIdentity;
+    metadata: {
+        isNewIdentity: boolean;
+        did: string;
+        claimUrl?: string;
+        registryUrl: string;
+    };
+}>;
+/**
+ * Re-export types that CLI might need
+ * @internal
+ */
+export type { MCPIdentityProgressEvent, MCPIdentityProgressCallback } from './types.js';
+//# sourceMappingURL=cli-mode.d.ts.map

package/dist/esm/cli-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-mode.d.ts","sourceRoot":"","sources":["../../src/cli-mode.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,kBAAkB,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAC7E,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC;;;GAGG;AACH,UAAU,qBAAsB,SAAQ,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC;IAC1E;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;IAE1D;;OAEG;IACH,UAAU,CAAC,EAAE,2BAA2B,CAAC;CAC1C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC;IACT,QAAQ,EAAE,WAAW,CAAC;IACtB,QAAQ,EAAE;QACR,aAAa,EAAE,OAAO,CAAC;QACvB,GAAG,EAAE,MAAM,CAAC;QACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;CACH,CAAC,CAyCD;AAED;;;GAGG;AACH,YAAY,EACV,wBAAwB,EACxB,2BAA2B,EAC5B,MAAM,YAAY,CAAC"}

package/dist/esm/cli-mode.js

@@ -0,0 +1,59 @@
+/**
+ * CLI Mode for MCP-I Package
+ * @internal - For use by @kya-os/cli package only
+ * @private
+ *
+ * This module provides a specialized interface for the KYA-OS CLI
+ * with enhanced progress reporting and silent logging by default.
+ */
+import { enableMCPIdentity } from './index.js';
+/**
+ * Enable MCP Identity with CLI-optimized defaults
+ * @internal - For use by @kya-os/cli package only
+ *
+ * This function:
+ * - Sets silent logging by default
+ * - Provides structured progress events
+ * - Returns additional metadata useful for CLI animations
+ * - Optimizes for the best CLI experience
+ *
+ * @param options Configuration options
+ * @returns MCPIdentity instance with additional CLI metadata
+ */
+export async function enableMCPIdentityCLI(options) {
+    // Track if this is a new identity
+    let isNewIdentity = false;
+    let capturedClaimUrl;
+    // Wrap the progress callback to capture metadata
+    const wrappedProgress = (event) => {
+        // Capture claim URL from complete event
+        if (event.stage === 'complete' && event.data?.claimUrl) {
+            capturedClaimUrl = event.data.claimUrl;
+        }
+        // Detect if this is a new identity
+        if (event.stage === 'generating_keys') {
+            isNewIdentity = true;
+        }
+        // Call the original callback if provided
+        options?.onProgress?.(event);
+    };
+    // Initialize with CLI-optimized defaults
+    const identity = await enableMCPIdentity({
+        ...options,
+        logLevel: options?.logLevel || 'silent', // Silent by default
+        onProgress: wrappedProgress
+    });
+    // Get DID for metadata
+    const did = identity.did;
+    // Return identity with additional CLI metadata
+    return {
+        identity,
+        metadata: {
+            isNewIdentity,
+            did,
+            claimUrl: capturedClaimUrl,
+            registryUrl: 'https://knowthat.ai/agents/' + did.split(':').pop()
+        }
+    };
+}
+//# sourceMappingURL=cli-mode.js.map

package/dist/esm/cli-mode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-mode.js","sourceRoot":"","sources":["../../src/cli-mode.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAoB/C;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,OAA+B;IAU/B,kCAAkC;IAClC,IAAI,aAAa,GAAG,KAAK,CAAC;IAC1B,IAAI,gBAAoC,CAAC;IAEzC,iDAAiD;IACjD,MAAM,eAAe,GAAgC,CAAC,KAAK,EAAE,EAAE;QAC7D,wCAAwC;QACxC,IAAI,KAAK,CAAC,KAAK,KAAK,UAAU,IAAI,KAAK,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC;YACvD,gBAAgB,GAAG,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC;QACzC,CAAC;QAED,mCAAmC;QACnC,IAAI,KAAK,CAAC,KAAK,KAAK,iBAAiB,EAAE,CAAC;YACtC,aAAa,GAAG,IAAI,CAAC;QACvB,CAAC;QAED,yCAAyC;QACzC,OAAO,EAAE,UAAU,EAAE,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC,CAAC;IAEF,yCAAyC;IACzC,MAAM,QAAQ,GAAG,MAAM,iBAAiB,CAAC;QACvC,GAAG,OAAO;QACV,QAAQ,EAAE,OAAO,EAAE,QAAQ,IAAI,QAAQ,EAAE,oBAAoB;QAC7D,UAAU,EAAE,eAAe;KAC5B,CAAC,CAAC;IAEH,uBAAuB;IACvB,MAAM,GAAG,GAAG,QAAQ,CAAC,GAAG,CAAC;IAEzB,+CAA+C;IAC/C,OAAO;QACL,QAAQ;QACR,QAAQ,EAAE;YACR,aAAa;YACb,GAAG;YACH,QAAQ,EAAE,gBAAgB;YAC1B,WAAW,EAAE,6BAA6B,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE;SAClE;KACF,CAAC;AACJ,CAAC"}