@kya-os/mcp-i 0.1.0-alpha.3.9 → 1.2.0

package/dist/cjs/registry/knowthat.js

@@ -1,173 +0,0 @@
-"use strict";
-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");
-const platform_info_1 = require("../platform-info");
-class KnowThatRegistry {
-    constructor(endpoint = 'https://knowthat.ai', transport, options) {
-        this.name = 'knowthat';
-        this.type = 'primary';
-        this.endpoint = endpoint;
-        this.transport = transport || transport_1.TransportFactory.create();
-        this.options = options;
-    }
-    async publishViaCLI(data) {
-        const logger = (0, logger_1.getLogger)();
-        try {
-            logger.debug('Using fast CLI registration endpoint');
-            const response = await this.transport.post(`${this.endpoint}/api/agents/cli-register`, {
-                name: data.name,
-                description: data.description,
-                repository: data.repository,
-                publicKey: data.publicKey
-            }, {
-                timeout: 5000,
-                headers: {
-                    'Content-Type': 'application/json',
-                    'User-Agent': `@kya-os/mcp-i/${(0, platform_info_1.generateClientInfo)().sdkVersion}`
-                }
-            });
-            logger.debug(`CLI registration completed in ${response.data.responseTime}ms`);
-            if (response.data.keys && !data.publicKey) {
-                logger.warn(response.data.keys.warning || 'Server generated keys - store them securely!');
-            }
-            return {
-                success: true,
-                registryAgentId: response.data.agent.id,
-                profileUrl: response.data.agent.url,
-                claimUrl: response.data.claimUrl,
-                claimToken: response.data.claimToken,
-                generatedKeys: response.data.keys
-            };
-        }
-        catch (error) {
-            logger.debug(`CLI registration failed: ${error.message}`);
-            throw error;
-        }
-    }
-    shouldUseCLIEndpoint() {
-        if (this.options?.registryEndpoint === 'cli')
-            return true;
-        if (this.options?.registryEndpoint === 'auto-register')
-            return false;
-        if (this.options?.registryEndpoint === 'auto' || !this.options?.registryEndpoint) {
-            if (this.options?.onProgress)
-                return true;
-            if (this.options?.processingMode === 'sync')
-                return true;
-            if (process.stdout?.isTTY)
-                return true;
-        }
-        return false;
-    }
-    async publish(data) {
-        const logger = (0, logger_1.getLogger)();
-        const useCLI = this.shouldUseCLIEndpoint();
-        if (useCLI) {
-            try {
-                return await this.publishViaCLI(data);
-            }
-            catch (error) {
-                logger.debug('CLI endpoint failed, falling back to auto-register');
-            }
-        }
-        return await this.publishViaAutoRegister(data);
-    }
-    async publishViaAutoRegister(data) {
-        const logger = (0, logger_1.getLogger)();
-        try {
-            const clientInfo = (0, platform_info_1.generateClientInfo)({
-                processingMode: this.options?.processingMode === 'auto'
-                    ? undefined
-                    : this.options?.processingMode || 'sync',
-                customMetadata: {
-                    source: 'mcp-i-sdk'
-                }
-            });
-            logger.debug(`Generated client info: ${JSON.stringify(clientInfo)}`);
-            const response = await this.transport.post(`${this.endpoint}/api/agents/auto-register`, {
-                metadata: {
-                    name: data.name,
-                    description: data.description,
-                    repository: data.repository,
-                    version: '1.0.0'
-                },
-                clientInfo,
-                publicKey: data.publicKey || undefined
-            }, {
-                timeout: 30000,
-                headers: {
-                    'Content-Type': 'application/json',
-                    'User-Agent': `@kya-os/mcp-i/${clientInfo.sdkVersion}`
-                }
-            });
-            logger.debug(`Registration response status: ${response.status}`);
-            logger.debug(`Registration response data: ${JSON.stringify(response.data, null, 2)}`);
-            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: syncResponse.agent.id,
-                profileUrl: syncResponse.agent.url
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error.message || 'Failed to register with KnowThat.ai'
-            };
-        }
-    }
-    async verify(did) {
-        try {
-            const agentSlug = this.extractAgentSlug(did);
-            const response = await this.transport.get(`${this.endpoint}/api/agents/${agentSlug}/verify`, { timeout: 5000 });
-            return response.data.valid === true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async getStatus(did) {
-        try {
-            const agentSlug = this.extractAgentSlug(did);
-            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,
-                type: 'primary'
-            };
-        }
-        catch (error) {
-            return {
-                name: this.name,
-                status: 'failed',
-                type: 'primary',
-                error: 'Failed to get status'
-            };
-        }
-    }
-    extractAgentSlug(did) {
-        const parts = did.split(':');
-        return parts[parts.length - 1];
-    }
-}
-exports.KnowThatRegistry = KnowThatRegistry;

package/dist/cjs/rotation.d.ts

@@ -1,35 +0,0 @@
-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/cjs/rotation.js

@@ -1,102 +0,0 @@
-"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/cjs/storage.d.ts

@@ -1,41 +0,0 @@
-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;
-}

package/dist/cjs/storage.js

@@ -1,163 +0,0 @@
-"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/cjs/transport.d.ts

@@ -1,35 +0,0 @@
-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 isNextJs(): boolean;
-    static hasFetch(): boolean;
-    static isLambda(): boolean;
-}
-export declare class TransportFactory {
-    static create(options?: {
-        transport?: 'axios' | 'fetch' | 'auto';
-    }): Transport;
-}