@kya-os/mcp-i 0.1.0-alpha.2.2 → 0.1.0-alpha.2.4

package/dist/index.js

@@ -1,19 +1,4 @@
 "use strict";
-/**
- * @kya-os/mcp-i - Ultra-light MCP Identity auto-registration
- *
- * Enable any MCP server to get a verifiable identity with just 2 lines of code:
- *
- * ```typescript
- * import "@kya-os/mcp-i/auto";  // That's it! Your server now has identity
- * ```
- *
- * Or with configuration:
- * ```typescript
- * import { enableMCPIdentity } from "@kya-os/mcp-i";
- * await enableMCPIdentity({ name: "My Amazing Agent" });
- * ```
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -50,94 +35,227 @@ var __importStar = (this && this.__importStar) || (function () {
 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);
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MCPIdentity = void 0;
+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.enableMCPIdentity = enableMCPIdentity;
-const axios_1 = __importDefault(require("axios"));
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
+exports.createMCPMiddleware = createMCPMiddleware;
 const crypto = __importStar(require("./crypto"));
-// Re-export types for convenience
+const storage_1 = require("./storage");
+const transport_1 = require("./transport");
+const logger_1 = require("./logger");
+const rotation_1 = require("./rotation");
 __exportStar(require("./types"), exports);
-// Global identity instance
+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; } });
+Object.defineProperty(exports, "resolveRegistries", { enumerable: true, get: function () { return registry_1.resolveRegistries; } });
+var logger_2 = require("./logger");
+Object.defineProperty(exports, "LoggerFactory", { enumerable: true, get: function () { return logger_2.LoggerFactory; } });
+Object.defineProperty(exports, "ConsoleLogger", { enumerable: true, get: function () { return logger_2.ConsoleLogger; } });
+Object.defineProperty(exports, "SilentLogger", { enumerable: true, get: function () { return logger_2.SilentLogger; } });
+var storage_2 = require("./storage");
+Object.defineProperty(exports, "StorageFactory", { enumerable: true, get: function () { return storage_2.StorageFactory; } });
+Object.defineProperty(exports, "MemoryStorage", { enumerable: true, get: function () { return storage_2.MemoryStorage; } });
+Object.defineProperty(exports, "FileStorage", { enumerable: true, get: function () { return storage_2.FileStorage; } });
+var transport_2 = require("./transport");
+Object.defineProperty(exports, "TransportFactory", { enumerable: true, get: function () { return transport_2.TransportFactory; } });
+Object.defineProperty(exports, "RuntimeDetector", { enumerable: true, get: function () { return transport_2.RuntimeDetector; } });
+var rotation_2 = require("./rotation");
+Object.defineProperty(exports, "KeyRotationManager", { enumerable: true, get: function () { return rotation_2.KeyRotationManager; } });
+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; } });
 let globalIdentity = null;
 class MCPIdentity {
     constructor(identity, options = {}) {
         this.usedNonces = new Set();
+        if (options.logger) {
+            logger_1.LoggerFactory.setLogger(options.logger);
+        }
+        else if (options.logLevel && options.logLevel !== 'silent') {
+            logger_1.LoggerFactory.setLogger(logger_1.LoggerFactory.createConsoleLogger(options.logLevel));
+        }
+        this.logger = (0, logger_1.getLogger)();
         this.did = identity.did;
         this.publicKey = identity.publicKey;
         this.privateKey = identity.privateKey;
-        this.timestampTolerance = options.timestampTolerance || 60000; // 60 seconds
+        this.encryptionPassword = options.encryptionPassword;
+        this.timestampTolerance = options.timestampTolerance || 60000;
         this.enableNonceTracking = options.enableNonceTracking !== false;
-        // Start nonce cleanup if tracking is enabled
+        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.precomputed = {
+            did: this.did,
+            publicKey: this.publicKey,
+            didBytes: new TextEncoder().encode(this.did),
+            signatureCache: new Map()
+        };
+        if (options.storage !== 'memory') {
+            this.rotationManager = new rotation_1.KeyRotationManager(identity, this.transport, {});
+        }
         if (this.enableNonceTracking) {
             this.startNonceCleanup();
         }
     }
-    /**
-     * Initialize MCP Identity - the main entry point
-     */
     static async init(options) {
-        // Return existing global identity if already initialized (unless forced)
-        if (globalIdentity && !options?.forceNew) {
+        const logger = options?.logger || (0, logger_1.getLogger)();
+        if (globalIdentity) {
             return globalIdentity;
         }
-        // Try to load existing identity
-        let identity = await loadIdentity(options?.persistencePath);
-        // Auto-register if needed
-        if (!identity) {
-            console.log('[MCP-I] No existing identity found, auto-registering...');
-            const response = await autoRegister({
-                name: options?.name || process.env.MCP_SERVER_NAME || 'Unnamed MCP Server',
-                description: options?.description,
-                repository: options?.repository,
-                apiEndpoint: options?.apiEndpoint || 'https://knowthat.ai'
-            });
-            // Create persisted identity
-            identity = {
-                did: response.did,
-                publicKey: response.keys.publicKey,
-                privateKey: response.keys.privateKey || '',
-                agentId: response.agent.id,
-                agentSlug: response.agent.slug,
-                registeredAt: new Date().toISOString(),
-            };
-            // If no private key was provided, generate one
-            if (!identity.privateKey) {
-                console.log('[MCP-I] Generating cryptographic keys...');
-                const keyPair = await crypto.generateKeyPair();
-                identity.publicKey = keyPair.publicKey;
-                identity.privateKey = keyPair.privateKey;
-            }
-            // Save for future use
-            await saveIdentity(identity, options?.persistencePath);
-            console.log('[MCP-I] ✅ Success! Your agent has been registered.');
-            console.log(`[MCP-I] DID: ${response.did}`);
-            console.log(`[MCP-I] Profile: ${response.agent.url}`);
+        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) {
+            logger.info('Loaded existing identity:', identity.did);
+            globalIdentity = new MCPIdentity(identity, options);
+            return globalIdentity;
+        }
+        logger.info('No existing identity found, creating new identity...');
+        const transport = transport_1.TransportFactory.create({
+            transport: options?.transport
+        });
+        const apiEndpoint = options?.apiEndpoint || 'https://knowthat.ai';
+        logger.info('Registering with knowthat.ai...');
+        const registrationData = {
+            name: options?.name || process.env.MCP_SERVER_NAME || 'Unnamed MCP Server',
+            description: options?.description,
+            repository: options?.repository,
+            directories: options?.directories,
+            isDraft: options?.mode === 'development'
+        };
+        logger.info('Generating cryptographic keys...');
+        const keyPair = await crypto.generateKeyPair();
+        const response = await autoRegister(transport, {
+            ...registrationData,
+            apiEndpoint,
+            directories: options?.directories
+        });
+        identity = {
+            did: response.did,
+            publicKey: keyPair.publicKey,
+            privateKey: keyPair.privateKey,
+            agentId: response.agent.id,
+            agentSlug: response.agent.slug,
+            registeredAt: new Date().toISOString(),
+            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);
         }
         globalIdentity = new MCPIdentity(identity, options);
         return globalIdentity;
     }
-    /**
-     * Sign a message with the agent's private key using Ed25519
-     */
+    async enableAutoRotation(policy) {
+        if (!this.rotationManager) {
+            throw new Error('Key rotation not available in memory storage mode');
+        }
+        this.rotationManager.setupAutoRotation((result) => {
+            if (result.success) {
+                this.logger.info('Keys rotated successfully');
+                this.persistIdentity();
+            }
+            else {
+                this.logger.error('Key rotation failed:', result.error);
+            }
+        });
+    }
+    async rotateKeys(reason) {
+        if (!this.rotationManager) {
+            throw new Error('Key rotation not available in memory storage mode');
+        }
+        const result = await this.rotationManager.rotateKeys(reason);
+        if (result.success) {
+            await this.persistIdentity();
+        }
+        return result;
+    }
+    checkKeyHealth() {
+        if (!this.rotationManager) {
+            return null;
+        }
+        return this.rotationManager.checkKeyHealth();
+    }
+    async getPrivateKey() {
+        if (this.decryptedPrivateKey) {
+            return this.decryptedPrivateKey;
+        }
+        if (this.encryptionPassword && this.privateKey.startsWith('enc:')) {
+            try {
+                this.decryptedPrivateKey = await crypto.decrypt(this.privateKey, this.encryptionPassword);
+                this.logger.debug('Private key decrypted successfully');
+                return this.decryptedPrivateKey;
+            }
+            catch (error) {
+                this.logger.error('Failed to decrypt private key:', error);
+                throw new Error('Invalid encryption password');
+            }
+        }
+        return this.privateKey;
+    }
     async sign(message) {
-        return crypto.sign(message, this.privateKey);
+        const messageStr = typeof message === 'string' ? message : message.toString('base64');
+        const cached = this.precomputed.signatureCache.get(messageStr);
+        if (cached) {
+            return cached;
+        }
+        const privateKey = await this.getPrivateKey();
+        const signature = await crypto.sign(message, privateKey);
+        if (this.precomputed.signatureCache.size > 100) {
+            const firstKey = this.precomputed.signatureCache.keys().next().value;
+            if (firstKey) {
+                this.precomputed.signatureCache.delete(firstKey);
+            }
+        }
+        this.precomputed.signatureCache.set(messageStr, signature);
+        if (this.rotationManager) {
+            this.rotationManager.incrementSignatureCount();
+        }
+        return signature;
+    }
+    async requestEditAccess() {
+        const timestamp = Date.now();
+        const message = `edit-request:${this.did}:knowthat.ai:${timestamp}`;
+        const signature = await this.sign(message);
+        const baseUrl = 'https://knowthat.ai';
+        const editUrl = new URL(`${baseUrl}/agents/edit`);
+        editUrl.searchParams.set('did', this.did);
+        editUrl.searchParams.set('timestamp', timestamp.toString());
+        editUrl.searchParams.set('signature', signature);
+        const claimUrl = new URL(`${baseUrl}/agents/claim`);
+        claimUrl.searchParams.set('did', this.did);
+        claimUrl.searchParams.set('timestamp', timestamp.toString());
+        claimUrl.searchParams.set('signature', signature);
+        return {
+            editUrl: editUrl.toString(),
+            claimUrl: claimUrl.toString()
+        };
     }
-    /**
-     * Verify a signature against a public key
-     */
     async verify(message, signature, publicKey) {
         return crypto.verify(message, signature, publicKey || this.publicKey);
     }
-    /**
-     * Respond to an MCP-I challenge
-     */
     async respondToChallenge(challenge) {
-        // Validate timestamp to prevent replay attacks
         const now = Date.now();
         const challengeAge = now - challenge.timestamp;
         if (challengeAge > this.timestampTolerance) {
@@ -146,14 +264,12 @@ class MCPIdentity {
         if (challengeAge < 0) {
             throw new Error('Challenge timestamp is in the future');
         }
-        // Check for nonce reuse if tracking is enabled
         if (this.enableNonceTracking) {
             if (this.usedNonces.has(challenge.nonce)) {
                 throw new Error('Nonce already used');
             }
             this.usedNonces.add(challenge.nonce);
         }
-        // Create the message to sign
         const messageComponents = [
             challenge.nonce,
             challenge.timestamp.toString(),
@@ -162,9 +278,7 @@ class MCPIdentity {
             (challenge.scope || []).join(',')
         ];
         const message = messageComponents.join(':');
-        // Sign the challenge
         const signature = await this.sign(message);
-        // Return the response
         return {
             did: this.did,
             signature,
@@ -173,35 +287,29 @@ class MCPIdentity {
             publicKey: this.publicKey
         };
     }
-    /**
-     * Get MCP-I capabilities for advertisement
-     */
     getCapabilities() {
         return {
             version: '1.0',
             did: this.did,
             publicKey: this.publicKey,
-            conformanceLevel: 2, // Level 2: Full crypto with challenge-response
+            conformanceLevel: 2,
             handshakeSupported: true,
             handshakeEndpoint: '/_mcp-i/handshake',
-            verificationEndpoint: `https://knowthat.ai/api/agents/${this.did}/verify`
+            verificationEndpoint: `https://knowthat.ai/api/agents/${this.did}/verify`,
+            registry: 'knowthat.ai'
         };
     }
-    /**
-     * Sign an MCP response with identity metadata
-     */
     async signResponse(response) {
         const timestamp = new Date().toISOString();
         const responseWithIdentity = {
             ...response,
             _mcp_identity: {
                 did: this.did,
-                signature: '', // Will be filled below
+                signature: '',
                 timestamp,
                 conformanceLevel: 2
             }
         };
-        // Sign the response content (excluding the signature field)
         const contentToSign = JSON.stringify({
             ...response,
             _mcp_identity: {
@@ -213,174 +321,142 @@ class MCPIdentity {
         responseWithIdentity._mcp_identity.signature = await this.sign(contentToSign);
         return responseWithIdentity;
     }
-    /**
-     * Generate a new nonce for challenges
-     */
     static generateNonce() {
-        return crypto.generateNonce();
+        return crypto.generateNonceSync();
+    }
+    getDirectories() {
+        return this.directories;
     }
-    /**
-     * Clean up old nonces periodically to prevent memory leaks
-     */
     startNonceCleanup() {
-        // Clean up nonces older than 2x the timestamp tolerance
         this.nonceCleanupInterval = setInterval(() => {
-            // In a production system, you'd track nonce timestamps
-            // For now, we'll clear all nonces periodically
             if (this.usedNonces.size > 10000) {
                 this.usedNonces.clear();
             }
         }, this.timestampTolerance * 2);
     }
-    /**
-     * Clean up resources
-     */
     destroy() {
         if (this.nonceCleanupInterval) {
             clearInterval(this.nonceCleanupInterval);
         }
         this.usedNonces.clear();
+        this.precomputed.signatureCache.clear();
+    }
+    extractAgentName() {
+        return process.env.MCP_SERVER_NAME || 'Unknown Agent';
+    }
+    extractAgentId() {
+        return process.env.AGENT_ID || '';
+    }
+    extractAgentSlug() {
+        const parts = this.did.split(':');
+        return parts[parts.length - 1];
+    }
+    async persistIdentity() {
+        try {
+            const identity = {
+                did: this.did,
+                publicKey: this.publicKey,
+                privateKey: this.privateKey,
+                agentId: this.extractAgentId(),
+                agentSlug: this.extractAgentSlug(),
+                registeredAt: new Date().toISOString(),
+                directories: this.directories
+            };
+            await this.storage.save(identity);
+        }
+        catch (error) {
+            this.logger.error('Failed to persist identity:', error);
+        }
     }
 }
 exports.MCPIdentity = MCPIdentity;
-/**
- * Enable MCP Identity for any MCP server
- * This is the main integration point that patches the MCP Server
- */
 async function enableMCPIdentity(options) {
     const identity = await MCPIdentity.init(options);
-    // Try to patch MCP Server if available
     try {
         patchMCPServer(identity);
     }
     catch (error) {
-        console.log('[MCP-I] MCP Server not found, identity initialized for manual use');
+        const logger = (0, logger_1.getLogger)();
+        logger.debug('MCP Server not found, identity initialized for manual use');
     }
     return identity;
 }
-/**
- * Patch the MCP Server to automatically add identity
- */
-function patchMCPServer(identity) {
-    try {
-        // Try to import the MCP SDK
-        const MCPModule = require('@modelcontextprotocol/sdk/server/index.js');
-        const OriginalServer = MCPModule.Server;
-        if (!OriginalServer) {
-            return;
-        }
-        // Store original methods
-        const originalSetRequestHandler = OriginalServer.prototype.setRequestHandler;
-        const originalConnect = OriginalServer.prototype.connect;
-        // Patch setRequestHandler to wrap all responses
-        OriginalServer.prototype.setRequestHandler = function (method, handler) {
+function createMCPMiddleware(identity) {
+    return (server) => {
+        const originalSetRequestHandler = server.setRequestHandler.bind(server);
+        const originalConnect = server.connect.bind(server);
+        server.setRequestHandler = function (method, handler) {
             const wrappedHandler = async (...args) => {
                 const result = await handler(...args);
-                // If result has content, sign it
                 if (result && typeof result === 'object' && 'content' in result) {
-                    const signed = await identity.signResponse(result);
-                    return signed;
+                    return await identity.signResponse(result);
                 }
                 return result;
             };
-            return originalSetRequestHandler.call(this, method, wrappedHandler);
+            return originalSetRequestHandler(method, wrappedHandler);
         };
-        // Patch connect to advertise MCP-I capabilities
-        OriginalServer.prototype.connect = async function (transport) {
-            // Add MCP-I capabilities to server info
+        server.connect = async function (transport) {
             if (this.serverInfo && this.serverInfo.capabilities) {
                 this.serverInfo.capabilities['mcp-i'] = identity.getCapabilities();
             }
-            // Set up MCP-I handshake handler
             this.setRequestHandler('mcp-i/challenge', async (request) => {
                 return identity.respondToChallenge(request.params);
             });
-            // Call original connect
-            return originalConnect.call(this, transport);
+            return originalConnect(transport);
         };
-        console.log('[MCP-I] ✨ MCP Server patched - all responses will be automatically signed');
-    }
-    catch (error) {
-        // MCP SDK not available, that's okay
-    }
+    };
 }
-// Helper functions (inline to keep package standalone)
-async function loadIdentity(customPath) {
-    // Check environment variables first (already loaded by process)
-    if (process.env.AGENT_DID && process.env.AGENT_PUBLIC_KEY && process.env.AGENT_PRIVATE_KEY) {
-        return {
-            did: process.env.AGENT_DID,
-            publicKey: process.env.AGENT_PUBLIC_KEY,
-            privateKey: process.env.AGENT_PRIVATE_KEY,
-            agentId: process.env.AGENT_ID || '',
-            agentSlug: process.env.AGENT_SLUG || '',
-            registeredAt: new Date().toISOString()
-        };
-    }
-    // Check JSON file (most reliable for programmatic access)
-    const filePath = customPath || path.join(process.cwd(), '.mcp-identity.json');
+function patchMCPServer(identity) {
     try {
-        if (fs.existsSync(filePath)) {
-            const content = fs.readFileSync(filePath, 'utf-8');
-            return JSON.parse(content);
+        const MCPModule = require('@modelcontextprotocol/sdk/server/index.js');
+        const OriginalServer = MCPModule.Server;
+        if (!OriginalServer) {
+            return;
         }
+        const middleware = createMCPMiddleware(identity);
+        const OriginalConstructor = OriginalServer;
+        MCPModule.Server = function (...args) {
+            const instance = new OriginalConstructor(...args);
+            middleware(instance, identity);
+            return instance;
+        };
+        Object.setPrototypeOf(MCPModule.Server, OriginalConstructor);
+        Object.setPrototypeOf(MCPModule.Server.prototype, OriginalConstructor.prototype);
+        const logger = (0, logger_1.getLogger)();
+        logger.info('✨ MCP Server patched - all responses will be automatically signed');
     }
-    catch {
-        // Ignore errors
+    catch (error) {
     }
-    return null;
-}
-async function saveIdentity(identity, customPath) {
-    // Save to .env (standard) and .env.local (for frameworks)
-    const envContent = `
-# MCP-I Identity (auto-generated)
-AGENT_DID="${identity.did}"
-AGENT_PUBLIC_KEY="${identity.publicKey}"
-AGENT_PRIVATE_KEY="${identity.privateKey}"
-AGENT_ID="${identity.agentId}"
-AGENT_SLUG="${identity.agentSlug}"
-`;
-    // Save to .env for standard Node.js compatibility
-    const envPath = path.join(process.cwd(), '.env');
-    fs.writeFileSync(envPath, envContent.trim());
-    // Also save to .env.local for framework compatibility (Next.js, Vite, etc.)
-    const envLocalPath = path.join(process.cwd(), '.env.local');
-    fs.writeFileSync(envLocalPath, envContent.trim());
-    // Also save as JSON for programmatic access
-    const filePath = customPath || path.join(process.cwd(), '.mcp-identity.json');
-    fs.writeFileSync(filePath, JSON.stringify(identity, null, 2));
-    console.log('[MCP-I] Identity saved to .env, .env.local, and .mcp-identity.json');
 }
-async function autoRegister(options) {
+async function autoRegister(transport, options) {
     try {
-        const response = await axios_1.default.post(`${options.apiEndpoint}/api/agents/auto-register`, {
+        const response = await transport.post(`${options.apiEndpoint}/api/agents/auto-register`, {
             metadata: {
                 name: options.name,
                 description: options.description,
                 repository: options.repository,
-                version: '1.0.0'
+                version: '1.0.0',
+                isDraft: options.isDraft,
+                directories: options.directories || 'verified'
             },
             clientInfo: {
-                sdkVersion: '0.1.0-alpha.2.0',
+                sdkVersion: '0.3.0',
                 language: 'typescript',
-                platform: 'node' // Always node for MCP servers
+                platform: 'node'
             }
         }, {
             timeout: 30000,
             headers: {
                 'Content-Type': 'application/json',
-                'User-Agent': '@kya-os/mcp-i/0.1.0-alpha.2.0'
+                'User-Agent': '@kya-os/mcp-i/0.3.0'
             }
         });
         return response.data;
     }
     catch (error) {
-        if (error.response?.status === 429) {
+        if (error.message?.includes('429')) {
             throw new Error('Rate limit exceeded. Please try again later.');
         }
-        throw new Error(error.response?.data?.message ||
-            error.message ||
-            'Failed to auto-register agent');
+        throw new Error(error.message || 'Failed to auto-register agent');
     }
 }
-//# sourceMappingURL=index.js.map

package/dist/logger.d.ts

@@ -0,0 +1,32 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+export interface Logger {
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+}
+export declare class SilentLogger implements Logger {
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+}
+export declare class ConsoleLogger implements Logger {
+    private prefix;
+    private level;
+    constructor(prefix?: string, level?: LogLevel);
+    private shouldLog;
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+}
+export declare class LoggerFactory {
+    private static instance;
+    static setLogger(logger: Logger): void;
+    static getLogger(): Logger;
+    static createConsoleLogger(level?: LogLevel): Logger;
+    static createSilentLogger(): Logger;
+    static reset(): void;
+}
+export declare function getLogger(): Logger;