🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
TypeScript agentic-aiagentic-frameworkagentic-workflowagentsai-agentsai-assistantai-skillsautonomous-agentsclaudecodexdsh-pluginharnessmcp-servermulti-agentmulti-agent-systemsnpmskillsswarmswarm-intelligencetypescript
Checkpoint: File edits
rUv42bf74686733
diff --git a/v3/@claude-flow/cli/src/transfer/store/publish.ts b/v3/@claude-flow/cli/src/transfer/store/publish.tsnew file mode 100644index 0000000000..ab03dc5d41--- /dev/null+++ b/v3/@claude-flow/cli/src/transfer/store/publish.ts@@ -0,0 +1,352 @@+/**+ * Pattern Publish Service+ * Publish and contribute patterns to decentralized registry+ */++import * as fs from 'fs';+import * as path from 'path';+import * as crypto from 'crypto';+import type {+ PatternEntry,+ PatternAuthor,+ PatternRegistry,+ PublishOptions,+ PublishResult,+ StoreConfig,+} from './types.js';+import { DEFAULT_STORE_CONFIG, addPatternToRegistry, generatePatternId } from './registry.js';+import type { CFPFormat, AnonymizationLevel } from '../types.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 {+ private config: StoreConfig;++ constructor(config: Partial<StoreConfig> = {}) {+ this.config = { ...DEFAULT_STORE_CONFIG, ...config };+ }++ /**+ * Publish a pattern to IPFS and registry+ */+ async publishPattern(+ cfp: CFPFormat,+ options: PublishOptions+ ): Promise<PublishResult> {+ 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: string | undefined;+ let publicKey: string | undefined;++ if (options.privateKeyPath && fs.existsSync(options.privateKeyPath)) {+ const signResult = this.signContent(contentBuffer, options.privateKeyPath);+ signature = signResult.signature;+ publicKey = signResult.publicKey;+ console.log(`[Publish] Content signed`);+ }++ // Step 5: Upload to IPFS+ console.log(`[Publish] Uploading to IPFS...`);+ const uploadResult = await uploadToIPFS(+ contentBuffer,+ `${options.name}.cfp.json`+ );++ if (!uploadResult.success || !uploadResult.cid) {+ return {+ success: false,+ patternId: '',+ cid: '',+ registryCid: '',+ gatewayUrl: '',+ message: 'Failed to upload to IPFS',+ };+ }++ console.log(`[Publish] Uploaded to IPFS: ${uploadResult.cid}`);++ // Step 6: Pin content+ await pinContent(uploadResult.cid);++ // Step 7: Create pattern entry+ const patternId = generatePatternId(options.name);+ const author = this.getAuthor();++ const patternEntry: PatternEntry = {+ id: patternId,+ name: options.name,+ displayName: options.displayName,+ description: options.description,+ version: cfp.version,+ cid: uploadResult.cid,+ 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(),+ minClaudeFlowVersion: '3.0.0',+ verified: author.verified,+ trustLevel: author.verified ? 'verified' : 'community',+ signature,+ publicKey,+ };++ // Step 8: Add to registry (in production: submit to registry maintainers)+ console.log(`[Publish] Pattern entry created: ${patternId}`);++ // Generate gateway URL+ const gatewayUrl = `${this.config.gateway}/ipfs/${uploadResult.cid}`;++ return {+ success: true,+ patternId,+ cid: uploadResult.cid,+ 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 private key+ */+ private signContent(+ content: Buffer,+ privateKeyPath: string+ ): { signature: string; publicKey: string } {+ // In production: Use actual Ed25519 signing+ // For demo: Generate mock signature+ const privateKey = fs.readFileSync(privateKeyPath, 'utf-8').trim();+ const signature = crypto+ .createHmac('sha256', privateKey)+ .update(content)+ .digest('hex');++ const publicKey =+ 'ed25519:' ++ crypto.createHash('sha256').update(privateKey).digest('hex').slice(0, 32);++ return {+ signature: `ed25519:${signature}`,+ publicKey,+ };+ }++ /**+ * Get current author info+ */+ private getAuthor(): PatternAuthor {+ 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: CFPFormat, options: PublishOptions): string[] {+ const errors: string[] = [];++ // 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: CFPFormat, options: PublishOptions): object {+ 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 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 async function submitContribution(+ request: ContributionRequest+): Promise<{ success: boolean; submissionId: string; message: string }> {+ 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: string+): Promise<{+ status: 'pending' | 'reviewing' | 'approved' | 'rejected';+ message: string;+ reviewedAt?: string;+ reviewer?: string;+}> {+ // 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?: Partial<StoreConfig>): PatternPublisher {+ return new PatternPublisher(config);+}++/**+ * Quick publish helper+ */+export async function quickPublish(+ cfp: CFPFormat,+ name: string,+ description: string,+ tags: string[],+ config?: Partial<StoreConfig>+): Promise<PublishResult> {+ const publisher = new PatternPublisher(config);++ const options: PublishOptions = {+ 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);+}