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

package/dist/dev-helper.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initWithDevExperience = initWithDevExperience;
+exports.showAgentStatus = showAgentStatus;
+const index_1 = require("./index");
+const logger_1 = require("./logger");
+async function initWithDevExperience(options = {}) {
+    const logger = (0, logger_1.getLogger)();
+    if (process.env.NODE_ENV === 'development' && !options.mode) {
+        options.mode = 'development';
+        logger.info('🔧 Development mode detected - agents will be created as drafts');
+    }
+    if (!options.name && !process.env.MCP_SERVER_NAME) {
+        try {
+            const pkg = require(process.cwd() + '/package.json');
+            options.name = pkg.name || 'Unnamed MCP Server';
+            options.description = pkg.description;
+            options.repository = pkg.repository?.url || pkg.repository;
+            logger.info(`📦 Auto-detected agent name: ${options.name}`);
+        }
+        catch {
+            options.name = 'Development MCP Server';
+        }
+    }
+    if (!options.storage) {
+        logger.info('💡 Tip: Use storage: "file" for persistent identity across restarts');
+    }
+    const identity = await index_1.MCPIdentity.init(options);
+    logger.info('✨ MCP Identity initialized successfully!');
+    logger.info(`🆔 DID: ${identity.did}`);
+    const { claimUrl } = await identity.requestEditAccess();
+    logger.info(`🔗 Claim your agent: ${claimUrl}`);
+    logger.info('💡 Your MCP server responses are now automatically signed with your agent identity');
+    return identity;
+}
+function showAgentStatus(identity) {
+    const logger = (0, logger_1.getLogger)();
+    const capabilities = identity.getCapabilities();
+    logger.info('📊 Agent Status:');
+    logger.info(`   DID: ${identity.did}`);
+    logger.info(`   Conformance Level: ${capabilities.conformanceLevel}`);
+    logger.info(`   Registry: ${capabilities.registry || 'knowthat.ai'}`);
+    logger.info(`   Handshake Supported: ${capabilities.handshakeSupported}`);
+    const directories = identity.getDirectories();
+    if (directories === 'none') {
+        logger.info('📋 Directories: Not listing on any directories');
+    }
+    else if (directories === 'verified') {
+        logger.info('📋 Directories: Listing on all verified directories');
+    }
+    else if (Array.isArray(directories)) {
+        logger.info(`📋 Directories: ${directories.join(', ')}`);
+    }
+}

package/dist/encrypted-storage.d.ts

@@ -0,0 +1,11 @@
+import { StorageProvider } from './storage';
+import { PersistedIdentity } from './types';
+export declare class EncryptedStorage implements StorageProvider {
+    private baseStorage;
+    private password;
+    constructor(baseStorage: StorageProvider, password: string);
+    load(): Promise<PersistedIdentity | null>;
+    save(identity: PersistedIdentity): Promise<void>;
+    exists(): Promise<boolean>;
+}
+export declare function createEncryptedStorage(baseStorage: StorageProvider, password: string): StorageProvider;

package/dist/encrypted-storage.js

@@ -0,0 +1,73 @@
+"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.EncryptedStorage = void 0;
+exports.createEncryptedStorage = createEncryptedStorage;
+const crypto = __importStar(require("./crypto"));
+class EncryptedStorage {
+    constructor(baseStorage, password) {
+        this.baseStorage = baseStorage;
+        this.password = password;
+    }
+    async load() {
+        const identity = await this.baseStorage.load();
+        if (!identity) {
+            return null;
+        }
+        if (identity.privateKey.startsWith('enc:')) {
+            try {
+                identity.privateKey = await crypto.decrypt(identity.privateKey, this.password);
+            }
+            catch (error) {
+                throw new Error('Failed to decrypt stored identity - invalid password');
+            }
+        }
+        return identity;
+    }
+    async save(identity) {
+        const encryptedIdentity = { ...identity };
+        if (!encryptedIdentity.privateKey.startsWith('enc:')) {
+            encryptedIdentity.privateKey = await crypto.encrypt(encryptedIdentity.privateKey, this.password);
+        }
+        await this.baseStorage.save(encryptedIdentity);
+    }
+    async exists() {
+        return this.baseStorage.exists();
+    }
+}
+exports.EncryptedStorage = EncryptedStorage;
+function createEncryptedStorage(baseStorage, password) {
+    return new EncryptedStorage(baseStorage, password);
+}

package/dist/index.d.ts

@@ -1,20 +1,12 @@
-/**
- * @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" });
- * ```
- */
-import { MCPIdentityOptions, Challenge, ChallengeResponse, MCPICapabilities, SignedResponse } from './types';
+import { MCPIdentityOptions, Challenge, ChallengeResponse, MCPICapabilities, SignedResponse, MCPMiddleware, DirectoryPreference } from './types';
+import { KeyRotationResult, KeyHealth } from './rotation';
 export * from './types';
+export { RegistryFactory, REGISTRY_TIERS, resolveRegistries } from './registry';
+export { LoggerFactory, ConsoleLogger, SilentLogger } from './logger';
+export { StorageFactory, MemoryStorage, FileStorage } from './storage';
+export { TransportFactory, RuntimeDetector } from './transport';
+export { KeyRotationManager } from './rotation';
+export { initWithDevExperience, showAgentStatus } from './dev-helper';
 export declare class MCPIdentity {
     readonly did: string;
     readonly publicKey: string;
@@ -23,47 +15,40 @@ export declare class MCPIdentity {
     private enableNonceTracking;
     private usedNonces;
     private nonceCleanupInterval?;
+    private encryptionPassword?;
+    private decryptedPrivateKey?;
+    private directories;
+    private storage;
+    private transport;
+    private logger;
+    private rotationManager?;
+    private precomputed;
     private constructor();
-    /**
-     * Initialize MCP Identity - the main entry point
-     */
     static init(options?: MCPIdentityOptions): Promise<MCPIdentity>;
-    /**
-     * Sign a message with the agent's private key using Ed25519
-     */
+    enableAutoRotation(policy?: {
+        maxAge?: number;
+        maxSignatures?: number;
+    }): Promise<void>;
+    rotateKeys(reason?: string): Promise<KeyRotationResult>;
+    checkKeyHealth(): KeyHealth | null;
+    private getPrivateKey;
     sign(message: string | Buffer): Promise<string>;
-    /**
-     * Verify a signature against a public key
-     */
+    requestEditAccess(): Promise<{
+        editUrl: string;
+        claimUrl?: string;
+    }>;
     verify(message: string | Buffer, signature: string, publicKey?: string): Promise<boolean>;
-    /**
-     * Respond to an MCP-I challenge
-     */
     respondToChallenge(challenge: Challenge): Promise<ChallengeResponse>;
-    /**
-     * Get MCP-I capabilities for advertisement
-     */
     getCapabilities(): MCPICapabilities;
-    /**
-     * Sign an MCP response with identity metadata
-     */
     signResponse<T = any>(response: T): Promise<SignedResponse<T>>;
-    /**
-     * Generate a new nonce for challenges
-     */
     static generateNonce(): string;
-    /**
-     * Clean up old nonces periodically to prevent memory leaks
-     */
+    getDirectories(): DirectoryPreference;
     private startNonceCleanup;
-    /**
-     * Clean up resources
-     */
     destroy(): void;
+    private extractAgentName;
+    private extractAgentId;
+    private extractAgentSlug;
+    private persistIdentity;
 }
-/**
- * Enable MCP Identity for any MCP server
- * This is the main integration point that patches the MCP Server
- */
 export declare function enableMCPIdentity(options?: MCPIdentityOptions): Promise<MCPIdentity>;
-//# sourceMappingURL=index.d.ts.map
+export declare function createMCPMiddleware(identity: MCPIdentity): MCPMiddleware;