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

package/dist/storage.js

@@ -0,0 +1,163 @@
+"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.StorageFactory = exports.CombinedStorage = exports.EnvironmentStorage = exports.MemoryStorage = exports.FileStorage = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class FileStorage {
+    constructor(customPath) {
+        this.filePath = customPath || path.join(process.cwd(), '.mcp-identity.json');
+    }
+    async load() {
+        try {
+            if (fs.existsSync(this.filePath)) {
+                const content = fs.readFileSync(this.filePath, 'utf-8');
+                return JSON.parse(content);
+            }
+        }
+        catch {
+        }
+        return null;
+    }
+    async save(identity) {
+        fs.writeFileSync(this.filePath, JSON.stringify(identity, null, 2));
+    }
+    async exists() {
+        return fs.existsSync(this.filePath);
+    }
+}
+exports.FileStorage = FileStorage;
+class MemoryStorage {
+    constructor(key) {
+        this.key = key || 'default';
+    }
+    async load() {
+        return MemoryStorage.instances.get(this.key) || null;
+    }
+    async save(identity) {
+        MemoryStorage.instances.set(this.key, identity);
+    }
+    async exists() {
+        return MemoryStorage.instances.has(this.key);
+    }
+    static clear() {
+        MemoryStorage.instances.clear();
+    }
+}
+exports.MemoryStorage = MemoryStorage;
+MemoryStorage.instances = new Map();
+class EnvironmentStorage {
+    static load() {
+        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: process.env.AGENT_REGISTERED_AT || new Date().toISOString()
+            };
+        }
+        return null;
+    }
+}
+exports.EnvironmentStorage = EnvironmentStorage;
+class CombinedStorage {
+    constructor(providers) {
+        if (providers.length === 0) {
+            throw new Error('At least one storage provider is required');
+        }
+        this.providers = providers;
+        this.primaryProvider = providers[0];
+    }
+    async load() {
+        const envIdentity = EnvironmentStorage.load();
+        if (envIdentity) {
+            return envIdentity;
+        }
+        for (const provider of this.providers) {
+            const identity = await provider.load();
+            if (identity) {
+                return identity;
+            }
+        }
+        return null;
+    }
+    async save(identity) {
+        await this.primaryProvider.save(identity);
+    }
+    async exists() {
+        for (const provider of this.providers) {
+            if (await provider.exists()) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+exports.CombinedStorage = CombinedStorage;
+class StorageFactory {
+    static create(options) {
+        const storageType = options?.storage || 'auto';
+        let baseStorage;
+        if (storageType === 'memory') {
+            baseStorage = new MemoryStorage(options?.memoryKey);
+        }
+        else if (storageType === 'file') {
+            baseStorage = new FileStorage(options?.customPath);
+        }
+        else if (storageType === 'auto') {
+            if (process.env.AWS_LAMBDA_FUNCTION_NAME ||
+                process.env.VERCEL ||
+                process.env.NETLIFY ||
+                !fs.existsSync ||
+                typeof fs.writeFileSync !== 'function') {
+                baseStorage = new MemoryStorage(options?.memoryKey);
+            }
+            else {
+                baseStorage = new FileStorage(options?.customPath);
+            }
+        }
+        else {
+            throw new Error(`Unknown storage type: ${storageType}`);
+        }
+        if (options?.encryptionPassword) {
+            const { createEncryptedStorage } = require('./encrypted-storage');
+            return createEncryptedStorage(baseStorage, options.encryptionPassword);
+        }
+        return baseStorage;
+    }
+}
+exports.StorageFactory = StorageFactory;

package/dist/transport.d.ts

@@ -0,0 +1,34 @@
+export interface TransportOptions {
+    timeout?: number;
+    headers?: Record<string, string>;
+}
+export interface TransportResponse<T = any> {
+    data: T;
+    status: number;
+    headers: Record<string, string>;
+}
+export interface Transport {
+    post<T = any>(url: string, data: any, options?: TransportOptions): Promise<TransportResponse<T>>;
+    get<T = any>(url: string, options?: TransportOptions): Promise<TransportResponse<T>>;
+}
+export declare class FetchTransport implements Transport {
+    post<T = any>(url: string, data: any, options?: TransportOptions): Promise<TransportResponse<T>>;
+    get<T = any>(url: string, options?: TransportOptions): Promise<TransportResponse<T>>;
+}
+export declare class AxiosTransport implements Transport {
+    private axiosInstance;
+    post<T = any>(url: string, data: any, options?: TransportOptions): Promise<TransportResponse<T>>;
+    get<T = any>(url: string, options?: TransportOptions): Promise<TransportResponse<T>>;
+    private getAxios;
+}
+export declare class RuntimeDetector {
+    static isEdgeRuntime(): boolean;
+    static isNodeRuntime(): boolean;
+    static hasFetch(): boolean;
+    static isLambda(): boolean;
+}
+export declare class TransportFactory {
+    static create(options?: {
+        transport?: 'axios' | 'fetch' | 'auto';
+    }): Transport;
+}

package/dist/transport.js

@@ -0,0 +1,207 @@
+"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.TransportFactory = exports.RuntimeDetector = exports.AxiosTransport = exports.FetchTransport = void 0;
+class FetchTransport {
+    async post(url, data, options) {
+        const controller = new AbortController();
+        const timeout = options?.timeout || 30000;
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...options?.headers
+                },
+                body: JSON.stringify(data),
+                signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const error = await response.text();
+                throw new Error(`HTTP ${response.status}: ${error}`);
+            }
+            const responseData = await response.json();
+            return {
+                data: responseData,
+                status: response.status,
+                headers: Object.fromEntries(response.headers.entries())
+            };
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error.name === 'AbortError') {
+                throw new Error('Request timeout');
+            }
+            throw error;
+        }
+    }
+    async get(url, options) {
+        const controller = new AbortController();
+        const timeout = options?.timeout || 30000;
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: options?.headers,
+                signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const error = await response.text();
+                throw new Error(`HTTP ${response.status}: ${error}`);
+            }
+            const responseData = await response.json();
+            return {
+                data: responseData,
+                status: response.status,
+                headers: Object.fromEntries(response.headers.entries())
+            };
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error.name === 'AbortError') {
+                throw new Error('Request timeout');
+            }
+            throw error;
+        }
+    }
+}
+exports.FetchTransport = FetchTransport;
+class AxiosTransport {
+    async post(url, data, options) {
+        const axios = await this.getAxios();
+        try {
+            const response = await axios.post(url, data, {
+                timeout: options?.timeout || 30000,
+                headers: options?.headers
+            });
+            return {
+                data: response.data,
+                status: response.status,
+                headers: response.headers
+            };
+        }
+        catch (error) {
+            if (error.response?.status === 429) {
+                throw new Error('Rate limit exceeded. Please try again later.');
+            }
+            throw new Error(error.response?.data?.message ||
+                error.message ||
+                'Request failed');
+        }
+    }
+    async get(url, options) {
+        const axios = await this.getAxios();
+        try {
+            const response = await axios.get(url, {
+                timeout: options?.timeout || 30000,
+                headers: options?.headers
+            });
+            return {
+                data: response.data,
+                status: response.status,
+                headers: response.headers
+            };
+        }
+        catch (error) {
+            throw new Error(error.response?.data?.message ||
+                error.message ||
+                'Request failed');
+        }
+    }
+    async getAxios() {
+        if (!this.axiosInstance) {
+            const axiosModule = await Promise.resolve().then(() => __importStar(require('axios')));
+            this.axiosInstance = axiosModule.default;
+        }
+        return this.axiosInstance;
+    }
+}
+exports.AxiosTransport = AxiosTransport;
+class RuntimeDetector {
+    static isEdgeRuntime() {
+        return !!(globalThis.EdgeRuntime ||
+            process.env.NEXT_RUNTIME === 'edge' ||
+            process.env.VERCEL_EDGE ||
+            globalThis.Deno ||
+            globalThis.Bun);
+    }
+    static isNodeRuntime() {
+        return !!(process.versions?.node &&
+            !this.isEdgeRuntime());
+    }
+    static hasFetch() {
+        return typeof globalThis.fetch === 'function';
+    }
+    static isLambda() {
+        return !!(process.env.AWS_LAMBDA_FUNCTION_NAME ||
+            process.env.LAMBDA_TASK_ROOT ||
+            process.env._HANDLER);
+    }
+}
+exports.RuntimeDetector = RuntimeDetector;
+class TransportFactory {
+    static create(options) {
+        const transportType = options?.transport || 'auto';
+        if (transportType === 'fetch') {
+            if (!RuntimeDetector.hasFetch()) {
+                throw new Error('Fetch is not available in this runtime');
+            }
+            return new FetchTransport();
+        }
+        if (transportType === 'axios') {
+            return new AxiosTransport();
+        }
+        if (transportType === 'auto') {
+            if (RuntimeDetector.isEdgeRuntime() && RuntimeDetector.hasFetch()) {
+                return new FetchTransport();
+            }
+            if (RuntimeDetector.isLambda() && RuntimeDetector.hasFetch()) {
+                return new FetchTransport();
+            }
+            if (RuntimeDetector.isNodeRuntime()) {
+                return new AxiosTransport();
+            }
+            if (RuntimeDetector.hasFetch()) {
+                return new FetchTransport();
+            }
+            return new AxiosTransport();
+        }
+        throw new Error(`Unknown transport type: ${transportType}`);
+    }
+}
+exports.TransportFactory = TransportFactory;

package/dist/types.d.ts

@@ -1,39 +1,81 @@
-/**
- * Type definitions for MCP-I challenge-response authentication
- */
-/**
- * Registry configuration and tier definitions
- */
-export type RegistryTier = 'verified' | 'experimental' | 'enterprise' | 'all';
-/**
- * Registry names - currently only 'knowthat' is supported.
- * Additional registries will be added as directories adopt MCP-I.
- */
-export type RegistryName = 'knowthat' | string;
+export type RegistryName = string;
+export type RegistryTier = 'verified';
 export interface RegistryConfig {
-    /** Include specific registries or a tier */
-    include?: RegistryName[] | RegistryTier;
-    /** Exclude specific registries */
-    exclude?: RegistryName[];
+    include?: string[] | 'verified';
+    exclude?: string[];
 }
+export interface RegistryStatus {
+    name: string;
+    status: 'active' | 'pending' | 'failed';
+    registeredAt?: string;
+    type?: 'primary' | 'secondary';
+    error?: string;
+}
+export interface RegistryAdapter {
+    name: string;
+    type: 'primary' | 'secondary';
+    publish(data: any): Promise<any>;
+    verify?(did: string): Promise<boolean>;
+}
+export interface RegistryPublishData {
+    did: string;
+    name: string;
+    description?: string;
+    repository?: string;
+    publicKey: string;
+    metadata?: Record<string, any>;
+}
+export interface RegistryPublishResult {
+    success: boolean;
+    registryAgentId?: string;
+    profileUrl?: string;
+    error?: string;
+}
+export type DirectoryPreference = string[] | 'verified' | 'none';
+export type DirectoryName = 'smithery' | 'glama' | string;
 export interface MCPIdentityOptions {
     name?: string;
     description?: string;
     repository?: string;
     apiEndpoint?: string;
     persistencePath?: string;
+    storage?: 'file' | 'memory' | 'auto';
+    memoryKey?: string;
+    transport?: 'axios' | 'fetch' | 'auto';
     timestampTolerance?: number;
     enableNonceTracking?: boolean;
-    registries?: RegistryName[] | RegistryTier | RegistryConfig;
-    /** Primary DID host (default: 'knowthat') */
-    didHost?: string;
-    /**
-     * Development vs Production mode
-     * - 'development': Creates draft DID that expires after 30 days
-     * - 'production': Creates permanent DID (requires proof of usage)
-     * @default 'production'
-     */
+    encryptionPassword?: string;
+    directories?: DirectoryPreference;
     mode?: 'development' | 'production';
+    logger?: Logger;
+    logLevel?: 'debug' | 'info' | 'warn' | 'error' | 'silent';
+}
+export interface MCPServer {
+    setRequestHandler(method: string, handler: Function): void;
+    connect(transport: any): Promise<void>;
+    serverInfo?: {
+        capabilities?: Record<string, any>;
+    };
+}
+export interface MCPMiddleware {
+    (server: MCPServer, identity: any): void;
+}
+export interface MCPRequest<T = any> {
+    method: string;
+    params?: T;
+}
+export interface MCPResponse<T = any> {
+    content?: T;
+    error?: {
+        code: number;
+        message: string;
+    };
+}
+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 interface AutoRegisterResponse {
     success: boolean;
@@ -56,81 +98,22 @@ export interface PersistedIdentity {
     agentId: string;
     agentSlug: string;
     registeredAt: string;
-    /** Primary DID host registry */
-    didHost?: string;
-    /** List of registries where this agent is published */
-    registries?: RegistryStatus[];
-}
-/**
- * Registry-specific status information
- */
-export interface RegistryStatus {
-    /** Registry name */
-    name: string;
-    /** Registration status */
-    status: 'active' | 'pending' | 'failed' | 'revoked';
-    /** When registered with this registry */
-    registeredAt?: string;
-    /** Last sync attempt */
-    lastSyncAt?: string;
-    /** Registry type */
-    type: 'primary' | 'secondary';
-    /** Error message if failed */
-    error?: string;
-    /** Registry-specific agent ID */
-    registryAgentId?: string;
+    directories?: DirectoryPreference;
 }
-/**
- * Registry adapter interface
- */
-export interface RegistryAdapter {
-    /** Registry name */
-    name: string;
-    /** Registry type - primary can host DIDs, secondary only references */
-    type: 'primary' | 'secondary';
-    /** Publish agent to this registry */
-    publish(data: RegistryPublishData): Promise<RegistryPublishResult>;
-    /** Verify agent exists in registry */
-    verify?(did: string): Promise<boolean>;
-    /** Remove agent from registry */
-    unpublish?(did: string): Promise<void>;
-    /** Get registry-specific status */
-    getStatus?(did: string): Promise<RegistryStatus>;
-}
-/**
- * Data needed to publish to a registry
- */
-export interface RegistryPublishData {
-    did: string;
+export interface RegistrationData {
     name: string;
     description?: string;
     repository?: string;
-    publicKey: string;
-    agentId?: string;
-    agentSlug?: string;
+    publicKey?: string;
+    directories?: DirectoryPreference;
     metadata?: Record<string, any>;
 }
-/**
- * Result from registry publication
- */
-export interface RegistryPublishResult {
-    success: boolean;
-    registryAgentId?: string;
-    profileUrl?: string;
-    error?: string;
-}
-/**
- * MCP-I Challenge structure
- */
 export interface Challenge {
     nonce: string;
     timestamp: number;
     verifier_did?: string;
     scope?: string[];
 }
-/**
- * MCP-I Challenge Response structure
- */
 export interface ChallengeResponse {
     did: string;
     signature: string;
@@ -138,9 +121,6 @@ export interface ChallengeResponse {
     nonce: string;
     publicKey?: string;
 }
-/**
- * MCP-I Capabilities advertisement
- */
 export interface MCPICapabilities {
     version: string;
     did: string;
@@ -149,14 +129,8 @@ export interface MCPICapabilities {
     handshakeSupported: boolean;
     handshakeEndpoint?: string;
     verificationEndpoint?: string;
-    registries?: {
-        primary: string;
-        secondary: string[];
-    };
+    registry?: string;
 }
-/**
- * Response with MCP-I identity attached
- */
 export interface SignedResponse<T = any> {
     [key: string]: any;
     _mcp_identity: {
@@ -166,4 +140,3 @@ export interface SignedResponse<T = any> {
         conformanceLevel?: number;
     };
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -1,6 +1,2 @@
 "use strict";
-/**
- * Type definitions for MCP-I challenge-response authentication
- */
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kya-os/mcp-i",
-  "version": "0.1.0-alpha.2.3",
-  "description": "Give your MCP server cryptographic identity in 2 lines of code",
+  "version": "0.1.0-alpha.2.4",
+  "description": "Production-ready MCP Identity with automatic registration, key rotation, and optimized performance",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -27,11 +27,14 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "tsc -p tsconfig.prod.json",
+    "build:dev": "tsc",
+    "clean": "rm -rf dist",
     "test": "vitest",
     "test:watch": "vitest watch",
     "test:coverage": "vitest run --coverage",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run clean && npm run build",
+    "size": "npm pack --dry-run && echo 'Bundled size:' && tar -tzf *.tgz | wc -c"
   },
   "keywords": [
     "mcp",
@@ -57,8 +60,15 @@
   "author": "Dylan Hobbs <dylan@vouched.id>",
   "license": "MIT",
   "dependencies": {
-    "@noble/ed25519": "^2.1.0",
-    "axios": "^1.6.7"
+    "@noble/ed25519": "^2.1.0"
+  },
+  "peerDependencies": {
+    "axios": "^1.6.0"
+  },
+  "peerDependenciesMeta": {
+    "axios": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/dist/__tests__/challenge-response.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Tests for challenge-response authentication
- */
-export {};
-//# sourceMappingURL=challenge-response.test.d.ts.map

package/dist/__tests__/challenge-response.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"challenge-response.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/challenge-response.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}