@kya-os/mcp-i 0.1.0-alpha.2.3 → 0.1.0-alpha.2.5

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;

package/dist/logger.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerFactory = exports.ConsoleLogger = exports.SilentLogger = void 0;
+exports.getLogger = getLogger;
+class SilentLogger {
+    debug() { }
+    info() { }
+    warn() { }
+    error() { }
+}
+exports.SilentLogger = SilentLogger;
+class ConsoleLogger {
+    constructor(prefix = '[MCP-I]', level = 'info') {
+        this.prefix = prefix;
+        this.level = level;
+    }
+    shouldLog(level) {
+        const levels = ['debug', 'info', 'warn', 'error', 'silent'];
+        const currentIndex = levels.indexOf(this.level);
+        const messageIndex = levels.indexOf(level);
+        return messageIndex >= currentIndex;
+    }
+    debug(message, ...args) {
+        if (this.shouldLog('debug')) {
+            console.log('[DEBUG]', message, ...args);
+        }
+    }
+    info(message, ...args) {
+        if (this.shouldLog('info')) {
+            console.log('[INFO]', message, ...args);
+        }
+    }
+    warn(message, ...args) {
+        if (this.shouldLog('warn')) {
+            console.warn('[WARN]', message, ...args);
+        }
+    }
+    error(message, ...args) {
+        if (this.shouldLog('error')) {
+            console.error('[ERROR]', message, ...args);
+        }
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;
+class LoggerFactory {
+    static setLogger(logger) {
+        LoggerFactory.instance = logger;
+    }
+    static getLogger() {
+        return LoggerFactory.instance;
+    }
+    static createConsoleLogger(level) {
+        return new ConsoleLogger('[MCP-I]', level);
+    }
+    static createSilentLogger() {
+        return new SilentLogger();
+    }
+    static reset() {
+        LoggerFactory.instance = new SilentLogger();
+    }
+}
+exports.LoggerFactory = LoggerFactory;
+LoggerFactory.instance = new SilentLogger();
+function getLogger() {
+    return LoggerFactory.getLogger();
+}

package/dist/registry/index.d.ts

@@ -1,43 +1,12 @@
-/**
- * Registry management for MCP-I identity
- *
- * Currently supports KnowThat.ai as the primary registry.
- * Additional registries will be added as directories adopt MCP-I.
- */
 import { RegistryAdapter, RegistryName, RegistryTier } from "../types";
-/**
- * Registry tier definitions
- *
- * As more directories adopt MCP-I, they will be added to appropriate tiers.
- * Directory maintainers can contact us to discuss integration.
- */
 export declare const REGISTRY_TIERS: Record<RegistryTier, RegistryName[]>;
-/**
- * Registry factory
- *
- * Manages registry adapters dynamically. New registries can be added
- * without modifying core code.
- */
 export declare class RegistryFactory {
     private static adapters;
-    /**
-     * Get a registry adapter by name
-     */
     static getAdapter(name: RegistryName): RegistryAdapter | null;
-    /**
-     * Get all adapters for a tier
-     */
     static getAdaptersByTier(tier: RegistryTier): RegistryAdapter[];
-    /**
-     * Register a custom adapter
-     */
     static registerAdapter(name: string, factory: () => RegistryAdapter): void;
 }
-/**
- * Resolve registries from options
- */
 export declare function resolveRegistries(registries?: RegistryName[] | RegistryTier | {
     include?: RegistryName[] | RegistryTier;
     exclude?: RegistryName[];
 }): RegistryName[];
-//# sourceMappingURL=index.d.ts.map

package/dist/registry/index.js

@@ -1,52 +1,22 @@
 "use strict";
-/**
- * Registry management for MCP-I identity
- *
- * Currently supports KnowThat.ai as the primary registry.
- * Additional registries will be added as directories adopt MCP-I.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegistryFactory = exports.REGISTRY_TIERS = void 0;
 exports.resolveRegistries = resolveRegistries;
 const knowthat_1 = require("./knowthat");
-/**
- * Registry tier definitions
- *
- * As more directories adopt MCP-I, they will be added to appropriate tiers.
- * Directory maintainers can contact us to discuss integration.
- */
 exports.REGISTRY_TIERS = {
-    verified: ["knowthat"], // Primary registry for MCP-I
-    experimental: [], // Future: Directories in beta/testing phase
-    enterprise: [], // Future: Enterprise-specific registries
-    all: ["knowthat"], // Currently same as verified
+    verified: ["knowthat"],
 };
-/**
- * Registry factory
- *
- * Manages registry adapters dynamically. New registries can be added
- * without modifying core code.
- */
 class RegistryFactory {
-    /**
-     * Get a registry adapter by name
-     */
     static getAdapter(name) {
         const factory = this.adapters.get(name);
         return factory ? factory() : null;
     }
-    /**
-     * Get all adapters for a tier
-     */
     static getAdaptersByTier(tier) {
         const registries = exports.REGISTRY_TIERS[tier] || [];
         return registries
             .map((name) => this.getAdapter(name))
             .filter((adapter) => adapter !== null);
     }
-    /**
-     * Register a custom adapter
-     */
     static registerAdapter(name, factory) {
         this.adapters.set(name, factory);
     }
@@ -54,25 +24,18 @@ class RegistryFactory {
 exports.RegistryFactory = RegistryFactory;
 RegistryFactory.adapters = new Map([
     ["knowthat", () => new knowthat_1.KnowThatRegistry()],
-    // Future registries will be added here as they adopt MCP-I
+    ["knowthat.ai", () => new knowthat_1.KnowThatRegistry()],
 ]);
-/**
- * Resolve registries from options
- */
 function resolveRegistries(registries) {
-    // Default to 'verified' tier
     if (!registries) {
         return exports.REGISTRY_TIERS.verified;
     }
-    // Array of specific registries
     if (Array.isArray(registries)) {
         return registries;
     }
-    // Tier name
     if (typeof registries === "string") {
         return exports.REGISTRY_TIERS[registries] || [];
     }
-    // Config object with include/exclude
     const config = registries;
     let included = [];
     if (config.include) {
@@ -84,13 +47,10 @@ function resolveRegistries(registries) {
         }
     }
     else {
-        // Default to 'verified' if no include specified
         included = exports.REGISTRY_TIERS.verified;
     }
-    // Apply exclusions
     if (config.exclude && config.exclude.length > 0) {
         return included.filter((name) => !config.exclude.includes(name));
     }
     return included;
 }
-//# sourceMappingURL=index.js.map

package/dist/registry/knowthat.d.ts

@@ -1,28 +1,13 @@
-/**
- * KnowThat.ai Registry Adapter
- * Primary registry that can host DIDs
- */
 import { RegistryAdapter, RegistryPublishData, RegistryPublishResult, RegistryStatus } from '../types';
+import { Transport } from '../transport';
 export declare class KnowThatRegistry implements RegistryAdapter {
     name: string;
     type: 'primary' | 'secondary';
     private endpoint;
-    constructor(endpoint?: string);
-    /**
-     * Primary registration - creates DID and hosts DID document
-     */
+    private transport;
+    constructor(endpoint?: string, transport?: Transport);
     publish(data: RegistryPublishData): Promise<RegistryPublishResult>;
-    /**
-     * Verify agent exists and is valid
-     */
     verify(did: string): Promise<boolean>;
-    /**
-     * Get agent status in KnowThat registry
-     */
     getStatus(did: string): Promise<RegistryStatus>;
-    /**
-     * Extract agent slug from DID
-     */
     private extractAgentSlug;
 }
-//# sourceMappingURL=knowthat.d.ts.map

package/dist/registry/knowthat.js

@@ -1,27 +1,17 @@
 "use strict";
-/**
- * KnowThat.ai Registry Adapter
- * Primary registry that can host DIDs
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KnowThatRegistry = void 0;
-const axios_1 = __importDefault(require("axios"));
+const transport_1 = require("../transport");
 class KnowThatRegistry {
-    constructor(endpoint = 'https://knowthat.ai') {
+    constructor(endpoint = 'https://knowthat.ai', transport) {
         this.name = 'knowthat';
         this.type = 'primary';
         this.endpoint = endpoint;
+        this.transport = transport || transport_1.TransportFactory.create();
     }
-    /**
-     * Primary registration - creates DID and hosts DID document
-     */
     async publish(data) {
         try {
-            // For KnowThat, we use the auto-register endpoint for primary registration
-            const response = await axios_1.default.post(`${this.endpoint}/api/agents/auto-register`, {
+            const response = await this.transport.post(`${this.endpoint}/api/agents/auto-register`, {
                 metadata: {
                     name: data.name,
                     description: data.description,
@@ -33,7 +23,6 @@ class KnowThatRegistry {
                     language: 'typescript',
                     platform: 'node'
                 },
-                // If we already have a public key, send it
                 publicKey: data.publicKey || undefined
             }, {
                 timeout: 30000,
@@ -49,7 +38,7 @@ class KnowThatRegistry {
             };
         }
         catch (error) {
-            if (error.response?.status === 429) {
+            if (error.message?.includes('Rate limit exceeded')) {
                 return {
                     success: false,
                     error: 'Rate limit exceeded. Please try again later.'
@@ -57,37 +46,29 @@ class KnowThatRegistry {
             }
             return {
                 success: false,
-                error: error.response?.data?.message || error.message || 'Failed to register with KnowThat.ai'
+                error: error.message || 'Failed to register with KnowThat.ai'
             };
         }
     }
-    /**
-     * Verify agent exists and is valid
-     */
     async verify(did) {
         try {
             const agentSlug = this.extractAgentSlug(did);
-            const response = await axios_1.default.get(`${this.endpoint}/api/agents/${agentSlug}/verify`, { timeout: 5000 });
+            const response = await this.transport.get(`${this.endpoint}/api/agents/${agentSlug}/verify`, { timeout: 5000 });
             return response.data.valid === true;
         }
         catch {
             return false;
         }
     }
-    /**
-     * Get agent status in KnowThat registry
-     */
     async getStatus(did) {
         try {
             const agentSlug = this.extractAgentSlug(did);
-            const response = await axios_1.default.get(`${this.endpoint}/api/agents/${agentSlug}/status`, { timeout: 5000 });
+            const response = await this.transport.get(`${this.endpoint}/api/agents/${agentSlug}/status`, { timeout: 5000 });
             return {
                 name: this.name,
                 status: response.data.verified ? 'active' : 'pending',
                 registeredAt: response.data.registeredAt,
-                lastSyncAt: new Date().toISOString(),
-                type: 'primary',
-                registryAgentId: response.data.agentId
+                type: 'primary'
             };
         }
         catch (error) {
@@ -95,19 +76,13 @@ class KnowThatRegistry {
                 name: this.name,
                 status: 'failed',
                 type: 'primary',
-                error: 'Failed to get status',
-                lastSyncAt: new Date().toISOString()
+                error: 'Failed to get status'
             };
         }
     }
-    /**
-     * Extract agent slug from DID
-     */
     extractAgentSlug(did) {
-        // did:web:knowthat.ai:agents:my-agent -> my-agent
         const parts = did.split(':');
         return parts[parts.length - 1];
     }
 }
 exports.KnowThatRegistry = KnowThatRegistry;
-//# sourceMappingURL=knowthat.js.map

package/dist/rotation.d.ts

@@ -0,0 +1,35 @@
+import { PersistedIdentity } from './types';
+import { Transport } from './transport';
+export interface KeyRotationPolicy {
+    maxAge?: number;
+    maxSignatures?: number;
+    algorithm?: string;
+}
+export interface KeyRotationResult {
+    success: boolean;
+    newKeyId?: string;
+    oldKeyId?: string;
+    gracePeriodEnd?: Date;
+    error?: string;
+}
+export interface KeyHealth {
+    age: number;
+    signatureCount: number;
+    shouldRotate: boolean;
+    lastRotated?: Date;
+}
+export declare class KeyRotationManager {
+    private identity;
+    private transport;
+    private policy;
+    private signatureCount;
+    private keyCreatedAt;
+    private lastRotatedAt?;
+    constructor(identity: PersistedIdentity, transport: Transport, policy?: KeyRotationPolicy);
+    checkKeyHealth(): KeyHealth;
+    incrementSignatureCount(): void;
+    rotateKeys(reason?: string): Promise<KeyRotationResult>;
+    setupAutoRotation(callback?: (result: KeyRotationResult) => void): NodeJS.Timer;
+    private getRegistryUrl;
+    private extractAgentId;
+}

package/dist/rotation.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyRotationManager = void 0;
+const crypto_1 = require("./crypto");
+class KeyRotationManager {
+    constructor(identity, transport, policy = {}) {
+        this.identity = identity;
+        this.transport = transport;
+        this.policy = policy;
+        this.signatureCount = 0;
+        this.keyCreatedAt = new Date(identity.registeredAt);
+    }
+    checkKeyHealth() {
+        const now = new Date();
+        const age = now.getTime() - this.keyCreatedAt.getTime();
+        const maxAge = this.policy.maxAge || 90 * 24 * 60 * 60 * 1000;
+        const maxSignatures = this.policy.maxSignatures || 1000000;
+        const shouldRotate = age > maxAge || this.signatureCount > maxSignatures;
+        return {
+            age,
+            signatureCount: this.signatureCount,
+            shouldRotate,
+            lastRotated: this.lastRotatedAt
+        };
+    }
+    incrementSignatureCount() {
+        this.signatureCount++;
+    }
+    async rotateKeys(reason = 'scheduled') {
+        try {
+            const newKeyPair = await (0, crypto_1.generateKeyPair)();
+            const timestamp = Date.now();
+            const message = `rotate-keys:${this.identity.did}:${timestamp}:${reason}`;
+            const signature = await (0, crypto_1.sign)(message, this.identity.privateKey);
+            const rotationRequest = {
+                newPublicKey: {
+                    type: 'Ed25519VerificationKey2020',
+                    publicKeyBase64: newKeyPair.publicKey
+                },
+                rotationReason: reason,
+                signedStatement: signature,
+                timestamp
+            };
+            const registryUrl = this.getRegistryUrl();
+            const agentId = this.extractAgentId();
+            const response = await this.transport.post(`${registryUrl}/api/agents/${agentId}/rotate-key`, rotationRequest, {
+                headers: {
+                    'Authorization': `DID-Auth ${signature}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            if (response.data.success) {
+                this.identity.publicKey = newKeyPair.publicKey;
+                this.identity.privateKey = newKeyPair.privateKey;
+                this.lastRotatedAt = new Date();
+                this.keyCreatedAt = new Date();
+                this.signatureCount = 0;
+                return {
+                    success: true,
+                    newKeyId: response.data.newKeyId,
+                    oldKeyId: response.data.oldKeyId,
+                    gracePeriodEnd: new Date(response.data.gracePeriodEnd)
+                };
+            }
+            else {
+                return {
+                    success: false,
+                    error: response.data.error || 'Key rotation failed'
+                };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Key rotation error'
+            };
+        }
+    }
+    setupAutoRotation(callback) {
+        const checkInterval = 24 * 60 * 60 * 1000;
+        return setInterval(async () => {
+            const health = this.checkKeyHealth();
+            if (health.shouldRotate) {
+                const result = await this.rotateKeys('auto-rotation');
+                if (callback) {
+                    callback(result);
+                }
+            }
+        }, checkInterval);
+    }
+    getRegistryUrl() {
+        return 'https://knowthat.ai';
+    }
+    extractAgentId() {
+        if (this.identity.agentId) {
+            return this.identity.agentId;
+        }
+        const parts = this.identity.did.split(':');
+        return parts[parts.length - 1];
+    }
+}
+exports.KeyRotationManager = KeyRotationManager;

package/dist/storage.d.ts

@@ -0,0 +1,41 @@
+import { PersistedIdentity } from './types';
+export interface StorageProvider {
+    load(): Promise<PersistedIdentity | null>;
+    save(identity: PersistedIdentity): Promise<void>;
+    exists(): Promise<boolean>;
+}
+export declare class FileStorage implements StorageProvider {
+    private filePath;
+    constructor(customPath?: string);
+    load(): Promise<PersistedIdentity | null>;
+    save(identity: PersistedIdentity): Promise<void>;
+    exists(): Promise<boolean>;
+}
+export declare class MemoryStorage implements StorageProvider {
+    private static instances;
+    private key;
+    constructor(key?: string);
+    load(): Promise<PersistedIdentity | null>;
+    save(identity: PersistedIdentity): Promise<void>;
+    exists(): Promise<boolean>;
+    static clear(): void;
+}
+export declare class EnvironmentStorage {
+    static load(): PersistedIdentity | null;
+}
+export declare class CombinedStorage implements StorageProvider {
+    private providers;
+    private primaryProvider;
+    constructor(providers: StorageProvider[]);
+    load(): Promise<PersistedIdentity | null>;
+    save(identity: PersistedIdentity): Promise<void>;
+    exists(): Promise<boolean>;
+}
+export declare class StorageFactory {
+    static create(options?: {
+        storage?: 'file' | 'memory' | 'auto';
+        customPath?: string;
+        memoryKey?: string;
+        encryptionPassword?: string;
+    }): StorageProvider;
+}