@monoes/monomindcli 1.15.5 → 1.15.7

package/dist/src/plugins/store/discovery.js

@@ -1,770 +0,0 @@
-/**
- * Plugin Discovery Service
- * Discovers plugin registries via IPNS and fetches from IPFS
- * Parallel implementation to pattern store for plugins
- */
-import * as crypto from 'crypto';
-import { resolveIPNS, fetchFromIPFS } from '../../transfer/ipfs/client.js';
-/** Maximum bytes accepted from npm API responses to prevent OOM. */
-const NPM_RESPONSE_MAX_BYTES = 256 * 1024; // 256 KB
-/**
- * Read a fetch Response body up to maxBytes.  AbortSignal.timeout() only
- * bounds wall-clock time, NOT response body size; a slow-drip or large
- * response would otherwise buffer unbounded memory here.
- */
-async function readBoundedJson(res, maxBytes) {
-    const lenHdr = res.headers.get('content-length');
-    if (lenHdr) {
-        const declared = parseInt(lenHdr, 10);
-        if (Number.isFinite(declared) && declared > maxBytes) {
-            throw new Error(`npm response too large: ${declared} bytes`);
-        }
-    }
-    if (!res.body)
-        return JSON.parse('');
-    const reader = res.body.getReader();
-    const chunks = [];
-    let total = 0;
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        if (value) {
-            total += value.byteLength;
-            if (total > maxBytes) {
-                await reader.cancel();
-                throw new Error(`npm response exceeded ${maxBytes} bytes`);
-            }
-            chunks.push(value);
-        }
-    }
-    const buf = new Uint8Array(total);
-    let off = 0;
-    for (const c of chunks) {
-        buf.set(c, off);
-        off += c.byteLength;
-    }
-    return JSON.parse(new TextDecoder('utf-8').decode(buf));
-}
-/**
- * Fetch real npm download stats for a package
- */
-async function fetchNpmStats(packageName) {
-    // Validate package name length to avoid constructing huge URLs
-    if (!packageName || packageName.length > 214)
-        return null;
-    try {
-        // Fetch last week downloads
-        const downloadsUrl = `https://api.npmjs.org/downloads/point/last-week/${encodeURIComponent(packageName)}`;
-        const downloadsRes = await fetch(downloadsUrl, { signal: AbortSignal.timeout(3000) });
-        if (!downloadsRes.ok)
-            return null;
-        const downloadsData = await readBoundedJson(downloadsRes, NPM_RESPONSE_MAX_BYTES);
-        // Fetch package info for version
-        const packageUrl = `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`;
-        const packageRes = await fetch(packageUrl, { signal: AbortSignal.timeout(3000) });
-        let version = 'unknown';
-        if (packageRes.ok) {
-            const packageData = await readBoundedJson(packageRes, NPM_RESPONSE_MAX_BYTES);
-            version = packageData.version || 'unknown';
-        }
-        return {
-            downloads: downloadsData.downloads || 0,
-            version,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Default plugin store configuration
- */
-/**
- * Live IPFS Registry CID - Updated 2026-01-24
- * This is the current pinned registry on Pinata
- */
-export const LIVE_REGISTRY_CID = 'QmXbfEAaR7D2Ujm4GAkbwcGZQMHqAMpwDoje4583uNP834';
-/**
- * Pre-trained Model Registry CID - Updated 2026-01-24
- * Contains 8 pre-trained learning pattern models with 40 patterns
- * Trained on 110,600+ examples with 90.5% average accuracy
- */
-export const MODEL_REGISTRY_CID = 'QmNr1yYMKi7YBaL8JSztQyuB5ZUaTdRMLxJC1pBpGbjsTc';
-export const DEFAULT_PLUGIN_STORE_CONFIG = {
-    registries: [
-        {
-            name: 'monomind-official',
-            description: 'Official Monomind plugin registry',
-            // Use direct CID for reliable resolution (IPNS can be slow)
-            ipnsName: LIVE_REGISTRY_CID,
-            gateway: 'https://gateway.pinata.cloud',
-            publicKey: 'ed25519:21490c8ef5e6d9fea573382e52fbad7d0fa40c3eb124e6746706da7a420ae2d2',
-            trusted: true,
-            official: true,
-        },
-        {
-            name: 'community-plugins',
-            description: 'Community-contributed plugins',
-            ipnsName: LIVE_REGISTRY_CID, // Same registry for now
-            gateway: 'https://ipfs.io',
-            publicKey: 'ed25519:21490c8ef5e6d9fea573382e52fbad7d0fa40c3eb124e6746706da7a420ae2d2',
-            trusted: true,
-            official: false,
-        },
-    ],
-    defaultRegistry: 'monomind-official',
-    gateway: 'https://gateway.pinata.cloud',
-    timeout: 30000,
-    cacheDir: '.monomind/plugins/cache',
-    cacheExpiry: 3600000, // 1 hour
-    requireVerification: true,
-    requireSecurityAudit: false,
-    minTrustLevel: 'community',
-    trustedAuthors: [],
-    blockedPlugins: [],
-    allowedPermissions: ['network', 'filesystem', 'memory', 'hooks'],
-    requirePermissionPrompt: true,
-};
-/**
- * Plugin Discovery Service
- */
-export class PluginDiscoveryService {
-    config;
-    cache = new Map();
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_PLUGIN_STORE_CONFIG, ...config };
-    }
-    /**
-     * Discover plugin registry via IPNS
-     */
-    async discoverRegistry(registryName) {
-        const targetRegistry = registryName || this.config.defaultRegistry;
-        const registry = this.config.registries.find(r => r.name === targetRegistry);
-        if (!registry) {
-            return {
-                success: false,
-                error: `Unknown registry: ${targetRegistry}`,
-            };
-        }
-        console.log(`[PluginDiscovery] Resolving ${registry.name} via IPNS...`);
-        // Check cache first — key by registry.name (not ipnsName which can be shared)
-        const cached = this.cache.get(registry.name);
-        if (cached && Date.now() - cached.timestamp < this.config.cacheExpiry) {
-            console.log(`[PluginDiscovery] Cache hit for ${registry.name}`);
-            return {
-                success: true,
-                registry: cached.registry,
-                fromCache: true,
-                source: registry.name,
-            };
-        }
-        try {
-            // Check if ipnsName is actually a direct CID (CIDv1 starts with 'baf', CIDv0 starts with 'Qm')
-            const isDirectCid = registry.ipnsName.startsWith('baf') || registry.ipnsName.startsWith('Qm');
-            let cid;
-            if (isDirectCid) {
-                // Use the CID directly - no IPNS resolution needed
-                cid = registry.ipnsName;
-                console.log(`[PluginDiscovery] Using direct CID: ${cid}`);
-            }
-            else {
-                // Resolve IPNS to get current CID
-                cid = await resolveIPNS(registry.ipnsName, registry.gateway);
-                if (!cid) {
-                    // Fallback to demo registry
-                    return this.createDemoRegistryAsync(registry);
-                }
-                console.log(`[PluginDiscovery] Resolved IPNS to CID: ${cid}`);
-            }
-            // Fetch registry from IPFS
-            const registryData = await fetchFromIPFS(cid, registry.gateway);
-            if (!registryData) {
-                return this.createDemoRegistryAsync(registry);
-            }
-            // Verify registry signature if required — treat failure as fatal to prevent
-            // a tampered registry from being served when requireVerification is enabled.
-            if (this.config.requireVerification && registryData.registrySignature) {
-                const verified = await this.verifyRegistrySignature(registryData, registry.publicKey);
-                if (!verified) {
-                    console.error(`[PluginDiscovery] Registry signature verification failed — falling back to demo registry`);
-                    return this.createDemoRegistryAsync(registry);
-                }
-            }
-            // Cache the result — key by registry.name so separate registries don't share a slot
-            this.cache.set(registry.name, {
-                registry: registryData,
-                timestamp: Date.now(),
-            });
-            return {
-                success: true,
-                registry: registryData,
-                cid,
-                source: registry.name,
-                fromCache: false,
-            };
-        }
-        catch (error) {
-            console.error(`[PluginDiscovery] Failed to discover registry:`, error);
-            // Return demo registry on error
-            return this.createDemoRegistryAsync(registry);
-        }
-    }
-    /**
-     * Create demo plugin registry with real npm stats
-     */
-    async createDemoRegistryAsync(registry) {
-        console.log(`[PluginDiscovery] Using demo registry for ${registry.name}`);
-        // Get plugins with real npm stats
-        const plugins = await this.getDemoPluginsWithStats();
-        const demoRegistry = {
-            version: '1.0.0',
-            type: 'plugins',
-            updatedAt: new Date().toISOString(),
-            ipnsName: registry.ipnsName,
-            plugins,
-            categories: [
-                { id: 'ai-ml', name: 'AI/ML', description: 'AI and machine learning plugins', pluginCount: 1 },
-                { id: 'security', name: 'Security', description: 'Security and compliance plugins', pluginCount: 1 },
-                { id: 'devops', name: 'DevOps', description: 'CI/CD and deployment plugins', pluginCount: 1 },
-                { id: 'integrations', name: 'Integrations', description: 'Third-party integrations', pluginCount: 2 },
-                { id: 'agents', name: 'Agents', description: 'Custom agent types', pluginCount: 1 },
-            ],
-            authors: [
-                {
-                    id: 'monomind-team',
-                    displayName: 'Monomind Team',
-                    verified: true,
-                    plugins: plugins.length,
-                    totalDownloads: plugins.reduce((sum, p) => sum + p.downloads, 0),
-                    reputation: 100,
-                },
-            ],
-            totalPlugins: plugins.length,
-            totalDownloads: plugins.reduce((sum, p) => sum + p.downloads, 0),
-            totalAuthors: 1,
-            featured: ['@monomind/plugin-agentic-qe', '@monomind/plugin-prime-radiant', '@monomind/security', '@monomind/claims', '@monomind/teammate-plugin'],
-            trending: ['@monomind/plugin-agentic-qe', '@monomind/plugin-prime-radiant'],
-            newest: ['@monomind/plugin-agentic-qe', '@monomind/plugin-prime-radiant'],
-            official: ['@monomind/plugin-agentic-qe', '@monomind/plugin-prime-radiant', '@monomind/security', '@monomind/claims'],
-            compatibilityMatrix: [
-                { pluginId: '@monomind/security', pluginVersion: '3.0.0', monomindVersions: ['3.x'], tested: true },
-            ],
-        };
-        // Cache the demo registry
-        this.cache.set(registry.name, {
-            registry: demoRegistry,
-            timestamp: Date.now(),
-        });
-        return {
-            success: true,
-            registry: demoRegistry,
-            cid: `bafybeiplugin${crypto.randomBytes(16).toString('hex')}`,
-            source: `${registry.name} (demo)`,
-            fromCache: false,
-        };
-    }
-    /**
-     * Get demo plugins
-     */
-    getDemoPlugins() {
-        const baseTime = new Date().toISOString();
-        const officialAuthor = {
-            id: 'monomind-team',
-            displayName: 'Monomind Team',
-            verified: true,
-            plugins: 5,
-            totalDownloads: 50000,
-            reputation: 100,
-        };
-        const communityAuthor = {
-            id: 'community-contributor',
-            displayName: 'Community Contributors',
-            verified: false,
-            plugins: 7,
-            totalDownloads: 15000,
-            reputation: 85,
-        };
-        return [
-            {
-                id: '@monomind/security',
-                name: '@monomind/security',
-                displayName: 'Security Scanner',
-                description: 'Security scanning, CVE detection, and compliance auditing with threat modeling',
-                version: '3.0.0',
-                cid: 'bafybeisecurityplugin',
-                size: 180000,
-                checksum: 'sha256:def456security',
-                author: officialAuthor,
-                license: 'MIT',
-                categories: ['security'],
-                tags: ['security', 'cve', 'audit', 'compliance', 'threats'],
-                keywords: ['security', 'scanner'],
-                downloads: 12000,
-                rating: 4.8,
-                ratingCount: 189,
-                lastUpdated: baseTime,
-                createdAt: '2024-01-15T00:00:00Z',
-                minMonomindVersion: '3.0.0',
-                dependencies: [{ name: '@monomind/core', version: '^3.0.0' }],
-                type: 'command',
-                hooks: ['security:scan', 'security:audit'],
-                commands: ['security scan', 'security audit', 'security cve', 'security threats'],
-                permissions: ['filesystem', 'network'],
-                exports: ['SecurityScanner', 'CVEDetector', 'ThreatModeler'],
-                verified: true,
-                trustLevel: 'official',
-                securityAudit: {
-                    auditor: 'monomind-security-team',
-                    auditDate: '2024-12-01T00:00:00Z',
-                    auditVersion: '3.0.0',
-                    passed: true,
-                    issues: [],
-                },
-            },
-            {
-                id: '@monomind/claims',
-                name: '@monomind/claims',
-                displayName: 'Claims Authorization',
-                description: 'Claims-based authorization system for fine-grained access control',
-                version: '3.0.0',
-                cid: 'bafybeiclaimsplugin',
-                size: 95000,
-                checksum: 'sha256:jkl012claims',
-                author: officialAuthor,
-                license: 'MIT',
-                categories: ['security'],
-                tags: ['claims', 'authorization', 'access-control', 'permissions'],
-                keywords: ['claims', 'auth'],
-                downloads: 6200,
-                rating: 4.6,
-                ratingCount: 98,
-                lastUpdated: baseTime,
-                createdAt: '2024-02-15T00:00:00Z',
-                minMonomindVersion: '3.0.0',
-                dependencies: [{ name: '@monomind/core', version: '^3.0.0' }],
-                type: 'core',
-                hooks: ['claims:check', 'claims:grant'],
-                commands: ['claims check', 'claims grant', 'claims revoke', 'claims list'],
-                permissions: ['config'],
-                exports: ['ClaimsManager', 'PermissionChecker'],
-                verified: true,
-                trustLevel: 'official',
-            },
-            {
-                id: 'community-analytics',
-                name: 'community-analytics',
-                displayName: 'Analytics Dashboard',
-                description: 'Analytics and metrics visualization for Monomind operations',
-                version: '1.2.0',
-                cid: 'bafybeianalyticsplugin',
-                size: 210000,
-                checksum: 'sha256:pqr678analytics',
-                author: communityAuthor,
-                license: 'MIT',
-                categories: ['integrations'],
-                tags: ['analytics', 'metrics', 'dashboard', 'visualization'],
-                keywords: ['analytics', 'dashboard'],
-                downloads: 3400,
-                rating: 4.4,
-                ratingCount: 67,
-                lastUpdated: baseTime,
-                createdAt: '2024-06-01T00:00:00Z',
-                minMonomindVersion: '3.0.0',
-                dependencies: [{ name: '@monomind/core', version: '^3.0.0' }],
-                type: 'integration',
-                hooks: ['analytics:track', 'analytics:report'],
-                commands: ['analytics dashboard', 'analytics export'],
-                permissions: ['memory', 'network'],
-                exports: ['AnalyticsTracker', 'Dashboard'],
-                verified: false,
-                trustLevel: 'community',
-            },
-            {
-                id: 'custom-agents',
-                name: 'custom-agents',
-                displayName: 'Custom Agent Pack',
-                description: 'Additional specialized agent types for domain-specific tasks',
-                version: '2.0.1',
-                cid: 'bafybeicustomagentsplugin',
-                size: 175000,
-                checksum: 'sha256:stu901agents',
-                author: communityAuthor,
-                license: 'Apache-2.0',
-                categories: ['agents'],
-                tags: ['agents', 'custom', 'specialized', 'domain-specific'],
-                keywords: ['agents', 'custom'],
-                downloads: 2100,
-                rating: 4.3,
-                ratingCount: 45,
-                lastUpdated: baseTime,
-                createdAt: '2024-08-01T00:00:00Z',
-                minMonomindVersion: '3.0.0',
-                dependencies: [{ name: '@monomind/core', version: '^3.0.0' }],
-                type: 'agent',
-                hooks: ['agent:spawn', 'agent:complete'],
-                commands: ['agents custom list', 'agents custom spawn'],
-                permissions: ['agents', 'memory'],
-                exports: ['DataScienceAgent', 'DevOpsAgent', 'ContentAgent'],
-                verified: false,
-                trustLevel: 'community',
-            },
-            {
-                id: 'slack-integration',
-                name: 'slack-integration',
-                displayName: 'Slack Integration',
-                description: 'Slack integration for notifications and collaborative workflows',
-                version: '1.0.0',
-                cid: 'bafybeislackplugin',
-                size: 85000,
-                checksum: 'sha256:vwx234slack',
-                author: communityAuthor,
-                license: 'MIT',
-                categories: ['integrations'],
-                tags: ['slack', 'notifications', 'collaboration', 'messaging'],
-                keywords: ['slack', 'integration'],
-                downloads: 1800,
-                rating: 4.5,
-                ratingCount: 38,
-                lastUpdated: baseTime,
-                createdAt: '2024-09-01T00:00:00Z',
-                minMonomindVersion: '3.0.0',
-                dependencies: [
-                    { name: '@monomind/core', version: '^3.0.0' },
-                    { name: '@slack/web-api', version: '^6.0.0' },
-                ],
-                type: 'integration',
-                hooks: ['notification:send'],
-                commands: ['slack notify', 'slack connect'],
-                permissions: ['network', 'credentials'],
-                exports: ['SlackNotifier', 'SlackBot'],
-                verified: false,
-                trustLevel: 'community',
-            },
-            // Plugin SDK - Unified Plugin SDK for creating plugins
-            {
-                id: '@monomind/plugins',
-                name: '@monomind/plugins',
-                displayName: 'Plugin SDK',
-                description: 'Unified Plugin SDK for Monomind - Worker, Hook, and Provider Integration. Create, test, and publish MonoMind plugins.',
-                version: '3.0.0-alpha.2',
-                cid: 'bafybeipluginsdk2024xyz',
-                size: 156000,
-                checksum: 'sha256:pluginsdk2024abc',
-                author: officialAuthor,
-                license: 'MIT',
-                categories: ['devops'],
-                tags: ['plugin', 'sdk', 'development', 'toolkit', 'workers', 'hooks', 'providers'],
-                keywords: ['plugin', 'sdk', 'development'],
-                downloads: 0,
-                rating: 0,
-                ratingCount: 0,
-                lastUpdated: baseTime,
-                createdAt: '2024-04-01T00:00:00Z',
-                minMonomindVersion: '3.0.0',
-                dependencies: [
-                    { name: '@monomind/core', version: '^3.0.0' },
-                ],
-                type: 'core',
-                hooks: [
-                    'plugin:create',
-                    'plugin:validate',
-                    'plugin:test',
-                ],
-                commands: [
-                    'plugins create',
-                    'plugins validate',
-                    'plugins test',
-                ],
-                permissions: ['filesystem'],
-                exports: [
-                    'PluginBuilder',
-                    'WorkerPlugin',
-                    'HookPlugin',
-                    'ProviderPlugin',
-                ],
-                verified: true,
-                trustLevel: 'official',
-            },
-            // Agentic QE - AI-powered quality engineering
-            {
-                id: '@monomind/plugin-agentic-qe',
-                name: '@monomind/plugin-agentic-qe',
-                displayName: 'Agentic Quality Engineering',
-                description: 'AI-powered quality engineering with 58 agents that write tests, find bugs, predict defects, scan security, and perform chaos engineering safely.',
-                version: '3.0.0-alpha.3',
-                cid: 'bafybeiagenticqeplugin2024',
-                size: 285000,
-                checksum: 'sha256:agenticqe2024xyz',
-                author: officialAuthor,
-                license: 'MIT',
-                categories: ['ai-ml', 'devops', 'security'],
-                tags: ['testing', 'qe', 'tdd', 'security', 'chaos-engineering', 'coverage', 'defect-prediction', 'agents'],
-                keywords: ['quality', 'testing', 'agents', 'tdd', 'security'],
-                downloads: 1200,
-                rating: 4.8,
-                ratingCount: 24,
-                lastUpdated: baseTime,
-                createdAt: '2026-01-20T00:00:00Z',
-                minMonomindVersion: '3.0.0',
-                dependencies: [
-                    { name: '@monomind/core', version: '^3.0.0' },
-                ],
-                type: 'integration',
-                hooks: [
-                    'aqe:generate-tests',
-                    'aqe:analyze-coverage',
-                    'aqe:security-scan',
-                    'aqe:predict-defects',
-                    'aqe:chaos-inject',
-                ],
-                commands: [
-                    'aqe generate-tests',
-                    'aqe tdd-cycle',
-                    'aqe security-scan',
-                    'aqe predict-defects',
-                    'aqe chaos-inject',
-                    'aqe quality-gate',
-                    'aqe visual-regression',
-                ],
-                permissions: ['filesystem', 'network', 'memory'],
-                exports: [
-                    'TestGenerator',
-                    'CoverageAnalyzer',
-                    'SecurityScanner',
-                    'DefectPredictor',
-                    'ChaosInjector',
-                    'QualityGate',
-                ],
-                verified: true,
-                trustLevel: 'official',
-                securityAudit: {
-                    auditor: 'monomind-security-team',
-                    auditDate: '2026-01-20T00:00:00Z',
-                    auditVersion: '3.0.0-alpha.3',
-                    passed: true,
-                    issues: [],
-                },
-            },
-            // Prime Radiant - Mathematical coherence and consensus verification
-            {
-                id: '@monomind/plugin-prime-radiant',
-                name: '@monomind/plugin-prime-radiant',
-                displayName: 'Prime Radiant',
-                description: 'Mathematical AI that catches contradictions, verifies consensus, prevents hallucinations, and analyzes swarm stability using sheaf cohomology and spectral graph theory.',
-                version: '0.1.5',
-                cid: 'bafybeiprimeradiantplugin2024',
-                size: 195000,
-                checksum: 'sha256:primeradiant2024xyz',
-                author: officialAuthor,
-                license: 'MIT',
-                categories: ['ai-ml', 'agents'],
-                tags: ['coherence', 'consensus', 'mathematics', 'validation', 'hallucination-prevention', 'spectral', 'causal'],
-                keywords: ['coherence', 'consensus', 'validation', 'mathematics'],
-                downloads: 850,
-                rating: 4.9,
-                ratingCount: 18,
-                lastUpdated: baseTime,
-                createdAt: '2026-01-20T00:00:00Z',
-                minMonomindVersion: '3.0.0',
-                dependencies: [
-                    { name: '@monomind/core', version: '^3.0.0' },
-                ],
-                type: 'integration',
-                hooks: [
-                    'pr:pre-memory-store',
-                    'pr:pre-consensus',
-                    'pr:post-swarm-task',
-                    'pr:pre-rag-retrieval',
-                ],
-                commands: [
-                    'pr coherence-check',
-                    'pr consensus-verify',
-                    'pr spectral-analyze',
-                    'pr causal-infer',
-                    'pr memory-gate',
-                    'pr quantum-topology',
-                ],
-                permissions: ['memory', 'hooks'],
-                exports: [
-                    'CoherenceChecker',
-                    'ConsensusVerifier',
-                    'SpectralAnalyzer',
-                    'CausalInference',
-                    'MemoryGate',
-                    'QuantumTopology',
-                ],
-                verified: true,
-                trustLevel: 'official',
-                securityAudit: {
-                    auditor: 'monomind-security-team',
-                    auditDate: '2026-01-20T00:00:00Z',
-                    auditVersion: '0.1.5',
-                    passed: true,
-                    issues: [],
-                },
-            },
-            // Teammate Plugin - Claude Code v2.1.19+ integration
-            {
-                id: '@monomind/teammate-plugin',
-                name: '@monomind/teammate-plugin',
-                displayName: 'Teammate Plugin',
-                description: 'Native TeammateTool integration for Claude Code v2.1.19+. Multi-agent team orchestration with plan approval workflows, delegation, messaging, and BMSSP-optimized topology routing. 21 MCP tools.',
-                version: '1.0.0-alpha.1',
-                cid: 'bafybeiteammateplugin2026',
-                size: 387000,
-                checksum: 'sha256:e335dd24ec2e68e8952c517794421a0b18dfb23f',
-                author: officialAuthor,
-                license: 'MIT',
-                categories: ['agents', 'integrations'],
-                tags: ['teammate', 'claude-code', 'multi-agent', 'swarm', 'orchestration', 'bmssp'],
-                keywords: ['teammate', 'claude-code', 'multi-agent'],
-                downloads: 0,
-                rating: 0,
-                ratingCount: 0,
-                lastUpdated: baseTime,
-                createdAt: '2026-01-25T00:00:00Z',
-                minMonomindVersion: '3.0.0',
-                dependencies: [
-                    { name: '@monomind/core', version: '^3.0.0' },
-                    { name: 'eventemitter3', version: '^5.0.1' },
-                ],
-                type: 'integration',
-                hooks: ['teammate:spawn', 'teammate:message', 'teammate:plan', 'teammate:delegate'],
-                commands: ['teammate spawn', 'teammate team', 'teammate message', 'teammate plan'],
-                permissions: ['filesystem', 'memory', 'network'],
-                exports: ['TeammateBridge', 'createTeammateBridge', 'TEAMMATE_MCP_TOOLS', 'TopologyOptimizer', 'SemanticRouter'],
-                verified: true,
-                trustLevel: 'official',
-                securityAudit: {
-                    auditor: 'monomind-security-team',
-                    auditDate: '2026-01-25T00:00:00Z',
-                    auditVersion: '1.0.0-alpha.1',
-                    passed: true,
-                    issues: [],
-                },
-            },
-        ];
-    }
-    /**
-     * Get demo plugins with real npm stats
-     */
-    async getDemoPluginsWithStats() {
-        const basePlugins = this.getDemoPlugins();
-        // Only fetch stats for real npm packages
-        const realNpmPackages = [
-            '@monomind/plugin-agentic-qe',
-            '@monomind/plugin-prime-radiant',
-            '@monomind/claims',
-            '@monomind/security',
-            '@monomind/plugins',
-            '@monomind/teammate-plugin',
-        ];
-        // Fetch stats in parallel
-        const statsPromises = realNpmPackages.map(pkg => fetchNpmStats(pkg));
-        const statsResults = await Promise.all(statsPromises);
-        // Create a map of package -> stats
-        const statsMap = new Map();
-        realNpmPackages.forEach((pkg, i) => {
-            if (statsResults[i]) {
-                statsMap.set(pkg, statsResults[i]);
-            }
-        });
-        // Update plugins with real stats, remove fake plugins that don't exist
-        return basePlugins
-            .filter(plugin => {
-            // Keep only real plugins that exist on npm or our two new ones
-            const isRealPlugin = realNpmPackages.includes(plugin.name);
-            return isRealPlugin;
-        })
-            .map(plugin => {
-            const stats = statsMap.get(plugin.name);
-            if (stats) {
-                return {
-                    ...plugin,
-                    downloads: stats.downloads,
-                    version: stats.version,
-                    ratingCount: 0, // No rating system yet
-                    rating: 0,
-                };
-            }
-            return {
-                ...plugin,
-                downloads: 0,
-                ratingCount: 0,
-                rating: 0,
-            };
-        });
-    }
-    /**
-     * Verify registry signature using real Ed25519
-     */
-    async verifyRegistrySignature(registry, expectedPublicKey) {
-        if (!registry.registrySignature || !registry.registryPublicKey)
-            return false;
-        if (registry.registryPublicKey !== expectedPublicKey)
-            return false;
-        const sigHex = registry.registrySignature.replace(/^ed25519:/, '');
-        const pubKeyHex = registry.registryPublicKey.replace(/^ed25519:/, '');
-        if (sigHex.length !== 128 || pubKeyHex.length !== 64)
-            return false;
-        const content = JSON.stringify({
-            version: registry.version,
-            updatedAt: registry.updatedAt,
-            plugins: registry.plugins.map(p => ({ id: p.id, cid: p.cid, checksum: p.checksum, version: p.version })),
-            totalPlugins: registry.totalPlugins,
-        });
-        try {
-            const ed = await import('@noble/ed25519');
-            return await ed.verifyAsync(Buffer.from(sigHex, 'hex'), Buffer.from(content), Buffer.from(pubKeyHex, 'hex'));
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * List available registries
-     */
-    listRegistries() {
-        return [...this.config.registries];
-    }
-    /**
-     * Add a new registry
-     */
-    addRegistry(registry) {
-        this.config.registries.push(registry);
-    }
-    /**
-     * Remove a registry
-     */
-    removeRegistry(name) {
-        const index = this.config.registries.findIndex(r => r.name === name);
-        if (index >= 0) {
-            this.config.registries.splice(index, 1);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Clear cache
-     */
-    clearCache() {
-        this.cache.clear();
-    }
-    /**
-     * Get cache statistics
-     */
-    getCacheStats() {
-        return {
-            entries: this.cache.size,
-            registries: Array.from(this.cache.keys()),
-        };
-    }
-}
-/**
- * Create discovery service with default config
- */
-export function createPluginDiscoveryService(config) {
-    return new PluginDiscoveryService(config);
-}
-//# sourceMappingURL=discovery.js.map