monomind 1.11.13 → 1.12.0

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

@@ -3,6 +3,46 @@
  * Secure discovery mechanism for finding patterns in decentralized environment
  */
 import * as crypto from 'crypto';
+/** Maximum bytes read from any IPFS gateway response to prevent OOM */
+const MAX_DISCOVERY_RESPONSE_BYTES = 10 * 1024 * 1024; // 10 MB
+/**
+ * Read a fetch response body with a hard byte cap.
+ * Aborts the stream early if the limit is exceeded.
+ */
+async function readBodyCapped(response, maxBytes = MAX_DISCOVERY_RESPONSE_BYTES) {
+    const lengthHeader = response.headers.get('content-length');
+    if (lengthHeader) {
+        const declared = parseInt(lengthHeader, 10);
+        if (Number.isFinite(declared) && declared > maxBytes) {
+            throw new Error(`Response too large: ${declared} bytes (max ${maxBytes})`);
+        }
+    }
+    const reader = response.body?.getReader();
+    if (!reader)
+        return '';
+    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(`Response too large: exceeded ${maxBytes} bytes`);
+            }
+            chunks.push(value);
+        }
+    }
+    const combined = new Uint8Array(total);
+    let offset = 0;
+    for (const c of chunks) {
+        combined.set(c, offset);
+        offset += c.byteLength;
+    }
+    return new TextDecoder('utf-8').decode(combined);
+}
 import { DEFAULT_STORE_CONFIG, } from './registry.js';
 /**
  * Pattern Store Discovery Service
@@ -136,7 +176,8 @@ export class PatternDiscovery {
                     signal: AbortSignal.timeout(10000),
                 });
                 if (response.ok) {
-                    const data = await response.json();
+                    const text = await readBodyCapped(response, 64 * 1024); // IPNS resolve is tiny
+                    const data = JSON.parse(text);
                     const cid = data.Path?.replace('/ipfs/', '') || '';
                     if (cid) {
                         const resolution = {
@@ -226,7 +267,7 @@ export class PatternDiscovery {
                 signal: AbortSignal.timeout(30000),
             });
             if (response.ok) {
-                const text = await response.text();
+                const text = await readBodyCapped(response);
                 try {
                     const registry = JSON.parse(text);
                     console.log(`[Discovery] Fetched registry with ${registry.patterns?.length || 0} patterns`);
@@ -257,7 +298,8 @@ export class PatternDiscovery {
                     signal: AbortSignal.timeout(15000),
                 });
                 if (response.ok) {
-                    const registry = await response.json();
+                    const altText = await readBodyCapped(response);
+                    const registry = JSON.parse(altText);
                     console.log(`[Discovery] Fetched registry from ${altGateway}`);
                     return registry;
                 }

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

@@ -11,6 +11,7 @@ import { DEFAULT_STORE_CONFIG } from './registry.js';
  * Handles secure download and verification of patterns
  */
 const MAX_DOWNLOAD_CACHE = 500;
+const MAX_PATTERN_FILE_BYTES = 50 * 1024 * 1024; // 50 MB — matches client.ts MAX_IPFS_RESPONSE_BYTES
 const ALLOWED_GATEWAYS = new Set([
     'https://w3s.link',
     'https://dweb.link',
@@ -362,6 +363,10 @@ export class PatternDownloader {
     async importPattern(filePath, strategy = 'merge') {
         console.log(`[Download] Importing pattern with strategy: ${strategy}`);
         try {
+            if (fs.statSync(filePath).size > MAX_PATTERN_FILE_BYTES) {
+                console.error(`[Download] Pattern file exceeds size limit (${MAX_PATTERN_FILE_BYTES} bytes)`);
+                return false;
+            }
             const content = fs.readFileSync(filePath, 'utf-8');
             const cfp = JSON.parse(content);
             // In production: Import to local pattern store

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

@@ -137,13 +137,17 @@ export class PatternPublisher {
         }
         catch (error) {
             console.error(`[Publish] Failed:`, error);
+            // Sanitize error message: strip control chars and cap length to prevent
+            // internal paths / stack traces from leaking into CLI output or logs.
+            const rawMsg = error instanceof Error ? error.message : String(error);
+            const safeMsg = rawMsg.replace(/[\x00-\x1f\x7f]/g, '?').slice(0, 256);
             return {
                 success: false,
                 patternId: '',
                 cid: '',
                 registryCid: '',
                 gatewayUrl: '',
-                message: `Publish failed: ${error}`,
+                message: `Publish failed: ${safeMsg}`,
             };
         }
     }
@@ -152,6 +156,14 @@ export class PatternPublisher {
      */
     async signContent(content, privateKeyPath) {
         const ed = await import('@noble/ed25519');
+        // Guard: cap key file size to prevent OOM on oversized or malicious files.
+        // A valid 32-byte Ed25519 seed encoded as hex is 64 chars; even with a
+        // newline and BOM the file should never exceed a few hundred bytes.
+        const MAX_KEY_FILE_BYTES = 4 * 1024; // 4 KB — generous upper bound
+        const keyFileStat = fs.statSync(privateKeyPath);
+        if (keyFileStat.size > MAX_KEY_FILE_BYTES) {
+            throw new Error(`Private key file exceeds size limit (${MAX_KEY_FILE_BYTES} bytes)`);
+        }
         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

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

@@ -37,6 +37,14 @@ export declare function removePatternFromRegistry(registry: PatternRegistry, pat
 export declare function serializeRegistry(registry: PatternRegistry): string;
 /**
  * Deserialize registry from JSON
+ *
+ * Caps the input string length before parsing to prevent OOM on a malicious or
+ * oversized registry fetched from IPFS / Pinata. The in-flight body is already
+ * capped by readBodyWithLimit (50 MB), but deserializeRegistry is also called
+ * with locally-cached data, so we add a 10 MB guard here too.
+ *
+ * We also reject non-semver and suspiciously long version strings to prevent
+ * version fields being used as a side-channel for large-payload injection.
  */
 export declare function deserializeRegistry(json: string): PatternRegistry;
 /**

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

@@ -206,12 +206,26 @@ export function serializeRegistry(registry) {
 }
 /**
  * Deserialize registry from JSON
+ *
+ * Caps the input string length before parsing to prevent OOM on a malicious or
+ * oversized registry fetched from IPFS / Pinata. The in-flight body is already
+ * capped by readBodyWithLimit (50 MB), but deserializeRegistry is also called
+ * with locally-cached data, so we add a 10 MB guard here too.
+ *
+ * We also reject non-semver and suspiciously long version strings to prevent
+ * version fields being used as a side-channel for large-payload injection.
  */
 export function deserializeRegistry(json) {
+    const MAX_JSON_BYTES = 10 * 1024 * 1024; // 10 MB
+    if (typeof json !== 'string' || json.length > MAX_JSON_BYTES) {
+        throw new Error(`Registry JSON too large: ${typeof json === 'string' ? json.length : typeof json} bytes (max ${MAX_JSON_BYTES})`);
+    }
     const registry = JSON.parse(json);
-    // Validate version
-    if (!registry.version) {
-        throw new Error('Invalid registry: missing version');
+    // Validate version — must be a non-empty semver-like string (e.g. "1.0.0").
+    if (!registry.version || typeof registry.version !== 'string'
+        || registry.version.length > 32
+        || !/^\d+\.\d+\.\d+/.test(registry.version)) {
+        throw new Error('Invalid registry: missing or malformed version');
     }
     return registry;
 }
@@ -266,9 +280,16 @@ export async function verifyRegistrySignature(registry) {
  */
 export function mergeRegistries(local, remote) {
     const merged = createRegistry(local.ipnsName);
+    // Cap combined input sizes to prevent OOM when merging a large remote registry.
+    // A remote registry fetched from IPFS could contain hundreds of thousands of
+    // entries; without a hard cap, patternMap grows unboundedly in memory.
+    const MAX_MERGE_PATTERNS = 10_000;
+    const MAX_MERGE_AUTHORS = 1_000;
     // Combine patterns, preferring newer versions
     const patternMap = new Map();
     for (const pattern of [...local.patterns, ...remote.patterns]) {
+        if (patternMap.size >= MAX_MERGE_PATTERNS && !patternMap.has(pattern.name))
+            continue;
         const existing = patternMap.get(pattern.name);
         if (!existing || new Date(pattern.lastUpdated) > new Date(existing.lastUpdated)) {
             patternMap.set(pattern.name, pattern);
@@ -278,6 +299,8 @@ export function mergeRegistries(local, remote) {
     // Combine authors
     const authorMap = new Map();
     for (const author of [...local.authors, ...remote.authors]) {
+        if (authorMap.size >= MAX_MERGE_AUTHORS && !authorMap.has(author.id))
+            continue;
         const existing = authorMap.get(author.id);
         if (!existing || author.patterns > existing.patterns) {
             authorMap.set(author.id, author);
@@ -294,8 +317,10 @@ export function mergeRegistries(local, remote) {
  * Generate pattern ID from name
  */
 export function generatePatternId(name) {
-    const normalized = name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
-    const hash = crypto.createHash('sha256').update(name + Date.now()).digest('hex').slice(0, 8);
+    // Cap name before normalizing to prevent OOM from an extremely long input string
+    const safeName = typeof name === 'string' ? name.slice(0, 128) : '';
+    const normalized = safeName.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+    const hash = crypto.createHash('sha256').update(safeName + Date.now()).digest('hex').slice(0, 8);
     return `${normalized}-${hash}`;
 }
 //# sourceMappingURL=registry.js.map

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

@@ -2,6 +2,16 @@
  * Pattern Search Service
  * Search and filter patterns from decentralized registry
  */
+/** Maximum query string length to prevent O(n*m) regex/includes DoS */
+const MAX_QUERY_LEN = 256;
+/** Hard cap on page size to prevent huge slice allocations */
+const MAX_PAGE_LIMIT = 200;
+/** Hard cap on offset to prevent absurdly large slice calculations */
+const MAX_OFFSET = 10_000;
+/** Hard cap on suggestion partial string length */
+const MAX_PARTIAL_LEN = 128;
+/** Hard cap on similar-pattern limit */
+const MAX_SIMILAR_LIMIT = 50;
 /**
  * Search patterns in registry
  */
@@ -9,7 +19,7 @@ export function searchPatterns(registry, options = {}) {
     let patterns = [...registry.patterns];
     // Text search
     if (options.query) {
-        const query = options.query.toLowerCase();
+        const query = String(options.query).slice(0, MAX_QUERY_LEN).toLowerCase();
         patterns = patterns.filter(p => p.name.toLowerCase().includes(query) ||
             p.displayName.toLowerCase().includes(query) ||
             p.description.toLowerCase().includes(query) ||
@@ -77,10 +87,12 @@ export function searchPatterns(registry, options = {}) {
         }
         return sortOrder === 'desc' ? -comparison : comparison;
     });
-    // Pagination
+    // Pagination — cap limit and offset to prevent huge slice allocations
     const total = patterns.length;
-    const limit = options.limit || 20;
-    const offset = options.offset || 0;
+    const rawLimit = typeof options.limit === 'number' && Number.isFinite(options.limit) ? options.limit : 20;
+    const limit = Math.min(Math.max(1, Math.floor(rawLimit)), MAX_PAGE_LIMIT);
+    const rawOffset = typeof options.offset === 'number' && Number.isFinite(options.offset) ? options.offset : 0;
+    const offset = Math.min(Math.max(0, Math.floor(rawOffset)), MAX_OFFSET);
     const page = Math.floor(offset / limit) + 1;
     patterns = patterns.slice(offset, offset + limit);
     return {
@@ -144,6 +156,7 @@ export function getPatternsByCategory(registry, categoryId) {
  * Get similar patterns (by tags and category)
  */
 export function getSimilarPatterns(registry, pattern, limit = 5) {
+    limit = Math.min(Math.max(1, Math.floor(limit)), MAX_SIMILAR_LIMIT);
     const scores = new Map();
     for (const p of registry.patterns) {
         if (p.id === pattern.id)
@@ -203,7 +216,9 @@ export function getTagCloud(registry) {
  */
 export function getSearchSuggestions(registry, partial, limit = 10) {
     const suggestions = new Set();
-    const query = partial.toLowerCase();
+    // Cap partial length to prevent O(n*m) DoS via enormous query strings
+    const query = String(partial).slice(0, MAX_PARTIAL_LEN).toLowerCase();
+    limit = Math.min(Math.max(1, Math.floor(limit)), MAX_SIMILAR_LIMIT);
     // Add matching pattern names
     for (const pattern of registry.patterns) {
         if (pattern.name.toLowerCase().includes(query)) {

package/packages/@monomind/cli/dist/src/transfer/store/tests/standalone-test.d.ts

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

package/packages/@monomind/cli/dist/src/transfer/store/tests/standalone-test.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env npx tsx
+/**
+ * Standalone Pattern Store Test
+ * Run this in any environment to verify the IPFS-based pattern store works
+ *
+ * Usage:
+ *   npx tsx standalone-test.ts
+ *   # or
+ *   npm run test:pattern-store
+ */
+import { PatternStore, createDiscoveryService, searchPatterns, getFeaturedPatterns, getTrendingPatterns, getNewestPatterns, getCategoryStats, getTagCloud, getSearchSuggestions, } from '../index.js';
+async function main() {
+    console.log('');
+    console.log('╔══════════════════════════════════════════════════════════════╗');
+    console.log('║  MONOMIND - STANDALONE PATTERN STORE TEST                   ║');
+    console.log('║  IPFS-Based Decentralized Pattern 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 = createDiscoveryService();
+        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 = createDiscoveryService();
+        const result = await discovery.discoverRegistry();
+        if (result.success && result.registry) {
+            registry = result.registry;
+            console.log(`  ✅ Discovered ${result.registry.patterns.length} patterns 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 Patterns
+    console.log('▶ Test 3: Search for "agent"');
+    try {
+        const results = searchPatterns(registry, { query: 'agent' });
+        console.log(`  ✅ Found ${results.patterns.length} patterns matching "agent"`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 4: Get Featured Patterns
+    console.log('▶ Test 4: Get Featured Patterns');
+    try {
+        const featured = getFeaturedPatterns(registry);
+        console.log(`  ✅ Found ${featured.length} featured patterns`);
+        if (featured.length > 0) {
+            console.log(`     - ${featured[0].name} (${featured[0].id})`);
+        }
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 5: Get Trending Patterns
+    console.log('▶ Test 5: Get Trending Patterns');
+    try {
+        const trending = getTrendingPatterns(registry);
+        console.log(`  ✅ Found ${trending.length} trending patterns`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 6: Get Newest Patterns
+    console.log('▶ Test 6: Get Newest Patterns');
+    try {
+        const newest = getNewestPatterns(registry);
+        console.log(`  ✅ Found ${newest.length} newest patterns`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 7: Search with Filters
+    console.log('▶ Test 7: Search with Filters (verified only)');
+    try {
+        const results = searchPatterns(registry, { verified: true });
+        console.log(`  ✅ Found ${results.patterns.length} verified patterns`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 8: Category Stats
+    console.log('▶ Test 8: Get Category Statistics');
+    try {
+        const stats = getCategoryStats(registry);
+        const count = Array.isArray(stats) ? stats.length : Object.keys(stats).length;
+        console.log(`  ✅ Found ${count} categories with stats`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 9: Tag Cloud
+    console.log('▶ Test 9: Get Tag Cloud');
+    try {
+        const tags = getTagCloud(registry);
+        console.log(`  ✅ Found ${tags.size} unique tags`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 10: Search Suggestions
+    console.log('▶ Test 10: Get Search Suggestions');
+    try {
+        const suggestions = getSearchSuggestions(registry, 'pat');
+        console.log(`  ✅ Got ${suggestions.length} suggestions for "pat"`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 11: PatternStore Class
+    console.log('▶ Test 11: PatternStore Class API');
+    try {
+        const store = new PatternStore();
+        await store.initialize();
+        const stats = store.getStats();
+        console.log(`  ✅ PatternStore initialized:`);
+        console.log(`     Total Patterns: ${stats.totalPatterns}`);
+        console.log(`     Total Downloads: ${stats.totalDownloads.toLocaleString()}`);
+        console.log(`     Categories: ${stats.categories}`);
+        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! Pattern Store is working correctly.');
+        console.log('');
+        console.log('  Available CLI Commands:');
+        console.log('    npx @monoes/cli patterns list');
+        console.log('    npx @monoes/cli patterns list --featured');
+        console.log('    npx @monoes/cli patterns search -q "agent"');
+        console.log('    npx @monoes/cli patterns info -n <pattern-id>');
+        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/packages/@monomind/cli/dist/src/transfer/test-seraphine.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Test Seraphine Genesis Model
+ * Quick validation of the transfer pipeline
+ */
+export {};
+//# sourceMappingURL=test-seraphine.d.ts.map

package/packages/@monomind/cli/dist/src/transfer/test-seraphine.js

@@ -0,0 +1,105 @@
+/**
+ * Test Seraphine Genesis Model
+ * Quick validation of the transfer pipeline
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Simple test without complex imports
+async function test() {
+    console.log('');
+    console.log('╔══════════════════════════════════════════════════════════╗');
+    console.log('║           SERAPHINE GENESIS TEST SUITE                    ║');
+    console.log('╚══════════════════════════════════════════════════════════╝');
+    console.log('');
+    let passed = 0;
+    let failed = 0;
+    // Test 1: Types file exists
+    const typesPath = path.join(__dirname, 'types.ts');
+    if (fs.existsSync(typesPath)) {
+        console.log('✅ Test 1: Types module exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 1: Types module missing');
+        failed++;
+    }
+    // Test 2: Seraphine model exists
+    const seraphPath = path.join(__dirname, 'models', 'seraphine.ts');
+    if (fs.existsSync(seraphPath)) {
+        console.log('✅ Test 2: Seraphine model exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 2: Seraphine model missing');
+        failed++;
+    }
+    // Test 3: CFP serializer exists
+    const cfpPath = path.join(__dirname, 'serialization', 'cfp.ts');
+    if (fs.existsSync(cfpPath)) {
+        console.log('✅ Test 3: CFP serializer exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 3: CFP serializer missing');
+        failed++;
+    }
+    // Test 4: Anonymization module exists
+    const anonPath = path.join(__dirname, 'anonymization', 'index.ts');
+    if (fs.existsSync(anonPath)) {
+        console.log('✅ Test 4: Anonymization module exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 4: Anonymization module missing');
+        failed++;
+    }
+    // Test 5: IPFS upload module exists
+    const ipfsPath = path.join(__dirname, 'ipfs', 'upload.ts');
+    if (fs.existsSync(ipfsPath)) {
+        console.log('✅ Test 5: IPFS upload module exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 5: IPFS upload module missing');
+        failed++;
+    }
+    // Test 6: Export module exists
+    const exportPath = path.join(__dirname, 'export.ts');
+    if (fs.existsSync(exportPath)) {
+        console.log('✅ Test 6: Export module exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 6: Export module missing');
+        failed++;
+    }
+    // Test 7: Index module exists
+    const indexPath = path.join(__dirname, 'index.ts');
+    if (fs.existsSync(indexPath)) {
+        console.log('✅ Test 7: Index module exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 7: Index module missing');
+        failed++;
+    }
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════');
+    console.log(`   Results: ${passed} passed, ${failed} failed`);
+    console.log('═══════════════════════════════════════════════════════════');
+    console.log('');
+    if (failed === 0) {
+        console.log('🎉 All module tests passed!');
+        console.log('');
+        console.log('Next steps:');
+        console.log('  1. Compile TypeScript: cd packages/@monoes/cli && npm run build');
+        console.log('  2. Run deployment: npx ts-node src/transfer/deploy-seraphine.ts --to-ipfs');
+        console.log('');
+    }
+    process.exit(failed > 0 ? 1 : 0);
+}
+test().catch(console.error);
+//# sourceMappingURL=test-seraphine.js.map

package/packages/@monomind/cli/dist/src/transfer/tests/test-store.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env npx tsx
+/**
+ * Pattern Store Test Suite
+ * Tests list, search, download, and publish functionality
+ */
+export {};
+//# sourceMappingURL=test-store.d.ts.map