monomind 1.10.0 → 1.10.2

package/packages/@monomind/cli/dist/src/transfer/store/publish.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Pattern Publish Service
+ * Publish and contribute patterns to decentralized registry
+ */
+import type { PublishOptions, PublishResult, StoreConfig } from './types.js';
+import type { CFPFormat } from '../types.js';
+/**
+ * Pattern Publisher
+ * Handles publishing patterns to IPFS and registry
+ */
+export declare class PatternPublisher {
+    private config;
+    constructor(config?: Partial<StoreConfig>);
+    /**
+     * Publish a pattern to IPFS and registry
+     */
+    publishPattern(cfp: CFPFormat, options: PublishOptions): Promise<PublishResult>;
+    /**
+     * Sign content with Ed25519 private key
+     */
+    private signContent;
+    /**
+     * Get current author info
+     */
+    private getAuthor;
+    /**
+     * Validate pattern before publish
+     */
+    validateForPublish(cfp: CFPFormat, options: PublishOptions): string[];
+    /**
+     * Create publish preview
+     */
+    createPreview(cfp: CFPFormat, options: PublishOptions): object;
+}
+/**
+ * Submit contribution request
+ * For contributing to official registry
+ */
+export interface ContributionRequest {
+    patternCid: string;
+    name: string;
+    displayName: string;
+    description: string;
+    categories: string[];
+    tags: string[];
+    authorId: string;
+    signature: string;
+    publicKey: string;
+    message?: string;
+}
+/**
+ * Submit a contribution to the registry
+ */
+export declare function submitContribution(request: ContributionRequest): Promise<{
+    success: boolean;
+    submissionId: string;
+    message: string;
+}>;
+/**
+ * Check contribution status
+ */
+export declare function checkContributionStatus(submissionId: string): Promise<{
+    status: 'pending' | 'reviewing' | 'approved' | 'rejected';
+    message: string;
+    reviewedAt?: string;
+    reviewer?: string;
+}>;
+/**
+ * Create publisher with default config
+ */
+export declare function createPublisher(config?: Partial<StoreConfig>): PatternPublisher;
+/**
+ * Quick publish helper
+ */
+export declare function quickPublish(cfp: CFPFormat, name: string, description: string, tags: string[], config?: Partial<StoreConfig>): Promise<PublishResult>;
+//# sourceMappingURL=publish.d.ts.map

package/packages/@monomind/cli/dist/src/transfer/store/publish.js

@@ -0,0 +1,293 @@
+/**
+ * Pattern Publish Service
+ * Publish and contribute patterns to decentralized registry
+ */
+import * as fs from 'fs';
+import * as crypto from 'crypto';
+import { DEFAULT_STORE_CONFIG, generatePatternId } from './registry.js';
+import { anonymizeCFP } from '../anonymization/index.js';
+import { uploadToIPFS, pinContent } from '../ipfs/upload.js';
+/**
+ * Pattern Publisher
+ * Handles publishing patterns to IPFS and registry
+ */
+export class PatternPublisher {
+    config;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_STORE_CONFIG, ...config };
+    }
+    /**
+     * Publish a pattern to IPFS and registry
+     */
+    async publishPattern(cfp, options) {
+        console.log(`[Publish] Starting publish: ${options.name}`);
+        try {
+            // Step 1: Anonymize if needed
+            const anonymized = anonymizeCFP(cfp, options.anonymize);
+            console.log(`[Publish] Anonymization level: ${options.anonymize}`);
+            // Step 2: Serialize content
+            const content = JSON.stringify(anonymized, null, 2);
+            const contentBuffer = Buffer.from(content);
+            // Step 3: Calculate checksum
+            const checksum = crypto
+                .createHash('sha256')
+                .update(contentBuffer)
+                .digest('hex');
+            // Step 4: Sign if private key provided
+            let signature;
+            let publicKey;
+            if (options.privateKeyPath && fs.existsSync(options.privateKeyPath)) {
+                const signResult = await this.signContent(contentBuffer, options.privateKeyPath);
+                signature = signResult.signature;
+                publicKey = signResult.publicKey;
+                console.log(`[Publish] Content signed`);
+            }
+            // Get author info early (needed for GCS metadata and pattern entry)
+            const author = this.getAuthor();
+            // Step 5: Upload to IPFS or GCS
+            let uploadCid;
+            let gatewayUrl;
+            // Check if GCS is configured
+            try {
+                const { hasGCSCredentials, uploadToGCS } = await import('../storage/gcs.js');
+                if (hasGCSCredentials()) {
+                    console.log(`[Publish] Uploading to Google Cloud Storage...`);
+                    const gcsResult = await uploadToGCS(contentBuffer, {
+                        name: `${options.name}.cfp.json`,
+                        metadata: {
+                            checksum,
+                            author: author.id,
+                            version: cfp.version,
+                        },
+                    });
+                    if (gcsResult.success) {
+                        uploadCid = gcsResult.uri; // Use GCS URI as CID
+                        gatewayUrl = gcsResult.publicUrl;
+                        console.log(`[Publish] Uploaded to GCS: ${gcsResult.uri}`);
+                    }
+                    else {
+                        throw new Error('GCS upload failed');
+                    }
+                }
+                else {
+                    throw new Error('GCS not configured');
+                }
+            }
+            catch {
+                // Fallback to IPFS
+                console.log(`[Publish] Uploading to IPFS...`);
+                const uploadResult = await uploadToIPFS(contentBuffer, {
+                    name: `${options.name}.cfp.json`,
+                    pin: true,
+                });
+                if (!uploadResult.cid) {
+                    return {
+                        success: false,
+                        patternId: '',
+                        cid: '',
+                        registryCid: '',
+                        gatewayUrl: '',
+                        message: 'Failed to upload to IPFS (no IPFS credentials configured)',
+                    };
+                }
+                uploadCid = uploadResult.cid;
+                gatewayUrl = `${this.config.gateway}/ipfs/${uploadResult.cid}`;
+                console.log(`[Publish] Uploaded to IPFS: ${uploadResult.cid}`);
+                // Pin content
+                await pinContent(uploadResult.cid);
+            }
+            // Step 6: Create pattern entry
+            const patternId = generatePatternId(options.name);
+            const patternEntry = {
+                id: patternId,
+                name: options.name,
+                displayName: options.displayName,
+                description: options.description,
+                version: cfp.version,
+                cid: uploadCid,
+                size: contentBuffer.length,
+                checksum,
+                author,
+                license: options.license,
+                categories: options.categories,
+                tags: options.tags,
+                language: options.language,
+                framework: options.framework,
+                downloads: 0,
+                rating: 0,
+                ratingCount: 0,
+                lastUpdated: new Date().toISOString(),
+                createdAt: new Date().toISOString(),
+                minMonomindVersion: '3.0.0',
+                verified: author.verified,
+                trustLevel: author.verified ? 'verified' : 'community',
+                signature,
+                publicKey,
+            };
+            // Step 7: Add to registry (in production: submit to registry maintainers)
+            console.log(`[Publish] Pattern entry created: ${patternId}`);
+            return {
+                success: true,
+                patternId,
+                cid: uploadCid,
+                registryCid: '', // Would be updated after registry update
+                gatewayUrl,
+                message: `Pattern '${options.displayName}' published successfully!`,
+            };
+        }
+        catch (error) {
+            console.error(`[Publish] Failed:`, error);
+            return {
+                success: false,
+                patternId: '',
+                cid: '',
+                registryCid: '',
+                gatewayUrl: '',
+                message: `Publish failed: ${error}`,
+            };
+        }
+    }
+    /**
+     * Sign content with Ed25519 private key
+     */
+    async signContent(content, privateKeyPath) {
+        const ed = await import('@noble/ed25519');
+        const keyHex = fs.readFileSync(privateKeyPath, 'utf-8').trim();
+        // Accept 64-char hex (32-byte seed) directly; otherwise derive via SHA-256
+        const privKeyBytes = keyHex.length === 64
+            ? Buffer.from(keyHex, 'hex')
+            : crypto.createHash('sha256').update(keyHex).digest();
+        const pubKeyBytes = await ed.getPublicKeyAsync(privKeyBytes);
+        const sigBytes = await ed.signAsync(content, privKeyBytes);
+        return {
+            signature: 'ed25519:' + Buffer.from(sigBytes).toString('hex'),
+            publicKey: 'ed25519:' + Buffer.from(pubKeyBytes).toString('hex'),
+        };
+    }
+    /**
+     * Get current author info
+     */
+    getAuthor() {
+        if (this.config.authorId) {
+            return {
+                id: this.config.authorId,
+                displayName: this.config.authorId,
+                verified: false,
+                patterns: 0,
+                totalDownloads: 0,
+            };
+        }
+        // Anonymous author
+        return {
+            id: `anon-${crypto.randomBytes(8).toString('hex')}`,
+            verified: false,
+            patterns: 0,
+            totalDownloads: 0,
+        };
+    }
+    /**
+     * Validate pattern before publish
+     */
+    validateForPublish(cfp, options) {
+        const errors = [];
+        // Check required fields
+        if (!options.name || options.name.length < 3) {
+            errors.push('Name must be at least 3 characters');
+        }
+        if (!options.displayName || options.displayName.length < 3) {
+            errors.push('Display name must be at least 3 characters');
+        }
+        if (!options.description || options.description.length < 20) {
+            errors.push('Description must be at least 20 characters');
+        }
+        if (!options.categories || options.categories.length === 0) {
+            errors.push('At least one category is required');
+        }
+        if (!options.tags || options.tags.length < 3) {
+            errors.push('At least 3 tags are required');
+        }
+        // Check valid license
+        const validLicenses = ['MIT', 'Apache-2.0', 'GPL-3.0', 'BSD-3-Clause', 'CC-BY-4.0', 'Unlicense'];
+        if (!validLicenses.includes(options.license)) {
+            errors.push(`License must be one of: ${validLicenses.join(', ')}`);
+        }
+        // Check pattern content
+        if (cfp.magic !== 'CFP1') {
+            errors.push('Invalid CFP format (missing magic header)');
+        }
+        const totalPatterns = cfp.statistics.totalPatterns;
+        if (totalPatterns === 0) {
+            errors.push('Pattern must contain at least one pattern');
+        }
+        return errors;
+    }
+    /**
+     * Create publish preview
+     */
+    createPreview(cfp, options) {
+        return {
+            name: options.name,
+            displayName: options.displayName,
+            description: options.description,
+            categories: options.categories,
+            tags: options.tags,
+            license: options.license,
+            language: options.language,
+            framework: options.framework,
+            anonymization: options.anonymize,
+            statistics: cfp.statistics,
+            estimatedSize: JSON.stringify(cfp).length,
+        };
+    }
+}
+/**
+ * Submit a contribution to the registry
+ */
+export async function submitContribution(request) {
+    console.log(`[Contribute] Submitting contribution: ${request.name}`);
+    // In production: Submit to registry governance system
+    // For demo: Generate mock submission ID
+    const submissionId = `contrib-${crypto.randomBytes(8).toString('hex')}`;
+    console.log(`[Contribute] Submission ID: ${submissionId}`);
+    console.log(`[Contribute] Pattern CID: ${request.patternCid}`);
+    console.log(`[Contribute] Author: ${request.authorId}`);
+    return {
+        success: true,
+        submissionId,
+        message: `Contribution submitted for review. Track status with ID: ${submissionId}`,
+    };
+}
+/**
+ * Check contribution status
+ */
+export async function checkContributionStatus(submissionId) {
+    // In production: Query registry governance system
+    // For demo: Return mock status
+    return {
+        status: 'pending',
+        message: 'Your contribution is pending review',
+    };
+}
+/**
+ * Create publisher with default config
+ */
+export function createPublisher(config) {
+    return new PatternPublisher(config);
+}
+/**
+ * Quick publish helper
+ */
+export async function quickPublish(cfp, name, description, tags, config) {
+    const publisher = new PatternPublisher(config);
+    const options = {
+        name,
+        displayName: name.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase()),
+        description,
+        categories: ['custom'],
+        tags,
+        license: 'MIT',
+        anonymize: 'standard',
+    };
+    return publisher.publishPattern(cfp, options);
+}
+//# sourceMappingURL=publish.js.map

package/packages/@monomind/cli/dist/src/transfer/store/registry.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Decentralized Pattern Registry
+ * IPFS-based registry with IPNS for mutable references
+ */
+import type { PatternRegistry, PatternEntry, PatternCategory, KnownRegistry, StoreConfig } from './types.js';
+/**
+ * Registry version
+ */
+export declare const REGISTRY_VERSION = "1.0.0";
+/**
+ * Default bootstrap registries for discovery
+ */
+export declare const BOOTSTRAP_REGISTRIES: KnownRegistry[];
+/**
+ * Default store configuration
+ */
+export declare const DEFAULT_STORE_CONFIG: StoreConfig;
+/**
+ * Create a new empty registry
+ */
+export declare function createRegistry(ipnsName: string): PatternRegistry;
+/**
+ * Default pattern categories
+ */
+export declare function getDefaultCategories(): PatternCategory[];
+/**
+ * Add a pattern to the registry
+ */
+export declare function addPatternToRegistry(registry: PatternRegistry, entry: PatternEntry): PatternRegistry;
+/**
+ * Remove a pattern from the registry
+ */
+export declare function removePatternFromRegistry(registry: PatternRegistry, patternId: string): PatternRegistry;
+/**
+ * Serialize registry to JSON
+ */
+export declare function serializeRegistry(registry: PatternRegistry): string;
+/**
+ * Deserialize registry from JSON
+ */
+export declare function deserializeRegistry(json: string): PatternRegistry;
+/**
+ * Sign registry with private key
+ */
+export declare function signRegistry(registry: PatternRegistry, privateKey: string): Promise<PatternRegistry>;
+/**
+ * Verify registry signature using real Ed25519
+ */
+export declare function verifyRegistrySignature(registry: PatternRegistry): Promise<boolean>;
+/**
+ * Merge two registries (for sync)
+ */
+export declare function mergeRegistries(local: PatternRegistry, remote: PatternRegistry): PatternRegistry;
+/**
+ * Generate pattern ID from name
+ */
+export declare function generatePatternId(name: string): string;
+//# sourceMappingURL=registry.d.ts.map