@claude-flow/cli 3.32.3 → 3.32.4

package/dist/src/plugins/store/types.d.ts

@@ -0,0 +1,279 @@
+/**
+ * Plugin Store Types
+ * Decentralized plugin marketplace using IPFS
+ * Extends the pattern store architecture for plugins
+ */
+import type { TrustLevel } from '../../transfer/types.js';
+/**
+ * Plugin entry in the registry
+ */
+export interface PluginEntry {
+    id: string;
+    name: string;
+    displayName: string;
+    description: string;
+    version: string;
+    cid: string;
+    size: number;
+    checksum: string;
+    author: PluginAuthor;
+    license: string;
+    categories: string[];
+    tags: string[];
+    keywords: string[];
+    downloads: number;
+    rating: number;
+    ratingCount: number;
+    lastUpdated: string;
+    createdAt: string;
+    minClaudeFlowVersion: string;
+    maxClaudeFlowVersion?: string;
+    dependencies: PluginDependency[];
+    peerDependencies?: PluginDependency[];
+    type: PluginType;
+    hooks: string[];
+    commands: string[];
+    permissions: PluginPermission[];
+    exports: string[];
+    verified: boolean;
+    trustLevel: TrustLevel;
+    signature?: string;
+    publicKey?: string;
+    securityAudit?: SecurityAudit;
+    knownVulnerabilities?: string[];
+}
+/**
+ * Plugin types
+ *
+ * ADR-150 added 'harness' — a MetaHarness-generated standalone agent
+ * harness. Harnesses share the ruflo plugin registry shape (per
+ * `buildRegistryEntry()` from metaharness) so `npx ruflo plugins list
+ * --type harness` surfaces community harnesses alongside plugins.
+ */
+export type PluginType = 'agent' | 'hook' | 'command' | 'provider' | 'integration' | 'theme' | 'core' | 'hybrid' | 'harness';
+/**
+ * Plugin dependency
+ */
+export interface PluginDependency {
+    name: string;
+    version: string;
+    optional?: boolean;
+}
+/**
+ * Plugin permissions
+ */
+export type PluginPermission = 'network' | 'filesystem' | 'execute' | 'memory' | 'agents' | 'credentials' | 'config' | 'hooks' | 'privileged';
+/**
+ * Security audit info
+ */
+export interface SecurityAudit {
+    auditor: string;
+    auditDate: string;
+    auditVersion: string;
+    passed: boolean;
+    issues: SecurityIssue[];
+    reportCid?: string;
+}
+/**
+ * Security issue
+ */
+export interface SecurityIssue {
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    description: string;
+    resolved: boolean;
+    resolvedVersion?: string;
+}
+/**
+ * Plugin author info
+ */
+export interface PluginAuthor {
+    id: string;
+    displayName?: string;
+    email?: string;
+    website?: string;
+    publicKey?: string;
+    verified: boolean;
+    plugins: number;
+    totalDownloads: number;
+    reputation: number;
+}
+/**
+ * Plugin category
+ */
+export interface PluginCategory {
+    id: string;
+    name: string;
+    description: string;
+    pluginCount: number;
+    icon?: string;
+    subcategories?: PluginCategory[];
+}
+/**
+ * Decentralized plugin registry
+ * Stored on IPFS with IPNS pointer for updates
+ */
+export interface PluginRegistry {
+    version: string;
+    type: 'plugins';
+    updatedAt: string;
+    ipnsName: string;
+    previousCid?: string;
+    plugins: PluginEntry[];
+    categories: PluginCategory[];
+    authors: PluginAuthor[];
+    totalPlugins: number;
+    totalDownloads: number;
+    totalAuthors: number;
+    featured: string[];
+    trending: string[];
+    newest: string[];
+    official: string[];
+    registrySignature?: string;
+    registryPublicKey?: string;
+    compatibilityMatrix: CompatibilityEntry[];
+}
+/**
+ * Compatibility entry
+ */
+export interface CompatibilityEntry {
+    pluginId: string;
+    pluginVersion: string;
+    claudeFlowVersions: string[];
+    tested: boolean;
+    notes?: string;
+}
+/**
+ * Search query options for plugins
+ */
+export interface PluginSearchOptions {
+    query?: string;
+    category?: string;
+    type?: PluginType;
+    tags?: string[];
+    author?: string;
+    minRating?: number;
+    minDownloads?: number;
+    verified?: boolean;
+    trustLevel?: TrustLevel;
+    permissions?: PluginPermission[];
+    hasSecurityAudit?: boolean;
+    sortBy?: 'downloads' | 'rating' | 'newest' | 'name' | 'reputation';
+    sortOrder?: 'asc' | 'desc';
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Search result
+ */
+export interface PluginSearchResult {
+    plugins: PluginEntry[];
+    total: number;
+    page: number;
+    pageSize: number;
+    hasMore: boolean;
+    query: PluginSearchOptions;
+}
+/**
+ * Publish options for plugins
+ */
+export interface PluginPublishOptions {
+    name: string;
+    displayName: string;
+    description: string;
+    version: string;
+    categories: string[];
+    tags: string[];
+    license: string;
+    type: PluginType;
+    hooks?: string[];
+    commands?: string[];
+    permissions: PluginPermission[];
+    dependencies?: PluginDependency[];
+    privateKeyPath?: string;
+    requestAudit?: boolean;
+}
+/**
+ * Publish result
+ */
+export interface PluginPublishResult {
+    success: boolean;
+    pluginId: string;
+    cid: string;
+    registryCid: string;
+    gatewayUrl: string;
+    message: string;
+    auditRequestId?: string;
+}
+/**
+ * Download options for plugins
+ */
+export interface PluginDownloadOptions {
+    output?: string;
+    verify?: boolean;
+    install?: boolean;
+    global?: boolean;
+    skipDependencies?: boolean;
+}
+/**
+ * Download result
+ */
+export interface PluginDownloadResult {
+    success: boolean;
+    plugin: PluginEntry;
+    outputPath?: string;
+    installed?: boolean;
+    verified: boolean;
+    size: number;
+    dependenciesInstalled?: string[];
+}
+/**
+ * Known plugin registries (bootstrap nodes)
+ */
+export interface KnownPluginRegistry {
+    name: string;
+    description: string;
+    ipnsName: string;
+    gateway: string;
+    publicKey: string;
+    trusted: boolean;
+    official: boolean;
+}
+/**
+ * Plugin store configuration
+ */
+export interface PluginStoreConfig {
+    registries: KnownPluginRegistry[];
+    defaultRegistry: string;
+    gateway: string;
+    timeout: number;
+    cacheDir: string;
+    cacheExpiry: number;
+    requireVerification: boolean;
+    requireSecurityAudit: boolean;
+    minTrustLevel: TrustLevel;
+    trustedAuthors: string[];
+    blockedPlugins: string[];
+    allowedPermissions: PluginPermission[];
+    requirePermissionPrompt: boolean;
+    authorId?: string;
+    privateKeyPath?: string;
+}
+/**
+ * Plugin installation manifest
+ */
+export interface PluginManifest {
+    name: string;
+    version: string;
+    cid: string;
+    installedAt: string;
+    enabled: boolean;
+    config?: Record<string, unknown>;
+}
+/**
+ * Installed plugins database
+ */
+export interface InstalledPlugins {
+    plugins: PluginManifest[];
+    lastUpdated: string;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,7 @@
+/**
+ * Plugin Store Types
+ * Decentralized plugin marketplace using IPFS
+ * Extends the pattern store architecture for plugins
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/plugins/tests/demo-plugin-store.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env npx tsx
+/**
+ * Plugin Store Demo
+ * Demonstrates the IPFS-based plugin registry working end-to-end
+ */
+export {};
+//# sourceMappingURL=demo-plugin-store.d.ts.map

package/dist/src/plugins/tests/demo-plugin-store.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env npx tsx
+/**
+ * Plugin Store Demo
+ * Demonstrates the IPFS-based plugin registry working end-to-end
+ */
+import { createPluginDiscoveryService, searchPlugins, getOfficialPlugins, } from '../store/index.js';
+async function demo() {
+    console.log('');
+    console.log('╔══════════════════════════════════════════════════════════════╗');
+    console.log('║  CLAUDE FLOW V3 - IPFS PLUGIN STORE DEMO                     ║');
+    console.log('║  Decentralized Plugin Marketplace                            ║');
+    console.log('╚══════════════════════════════════════════════════════════════╝');
+    console.log('');
+    // Step 1: Initialize discovery service
+    console.log('🔍 Step 1: Initialize Plugin Discovery Service');
+    const discovery = createPluginDiscoveryService();
+    const registries = discovery.listRegistries();
+    console.log(`   Found ${registries.length} bootstrap registries:`);
+    registries.forEach(r => {
+        console.log(`   ├─ ${r.name} ${r.official ? '(Official)' : '(Community)'}`);
+        console.log(`   │  └─ IPNS: ${r.ipnsName.slice(0, 30)}...`);
+    });
+    console.log('');
+    // Step 2: Discover registry via IPNS
+    console.log('🌐 Step 2: Discover Registry via IPNS');
+    const result = await discovery.discoverRegistry();
+    if (!result.success || !result.registry) {
+        console.error('   ❌ Failed to discover registry');
+        return;
+    }
+    console.log(`   ✅ Registry discovered from: ${result.source}`);
+    console.log(`   ├─ Total plugins: ${result.registry.totalPlugins}`);
+    console.log(`   ├─ Total downloads: ${result.registry.totalDownloads.toLocaleString()}`);
+    console.log(`   └─ CID: ${result.cid?.slice(0, 40)}...`);
+    console.log('');
+    // Step 3: List official plugins
+    console.log('📦 Step 3: Official Plugins Available');
+    const official = getOfficialPlugins(result.registry);
+    console.log('');
+    official.forEach(p => {
+        const stars = '★'.repeat(Math.round(p.rating));
+        console.log(`   ${p.verified ? '✓' : ' '} ${p.displayName} v${p.version}`);
+        console.log(`     └─ ${p.description.slice(0, 60)}...`);
+        console.log(`     └─ ${p.downloads.toLocaleString()} downloads | ${stars} ${p.rating}`);
+        console.log('');
+    });
+    // Step 4: Search for plugin-creator
+    console.log('🔎 Step 4: Search for "plugin creator"');
+    const searchResult = searchPlugins(result.registry, { query: 'plugin creator' });
+    console.log(`   Found ${searchResult.total} results`);
+    console.log('');
+    // Step 5: Plugin Creator details
+    const pluginCreator = searchResult.plugins.find(p => p.id === 'plugin-creator');
+    if (pluginCreator) {
+        console.log('═══════════════════════════════════════════════════════════════');
+        console.log('                    PLUGIN CREATOR PRO                          ');
+        console.log('═══════════════════════════════════════════════════════════════');
+        console.log('');
+        console.log(`   Name:        ${pluginCreator.displayName}`);
+        console.log(`   Version:     ${pluginCreator.version}`);
+        console.log(`   Trust:       ${pluginCreator.trustLevel.toUpperCase()}`);
+        console.log(`   Verified:    ${pluginCreator.verified ? '✓ Yes' : '✗ No'}`);
+        console.log(`   Downloads:   ${pluginCreator.downloads.toLocaleString()}`);
+        console.log(`   Rating:      ${'★'.repeat(Math.round(pluginCreator.rating))} ${pluginCreator.rating}/5`);
+        console.log(`   License:     ${pluginCreator.license}`);
+        console.log('');
+        console.log('   Description:');
+        console.log(`   ${pluginCreator.description}`);
+        console.log('');
+        console.log('   IPFS Storage:');
+        console.log(`   ├─ CID:      ${pluginCreator.cid}`);
+        console.log(`   ├─ Size:     ${(pluginCreator.size / 1024).toFixed(1)} KB`);
+        console.log(`   └─ Checksum: ${pluginCreator.checksum}`);
+        console.log('');
+        console.log('   Commands Available:');
+        pluginCreator.commands.forEach(cmd => {
+            console.log(`   └─ ${cmd}`);
+        });
+        console.log('');
+        console.log('   Hooks Provided:');
+        pluginCreator.hooks.forEach(hook => {
+            console.log(`   └─ ${hook}`);
+        });
+        console.log('');
+        console.log('   Permissions Required:');
+        console.log(`   └─ ${pluginCreator.permissions.join(', ')}`);
+        console.log('');
+        if (pluginCreator.securityAudit) {
+            console.log('   Security Audit:');
+            console.log(`   ├─ Auditor:  ${pluginCreator.securityAudit.auditor}`);
+            console.log(`   ├─ Date:     ${pluginCreator.securityAudit.auditDate}`);
+            console.log(`   └─ Passed:   ${pluginCreator.securityAudit.passed ? '✓ Yes' : '✗ No'}`);
+            console.log('');
+        }
+        console.log('   To install:');
+        console.log('   $ claude-flow plugins install -n plugin-creator');
+        console.log('');
+    }
+    // Summary
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('                    DEMO COMPLETE                               ');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('');
+    console.log('   The IPFS-based Plugin Store is working!');
+    console.log('');
+    console.log('   Features demonstrated:');
+    console.log('   ✅ Registry discovery via IPNS');
+    console.log('   ✅ Plugin search with full-text matching');
+    console.log('   ✅ Official/Verified plugin filtering');
+    console.log('   ✅ Plugin Creator Pro available for download');
+    console.log('   ✅ Security audit verification');
+    console.log('   ✅ Content-addressed storage (CID)');
+    console.log('');
+    console.log('   CLI Commands:');
+    console.log('   $ claude-flow plugins list              # List all plugins');
+    console.log('   $ claude-flow plugins list --official   # Official only');
+    console.log('   $ claude-flow plugins search -q neural  # Search plugins');
+    console.log('   $ claude-flow plugins info -n plugin-creator');
+    console.log('   $ claude-flow plugins install -n plugin-creator');
+    console.log('');
+}
+demo().catch(err => {
+    console.error('Demo failed:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=demo-plugin-store.js.map

package/dist/src/plugins/tests/standalone-test.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env npx tsx
+/**
+ * Standalone Plugin Store Test
+ * Run this in any environment to verify the IPFS-based plugin store works
+ *
+ * Usage:
+ *   npx tsx standalone-test.ts
+ *   # or
+ *   npm run test:plugin-store
+ */
+export {};
+//# sourceMappingURL=standalone-test.d.ts.map

package/dist/src/plugins/tests/standalone-test.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env npx tsx
+/**
+ * Standalone Plugin Store Test
+ * Run this in any environment to verify the IPFS-based plugin store works
+ *
+ * Usage:
+ *   npx tsx standalone-test.ts
+ *   # or
+ *   npm run test:plugin-store
+ */
+import { createPluginDiscoveryService, searchPlugins, getFeaturedPlugins, getOfficialPlugins, getPluginSearchSuggestions, getPluginTagCloud, findSimilarPlugins, } from '../store/index.js';
+async function main() {
+    console.log('');
+    console.log('╔══════════════════════════════════════════════════════════════╗');
+    console.log('║  CLAUDE FLOW V3 - STANDALONE PLUGIN STORE TEST               ║');
+    console.log('║  IPFS-Based Decentralized Plugin Marketplace                 ║');
+    console.log('╚══════════════════════════════════════════════════════════════╝');
+    console.log('');
+    let passed = 0;
+    let failed = 0;
+    // Test 1: Discovery Service Creation
+    console.log('▶ Test 1: Create Discovery Service');
+    try {
+        const discovery = createPluginDiscoveryService();
+        const registries = discovery.listRegistries();
+        console.log(`  ✅ Created service with ${registries.length} bootstrap registries`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 2: Discover Registry
+    console.log('▶ Test 2: Discover Registry via IPNS');
+    let registry = null;
+    try {
+        const discovery = createPluginDiscoveryService();
+        const result = await discovery.discoverRegistry();
+        if (result.success && result.registry) {
+            registry = result.registry;
+            console.log(`  ✅ Discovered ${result.registry.plugins.length} plugins from ${result.source}`);
+            passed++;
+        }
+        else {
+            throw new Error(result.error || 'No registry');
+        }
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    if (!registry) {
+        console.log('\n❌ Cannot continue without registry\n');
+        process.exit(1);
+    }
+    // Test 3: Search Plugins
+    console.log('▶ Test 3: Search for "plugin creator"');
+    try {
+        const results = searchPlugins(registry, { query: 'plugin creator' });
+        const found = results.plugins.find(p => p.id === 'plugin-creator');
+        if (found) {
+            console.log(`  ✅ Found Plugin Creator Pro v${found.version}`);
+            passed++;
+        }
+        else {
+            throw new Error('Plugin Creator not found in search results');
+        }
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 4: Get Official Plugins
+    console.log('▶ Test 4: Get Official Plugins');
+    try {
+        const official = getOfficialPlugins(registry);
+        console.log(`  ✅ Found ${official.length} official plugins:`);
+        official.forEach(p => console.log(`     - ${p.displayName} (${p.id})`));
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 5: Get Featured Plugins
+    console.log('▶ Test 5: Get Featured Plugins');
+    try {
+        const featured = getFeaturedPlugins(registry);
+        const hasPluginCreator = featured.some(p => p.id === 'plugin-creator');
+        console.log(`  ✅ Found ${featured.length} featured plugins (Plugin Creator featured: ${hasPluginCreator})`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 6: Search with Filters
+    console.log('▶ Test 6: Search with Filters (verified only)');
+    try {
+        const results = searchPlugins(registry, { verified: true });
+        console.log(`  ✅ Found ${results.plugins.length} verified plugins`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 7: Plugin Details
+    console.log('▶ Test 7: Get Plugin Creator Details');
+    try {
+        const plugin = registry.plugins.find((p) => p.id === 'plugin-creator');
+        if (plugin) {
+            console.log(`  ✅ Plugin Creator Pro Details:`);
+            console.log(`     Version: ${plugin.version}`);
+            console.log(`     Trust: ${plugin.trustLevel}`);
+            console.log(`     Commands: ${plugin.commands.length}`);
+            console.log(`     Downloads: ${plugin.downloads.toLocaleString()}`);
+            console.log(`     Rating: ${plugin.rating}/5`);
+            passed++;
+        }
+        else {
+            throw new Error('Plugin not found');
+        }
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 8: Tag Cloud
+    console.log('▶ Test 8: Get Tag Cloud');
+    try {
+        const tags = getPluginTagCloud(registry);
+        console.log(`  ✅ Found ${tags.size} unique tags`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 9: Search Suggestions
+    console.log('▶ Test 9: Get Search Suggestions');
+    try {
+        const suggestions = getPluginSearchSuggestions(registry, 'plug');
+        console.log(`  ✅ Got ${suggestions.length} suggestions for "plug"`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 10: Similar Plugins
+    console.log('▶ Test 10: Find Similar Plugins');
+    try {
+        const similar = findSimilarPlugins(registry, '@claude-flow/neural', 3);
+        console.log(`  ✅ Found ${similar.length} similar plugins to @claude-flow/neural`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Summary
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('                        TEST RESULTS                            ');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('');
+    console.log(`  Total:  ${passed + failed}`);
+    console.log(`  ✅ Passed: ${passed}`);
+    console.log(`  ❌ Failed: ${failed}`);
+    console.log('');
+    if (failed === 0) {
+        console.log('  🎉 All tests passed! Plugin Store is working correctly.');
+        console.log('');
+        console.log('  Available CLI Commands:');
+        console.log('    npx @claude-flow/cli plugins list');
+        console.log('    npx @claude-flow/cli plugins list --official');
+        console.log('    npx @claude-flow/cli plugins search -q "plugin creator"');
+        console.log('    npx @claude-flow/cli plugins info -n plugin-creator');
+        console.log('');
+    }
+    process.exit(failed > 0 ? 1 : 0);
+}
+main().catch(err => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=standalone-test.js.map

package/dist/src/plugins/tests/test-plugin-store.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env npx tsx
+/**
+ * Plugin Store Test Suite
+ * Tests IPFS-based plugin registry discovery, search, and operations
+ */
+export {};
+//# sourceMappingURL=test-plugin-store.d.ts.map