+4

.tangled/workflows/deploy-wisp.yml

··· 30 30 - name: Build wisp-cli 31 31 command: | 32 32 cd cli 33 33 + 34 34 + export PATH="$HOME/.nix-profile/bin:$PATH" 35 35 + 33 36 nix-channel --add https://nixos.org/channels/nixpkgs-unstable nixpkgs 34 37 35 38 nix-channel --update ··· 46 49 - name: Build docs 47 50 command: | 48 51 cd docs 52 52 + export PATH="$HOME/.nix-profile/bin:$PATH" 49 53 bun install 50 54 bun run build 51 55 - name: Deploy to Wisp.place

+23

apps/hosting-service/src/lib/file-serving.ts

··· 550 550 const rewrittenKey = getCacheKey(did, rkey, fileRequestPath, `rewritten:${basePath}`); 551 551 const rewrittenContent = rewrittenHtmlCache.get(rewrittenKey); 552 552 if (rewrittenContent) { 553 553 + console.log(`[HTML Rewrite] Serving from rewritten cache: ${rewrittenKey}`); 553 554 const headers: Record<string, string> = { 554 555 'Content-Type': 'text/html; charset=utf-8', 555 556 'Content-Encoding': 'gzip', ··· 569 570 const meta = result.metadata.customMetadata as { encoding?: string; mimeType?: string } | undefined; 570 571 const mimeType = meta?.mimeType || lookup(fileRequestPath) || 'application/octet-stream'; 571 572 const isGzipped = meta?.encoding === 'gzip'; 573 573 + 574 574 + console.log(`[File Serve] Serving ${fileRequestPath}, mimeType: ${mimeType}, isHTML: ${isHtmlContent(fileRequestPath, mimeType)}, basePath: ${basePath}`); 572 575 573 576 // Check if this is HTML content that needs rewriting 574 577 if (isHtmlContent(fileRequestPath, mimeType)) { 578 578 + console.log(`[HTML Rewrite] Processing ${fileRequestPath}, basePath: ${basePath}, mimeType: ${mimeType}, isGzipped: ${isGzipped}`); 575 579 let htmlContent: string; 576 580 if (isGzipped) { 577 581 // Verify content is actually gzipped ··· 586 590 } else { 587 591 htmlContent = content.toString('utf-8'); 588 592 } 593 593 + // Check for <base> tag which can override paths 594 594 + const baseTagMatch = htmlContent.match(/<base\s+[^>]*href=["'][^"']+["'][^>]*>/i); 595 595 + if (baseTagMatch) { 596 596 + console.warn(`[HTML Rewrite] WARNING: <base> tag found: ${baseTagMatch[0]} - this may override path rewrites`); 597 597 + } 598 598 + 599 599 + // Find src/href attributes (quoted and unquoted) to debug 600 600 + const allMatches = htmlContent.match(/(?:src|href)\s*=\s*["']?\/[^"'\s>]+/g); 601 601 + console.log(`[HTML Rewrite] Found ${allMatches ? allMatches.length : 0} local path attrs`); 602 602 + if (allMatches && allMatches.length > 0) { 603 603 + console.log(`[HTML Rewrite] Sample paths: ${allMatches.slice(0, 5).join(', ')}`); 604 604 + } 605 605 + 589 606 const rewritten = rewriteHtmlPaths(htmlContent, basePath, fileRequestPath); 607 607 + 608 608 + const rewrittenMatches = rewritten.match(/(?:src|href)\s*=\s*["']?\/[^"'\s>]+/g); 609 609 + console.log(`[HTML Rewrite] After rewrite, found ${rewrittenMatches ? rewrittenMatches.length : 0} local paths`); 610 610 + if (rewrittenMatches && rewrittenMatches.length > 0) { 611 611 + console.log(`[HTML Rewrite] Sample rewritten: ${rewrittenMatches.slice(0, 5).join(', ')}`); 612 612 + } 590 613 591 614 // Recompress and cache the rewritten HTML 592 615 const { gzipSync } = await import('zlib');

+16

apps/hosting-service/src/lib/html-rewriter.ts

··· 189 189 `\\b${attr}[ \\t]{0,5}=[ \\t]{0,5}'([^']*)'`, 190 190 'gi' 191 191 ) 192 192 + // Unquoted attributes (valid in HTML5 for values without spaces/special chars) 193 193 + // Match: attr=value where value starts immediately (no quotes) and continues until space or > 194 194 + // Use negative lookahead to ensure we don't match quoted attributes 195 195 + const unquotedRegex = new RegExp( 196 196 + `\\b${attr}[ \\t]{0,5}=[ \\t]{0,5}(?!["'])([^\\s>]+)`, 197 197 + 'gi' 198 198 + ) 192 199 193 200 rewritten = rewritten.replace(doubleQuoteRegex, (match, value) => { 194 201 const rewrittenValue = rewritePath( ··· 206 213 documentPath 207 214 ) 208 215 return `${attr}='${rewrittenValue}'` 216 216 + }) 217 217 + 218 218 + rewritten = rewritten.replace(unquotedRegex, (match, value) => { 219 219 + const rewrittenValue = rewritePath( 220 220 + value, 221 221 + normalizedBase, 222 222 + documentPath 223 223 + ) 224 224 + return `${attr}=${rewrittenValue}` 209 225 }) 210 226 } 211 227 }

+94 -2

apps/hosting-service/src/lib/storage.ts

··· 7 7 * - Cold (S3/R2): Object storage as source of truth (optional) 8 8 * 9 9 * When S3 is not configured, falls back to disk-only mode (warm tier acts as source of truth). 10 10 + * In cache-only mode (non-master nodes), S3 writes are skipped even if configured. 10 11 */ 11 12 12 13 import { ··· 15 16 DiskStorageTier, 16 17 S3StorageTier, 17 18 type StorageTier, 19 19 + type StorageMetadata, 18 20 } from 'tiered-storage'; 19 21 20 22 const CACHE_DIR = process.env.CACHE_DIR || './cache/sites'; ··· 22 24 const HOT_CACHE_COUNT = parseInt(process.env.HOT_CACHE_COUNT || '500', 10); 23 25 const WARM_CACHE_SIZE = parseInt(process.env.WARM_CACHE_SIZE || '10737418240', 10); // 10GB default 24 26 const WARM_EVICTION_POLICY = (process.env.WARM_EVICTION_POLICY || 'lru') as 'lru' | 'fifo' | 'size'; 27 27 + 28 28 + // Cache-only mode: skip S3 writes (non-master nodes) 29 29 + // This is the same flag used to skip database writes 30 30 + const CACHE_ONLY_MODE = process.env.CACHE_ONLY_MODE === 'true'; 25 31 26 32 // S3/Cold tier configuration (optional) 27 33 const S3_BUCKET = process.env.S3_BUCKET || ''; ··· 49 55 }; 50 56 51 57 /** 58 58 + * Read-only wrapper for S3 tier in cache-only mode. 59 59 + * Allows reads from S3 but skips all writes (for non-master nodes). 60 60 + */ 61 61 + class ReadOnlyS3Tier implements StorageTier { 62 62 + private static hasLoggedWriteSkip = false; 63 63 + 64 64 + constructor(private tier: StorageTier) {} 65 65 + 66 66 + // Read operations - pass through to underlying tier 67 67 + async get(key: string) { 68 68 + return this.tier.get(key); 69 69 + } 70 70 + 71 71 + async getWithMetadata(key: string) { 72 72 + return this.tier.getWithMetadata?.(key) ?? null; 73 73 + } 74 74 + 75 75 + async getStream(key: string) { 76 76 + return this.tier.getStream?.(key) ?? null; 77 77 + } 78 78 + 79 79 + async exists(key: string) { 80 80 + return this.tier.exists(key); 81 81 + } 82 82 + 83 83 + async getMetadata(key: string) { 84 84 + return this.tier.getMetadata(key); 85 85 + } 86 86 + 87 87 + async *listKeys(prefix?: string) { 88 88 + yield* this.tier.listKeys(prefix); 89 89 + } 90 90 + 91 91 + async getStats() { 92 92 + return this.tier.getStats(); 93 93 + } 94 94 + 95 95 + // Write operations - no-op in cache-only mode 96 96 + async set(key: string, _data: Uint8Array, _metadata: StorageMetadata) { 97 97 + this.logWriteSkip('set', key); 98 98 + } 99 99 + 100 100 + async setStream(key: string, _stream: NodeJS.ReadableStream, _metadata: StorageMetadata) { 101 101 + this.logWriteSkip('setStream', key); 102 102 + } 103 103 + 104 104 + async setMetadata(key: string, _metadata: StorageMetadata) { 105 105 + this.logWriteSkip('setMetadata', key); 106 106 + } 107 107 + 108 108 + async delete(key: string) { 109 109 + this.logWriteSkip('delete', key); 110 110 + } 111 111 + 112 112 + async deleteMany(keys: string[]) { 113 113 + this.logWriteSkip('deleteMany', `${keys.length} keys`); 114 114 + } 115 115 + 116 116 + async clear() { 117 117 + this.logWriteSkip('clear', 'all keys'); 118 118 + } 119 119 + 120 120 + private logWriteSkip(operation: string, key: string) { 121 121 + // Only log once to avoid spam 122 122 + if (!ReadOnlyS3Tier.hasLoggedWriteSkip) { 123 123 + console.log(`[Storage] Cache-only mode: skipping S3 writes (operation: ${operation})`); 124 124 + ReadOnlyS3Tier.hasLoggedWriteSkip = true; 125 125 + } 126 126 + } 127 127 + } 128 128 + 129 129 + /** 52 130 * Initialize tiered storage 53 131 * Must be called before serving requests 54 132 */ ··· 66 144 67 145 if (S3_BUCKET) { 68 146 // Full three-tier setup with S3 as cold storage 69 69 - coldTier = new S3StorageTier({ 147 147 + const s3Tier = new S3StorageTier({ 70 148 bucket: S3_BUCKET, 71 149 metadataBucket: S3_METADATA_BUCKET, 72 150 region: S3_REGION, ··· 78 156 : undefined, 79 157 prefix: S3_PREFIX, 80 158 }); 159 159 + 160 160 + // In cache-only mode, wrap S3 tier to make it read-only 161 161 + coldTier = CACHE_ONLY_MODE ? new ReadOnlyS3Tier(s3Tier) : s3Tier; 81 162 warmTier = diskTier; 82 82 - console.log('[Storage] Using S3 as cold tier, disk as warm tier'); 163 163 + 164 164 + if (CACHE_ONLY_MODE) { 165 165 + console.log('[Storage] Cache-only mode: S3 as read-only cold tier (no writes), disk as warm tier'); 166 166 + } else { 167 167 + console.log('[Storage] Using S3 as cold tier, disk as warm tier'); 168 168 + } 83 169 } else { 84 170 // Disk-only mode: disk tier acts as source of truth (cold) 85 171 coldTier = diskTier; ··· 104 190 105 191 // Placement rules: determine which tiers each file goes to 106 192 placementRules: [ 193 193 + // Metadata is critical: frequently accessed for cache validity checks 194 194 + { 195 195 + pattern: '**/.metadata.json', 196 196 + tiers: ['hot', 'warm', 'cold'], 197 197 + }, 198 198 + 107 199 // index.html is critical: write to all tiers for instant serving 108 200 { 109 201 pattern: '**/index.html',

+44 -141

apps/hosting-service/src/lib/utils.ts

··· 397 397 const existingMetadata = await getCacheMetadata(did, rkey); 398 398 const existingFileCids = existingMetadata?.fileCids || {}; 399 399 400 400 - // Use a temporary directory with timestamp to avoid collisions 401 401 - const tempSuffix = `.tmp-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`; 402 402 - const tempDir = `${CACHE_DIR}/${did}/${rkey}${tempSuffix}`; 403 403 - const finalDir = `${CACHE_DIR}/${did}/${rkey}`; 404 404 - 405 405 - try { 406 406 - // Collect file CIDs from the new record (using expanded root) 407 407 - const newFileCids: Record<string, string> = {}; 408 408 - collectFileCidsFromEntries(expandedRoot.entries, '', newFileCids); 400 400 + // Collect file CIDs from the new record (using expanded root) 401 401 + const newFileCids: Record<string, string> = {}; 402 402 + collectFileCidsFromEntries(expandedRoot.entries, '', newFileCids); 409 403 410 410 - // Fetch site settings (optional) 411 411 - const settings = await fetchSiteSettings(did, rkey); 404 404 + // Fetch site settings (optional) 405 405 + const settings = await fetchSiteSettings(did, rkey); 412 406 413 413 - // Download/copy files to temporary directory (with incremental logic, using expanded root) 414 414 - await cacheFiles(did, rkey, expandedRoot.entries, pdsEndpoint, '', tempSuffix, existingFileCids, finalDir); 415 415 - await saveCacheMetadata(did, rkey, recordCid, tempSuffix, newFileCids, settings); 407 407 + // Download files directly to tiered storage (with incremental logic) 408 408 + await cacheFiles(did, rkey, expandedRoot.entries, pdsEndpoint, '', existingFileCids); 409 409 + await saveCacheMetadata(did, rkey, recordCid, newFileCids, settings); 416 410 417 417 - // Atomically replace old cache with new cache 418 418 - // On POSIX systems (Linux/macOS), rename is atomic 419 419 - if (existsSync(finalDir)) { 420 420 - // Rename old directory to backup 421 421 - const backupDir = `${finalDir}.old-${Date.now()}`; 422 422 - await rename(finalDir, backupDir); 423 423 - 424 424 - try { 425 425 - // Rename new directory to final location 426 426 - await rename(tempDir, finalDir); 427 427 - 428 428 - // Clean up old backup 429 429 - rmSync(backupDir, { recursive: true, force: true }); 430 430 - } catch (err) { 431 431 - // If rename failed, restore backup 432 432 - if (existsSync(backupDir) && !existsSync(finalDir)) { 433 433 - await rename(backupDir, finalDir); 434 434 - } 435 435 - throw err; 436 436 - } 437 437 - } else { 438 438 - // No existing cache, just rename temp to final 439 439 - await rename(tempDir, finalDir); 440 440 - } 441 441 - 442 442 - console.log('Successfully cached site atomically', did, rkey); 443 443 - } catch (err) { 444 444 - // Clean up temp directory on failure 445 445 - if (existsSync(tempDir)) { 446 446 - rmSync(tempDir, { recursive: true, force: true }); 447 447 - } 448 448 - throw err; 449 449 - } 411 411 + console.log('Successfully cached site', did, rkey); 450 412 } 451 413 452 414 ··· 456 418 entries: Entry[], 457 419 pdsEndpoint: string, 458 420 pathPrefix: string, 459 459 - dirSuffix: string = '', 460 460 - existingFileCids: Record<string, string> = {}, 461 461 - existingCacheDir?: string 421 421 + existingFileCids: Record<string, string> = {} 462 422 ): Promise<void> { 463 463 - // Collect file tasks, separating unchanged files from new/changed files 423 423 + // Collect file download tasks (skip unchanged files) 464 424 const downloadTasks: Array<() => Promise<void>> = []; 465 465 - const copyTasks: Array<() => Promise<void>> = []; 466 425 467 426 function collectFileTasks( 468 427 entries: Entry[], ··· 479 438 const cid = extractBlobCid(fileNode.blob); 480 439 481 440 // Check if file is unchanged (same CID as existing cache) 482 482 - if (cid && existingFileCids[currentPath] === cid && existingCacheDir) { 483 483 - // File unchanged - copy from existing cache instead of downloading 484 484 - copyTasks.push(() => copyExistingFile( 485 485 - did, 486 486 - site, 487 487 - currentPath, 488 488 - dirSuffix, 489 489 - existingCacheDir 490 490 - )); 441 441 + if (cid && existingFileCids[currentPath] === cid) { 442 442 + // File unchanged - skip download (already in tiered storage) 443 443 + console.log(`Skipping unchanged file: ${currentPath}`); 491 444 } else { 492 445 // File new or changed - download it 493 446 downloadTasks.push(() => cacheFileBlob( ··· 498 451 pdsEndpoint, 499 452 fileNode.encoding, 500 453 fileNode.mimeType, 501 501 - fileNode.base64, 502 502 - dirSuffix 454 454 + fileNode.base64 503 455 )); 504 456 } 505 457 } ··· 508 460 509 461 collectFileTasks(entries, pathPrefix); 510 462 511 511 - console.log(`[Incremental Update] Files to copy: ${copyTasks.length}, Files to download: ${downloadTasks.length}`); 463 463 + console.log(`[Incremental Update] Files to download: ${downloadTasks.length}`); 512 464 513 513 - // Copy unchanged files in parallel (fast local operations) - increased limit for better performance 514 514 - const copyLimit = 50; 515 515 - for (let i = 0; i < copyTasks.length; i += copyLimit) { 516 516 - const batch = copyTasks.slice(i, i + copyLimit); 517 517 - await Promise.all(batch.map(task => task())); 518 518 - if (copyTasks.length > copyLimit) { 519 519 - console.log(`[Cache Progress] Copied ${Math.min(i + copyLimit, copyTasks.length)}/${copyTasks.length} unchanged files`); 520 520 - } 521 521 - } 522 522 - 523 523 - // Download new/changed files concurrently - increased from 3 to 20 for much better performance 465 465 + // Download new/changed files concurrently 524 466 const downloadLimit = 20; 525 467 let successCount = 0; 526 468 let failureCount = 0; ··· 549 491 } 550 492 } 551 493 552 552 - /** 553 553 - * Copy an unchanged file from existing cache to new cache location 554 554 - */ 555 555 - async function copyExistingFile( 556 556 - did: string, 557 557 - site: string, 558 558 - filePath: string, 559 559 - dirSuffix: string, 560 560 - existingCacheDir: string 561 561 - ): Promise<void> { 562 562 - const { copyFile } = await import('fs/promises'); 563 563 - 564 564 - const sourceFile = `${existingCacheDir}/${filePath}`; 565 565 - const destFile = `${CACHE_DIR}/${did}/${site}${dirSuffix}/${filePath}`; 566 566 - const destDir = destFile.substring(0, destFile.lastIndexOf('/')); 567 567 - 568 568 - // Create destination directory if needed 569 569 - if (destDir && !existsSync(destDir)) { 570 570 - mkdirSync(destDir, { recursive: true }); 571 571 - } 572 572 - 573 573 - try { 574 574 - // Copy the file 575 575 - await copyFile(sourceFile, destFile); 576 576 - 577 577 - // Copy metadata file if it exists 578 578 - const sourceMetaFile = `${sourceFile}.meta`; 579 579 - const destMetaFile = `${destFile}.meta`; 580 580 - if (existsSync(sourceMetaFile)) { 581 581 - await copyFile(sourceMetaFile, destMetaFile); 582 582 - } 583 583 - } catch (err) { 584 584 - console.error(`Failed to copy cached file ${filePath}, will attempt download:`, err); 585 585 - throw err; 586 586 - } 587 587 - } 588 588 - 589 494 async function cacheFileBlob( 590 495 did: string, 591 496 site: string, ··· 594 499 pdsEndpoint: string, 595 500 encoding?: 'gzip', 596 501 mimeType?: string, 597 597 - base64?: boolean, 598 598 - dirSuffix: string = '' 502 502 + base64?: boolean 599 503 ): Promise<void> { 600 504 const cid = extractBlobCid(blobRef); 601 505 if (!cid) { ··· 635 539 } 636 540 } 637 541 638 638 - // Write to tiered storage via streaming (warm + cold, skip hot on ingest) 639 639 - // Convert buffer to stream for large file support 542 542 + // Write to tiered storage with metadata 640 543 const stream = Readable.from([content]); 641 544 const key = `${did}/${site}/${filePath}`; 642 545 ··· 676 579 return await storage.exists(indexKey); 677 580 } 678 581 679 679 - async function saveCacheMetadata(did: string, rkey: string, recordCid: string, dirSuffix: string = '', fileCids?: Record<string, string>, settings?: WispSettings | null): Promise<void> { 582 582 + async function saveCacheMetadata(did: string, rkey: string, recordCid: string, fileCids?: Record<string, string>, settings?: WispSettings | null): Promise<void> { 680 583 const metadata: CacheMetadata = { 681 584 recordCid, 682 585 cachedAt: Date.now(), ··· 686 589 settings: settings || undefined 687 590 }; 688 591 689 689 - const metadataPath = `${CACHE_DIR}/${did}/${rkey}${dirSuffix}/.metadata.json`; 690 690 - const metadataDir = metadataPath.substring(0, metadataPath.lastIndexOf('/')); 691 691 - 692 692 - if (!existsSync(metadataDir)) { 693 693 - mkdirSync(metadataDir, { recursive: true }); 694 694 - } 695 695 - 696 696 - await writeFile(metadataPath, JSON.stringify(metadata, null, 2)); 592 592 + // Store through tiered storage for persistence to S3/cold tier 593 593 + const metadataKey = `${did}/${rkey}/.metadata.json`; 594 594 + const metadataBytes = new TextEncoder().encode(JSON.stringify(metadata, null, 2)); 595 595 + await storage.set(metadataKey, metadataBytes); 697 596 } 698 597 699 598 async function getCacheMetadata(did: string, rkey: string): Promise<CacheMetadata | null> { 700 599 try { 701 701 - const metadataPath = `${CACHE_DIR}/${did}/${rkey}/.metadata.json`; 702 702 - if (!existsSync(metadataPath)) return null; 600 600 + // Retrieve metadata from tiered storage 601 601 + const metadataKey = `${did}/${rkey}/.metadata.json`; 602 602 + const data = await storage.get(metadataKey); 603 603 + 604 604 + if (!data) return null; 703 605 704 704 - const content = await readFile(metadataPath, 'utf-8'); 705 705 - return JSON.parse(content) as CacheMetadata; 606 606 + // Deserialize from Uint8Array to JSON (storage uses identity serialization) 607 607 + const jsonString = new TextDecoder().decode(data as Uint8Array); 608 608 + return JSON.parse(jsonString) as CacheMetadata; 706 609 } catch (err) { 707 610 console.error('Failed to read cache metadata', err); 708 611 return null; ··· 736 639 } 737 640 738 641 export async function updateCacheMetadataSettings(did: string, rkey: string, settings: WispSettings | null): Promise<void> { 739 739 - const metadataPath = `${CACHE_DIR}/${did}/${rkey}/.metadata.json`; 642 642 + try { 643 643 + // Read existing metadata from tiered storage 644 644 + const metadata = await getCacheMetadata(did, rkey); 740 645 741 741 - if (!existsSync(metadataPath)) { 742 742 - console.warn('Metadata file does not exist, cannot update settings', { did, rkey }); 743 743 - return; 744 744 - } 745 745 - 746 746 - try { 747 747 - // Read existing metadata 748 748 - const content = await readFile(metadataPath, 'utf-8'); 749 749 - const metadata = JSON.parse(content) as CacheMetadata; 646 646 + if (!metadata) { 647 647 + console.warn('Metadata does not exist, cannot update settings', { did, rkey }); 648 648 + return; 649 649 + } 750 650 751 651 // Update settings field 752 652 // Store null explicitly to cache "no settings" state and avoid repeated fetches 753 653 metadata.settings = settings ?? null; 754 654 755 755 - // Write back to disk 756 756 - await writeFile(metadataPath, JSON.stringify(metadata, null, 2), 'utf-8'); 655 655 + // Write back through tiered storage 656 656 + // Convert to Uint8Array since storage is typed for binary data 657 657 + const metadataKey = `${did}/${rkey}/.metadata.json`; 658 658 + const metadataBytes = new TextEncoder().encode(JSON.stringify(metadata, null, 2)); 659 659 + await storage.set(metadataKey, metadataBytes); 757 660 console.log('Updated metadata settings', { did, rkey, hasSettings: !!settings }); 758 661 } catch (err) { 759 662 console.error('Failed to update metadata settings', err);

+3

apps/hosting-service/src/server.ts

··· 80 80 return c.text('Invalid identifier', 400); 81 81 } 82 82 83 83 + console.log(`[Server] sites.wisp.place request: identifier=${identifier}, site=${site}, filePath=${filePath}`); 84 84 + 83 85 // Check if site is currently being cached - return updating response early 84 86 if (isSiteBeingCached(did, site)) { 85 87 return siteUpdatingResponse(); ··· 93 95 94 96 // Serve with HTML path rewriting to handle absolute paths 95 97 const basePath = `/${identifier}/${site}/`; 98 98 + console.log(`[Server] Serving with basePath: ${basePath}`); 96 99 const headers = extractHeaders(c.req.raw.headers); 97 100 return serveFromCacheWithRewrite(did, site, filePath, basePath, c.req.url, headers); 98 101 }

+59

backup.nix

··· 1 1 + { 2 2 + inputs.nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable"; 3 3 + inputs.nci.url = "github:90-008/nix-cargo-integration"; 4 4 + inputs.nci.inputs.nixpkgs.follows = "nixpkgs"; 5 5 + inputs.parts.url = "github:hercules-ci/flake-parts"; 6 6 + inputs.parts.inputs.nixpkgs-lib.follows = "nixpkgs"; 7 7 + inputs.fenix = { 8 8 + url = "github:nix-community/fenix"; 9 9 + inputs.nixpkgs.follows = "nixpkgs"; 10 10 + }; 11 11 + 12 12 + outputs = inputs @ { 13 13 + parts, 14 14 + nci, 15 15 + ... 16 16 + }: 17 17 + parts.lib.mkFlake {inherit inputs;} { 18 18 + systems = ["x86_64-linux" "aarch64-darwin"]; 19 19 + imports = [ 20 20 + nci.flakeModule 21 21 + ./crates.nix 22 22 + ]; 23 23 + perSystem = { 24 24 + pkgs, 25 25 + config, 26 26 + ... 27 27 + }: let 28 28 + crateOutputs = config.nci.outputs."wisp-cli"; 29 29 + mkRenamedPackage = name: pkg: isWindows: pkgs.runCommand name {} '' 30 30 + mkdir -p $out/bin 31 31 + if [ -f ${pkg}/bin/wisp-cli.exe ]; then 32 32 + cp ${pkg}/bin/wisp-cli.exe $out/bin/${name} 33 33 + elif [ -f ${pkg}/bin/wisp-cli ]; then 34 34 + cp ${pkg}/bin/wisp-cli $out/bin/${name} 35 35 + else 36 36 + echo "Error: Could not find wisp-cli binary in ${pkg}/bin/" 37 37 + ls -la ${pkg}/bin/ || true 38 38 + exit 1 39 39 + fi 40 40 + ''; 41 41 + in { 42 42 + devShells.default = crateOutputs.devShell; 43 43 + packages.default = crateOutputs.packages.release; 44 44 + packages.wisp-cli-x86_64-linux = mkRenamedPackage "wisp-cli-x86_64-linux" crateOutputs.packages.release false; 45 45 + packages.wisp-cli-aarch64-linux = mkRenamedPackage "wisp-cli-aarch64-linux" crateOutputs.allTargets."aarch64-unknown-linux-gnu".packages.release false; 46 46 + packages.wisp-cli-x86_64-windows = mkRenamedPackage "wisp-cli-x86_64-windows.exe" crateOutputs.allTargets."x86_64-pc-windows-gnu".packages.release true; 47 47 + packages.wisp-cli-aarch64-darwin = mkRenamedPackage "wisp-cli-aarch64-darwin" crateOutputs.allTargets."aarch64-apple-darwin".packages.release false; 48 48 + packages.all = pkgs.symlinkJoin { 49 49 + name = "wisp-cli-all"; 50 50 + paths = [ 51 51 + config.packages.wisp-cli-x86_64-linux 52 52 + config.packages.wisp-cli-aarch64-linux 53 53 + config.packages.wisp-cli-x86_64-windows 54 54 + config.packages.wisp-cli-aarch64-darwin 55 55 + ]; 56 56 + }; 57 57 + }; 58 58 + }; 59 59 + }

+13 -3

cli/default.nix

··· 1 1 - {rustPlatform}: 1 1 + { 2 2 + rustPlatform, 3 3 + glibc, 4 4 + }: 2 5 rustPlatform.buildRustPackage { 3 3 - name = "rust-cross-test"; 6 6 + name = "wisp-cli"; 4 7 src = ./.; 5 5 - cargoLock.lockFile = ./Cargo.lock; 8 8 + cargoLock = { 9 9 + lockFile = ./Cargo.lock; 10 10 + outputHashes = { 11 11 + "jacquard-0.9.5" = "sha256-75bas4VAYFcZAcBspSqS4vlJe8nmFn9ncTgeoT/OvnA="; 12 12 + }; 13 13 + }; 14 14 + buildInputs = [glibc.static]; 15 15 + RUSTFLAGS = ["-C" "target-feature=+crt-static"]; 6 16 }

+96

cli/flake.lock

··· 1 1 + { 2 2 + "nodes": { 3 3 + "flake-utils": { 4 4 + "inputs": { 5 5 + "systems": "systems" 6 6 + }, 7 7 + "locked": { 8 8 + "lastModified": 1731533236, 9 9 + "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=", 10 10 + "owner": "numtide", 11 11 + "repo": "flake-utils", 12 12 + "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b", 13 13 + "type": "github" 14 14 + }, 15 15 + "original": { 16 16 + "owner": "numtide", 17 17 + "repo": "flake-utils", 18 18 + "type": "github" 19 19 + } 20 20 + }, 21 21 + "nixpkgs": { 22 22 + "locked": { 23 23 + "lastModified": 1767640445, 24 24 + "narHash": "sha256-UWYqmD7JFBEDBHWYcqE6s6c77pWdcU/i+bwD6XxMb8A=", 25 25 + "owner": "NixOS", 26 26 + "repo": "nixpkgs", 27 27 + "rev": "9f0c42f8bc7151b8e7e5840fb3bd454ad850d8c5", 28 28 + "type": "github" 29 29 + }, 30 30 + "original": { 31 31 + "owner": "NixOS", 32 32 + "ref": "nixos-unstable", 33 33 + "repo": "nixpkgs", 34 34 + "type": "github" 35 35 + } 36 36 + }, 37 37 + "nixpkgs_2": { 38 38 + "locked": { 39 39 + "lastModified": 1744536153, 40 40 + "narHash": "sha256-awS2zRgF4uTwrOKwwiJcByDzDOdo3Q1rPZbiHQg/N38=", 41 41 + "owner": "NixOS", 42 42 + "repo": "nixpkgs", 43 43 + "rev": "18dd725c29603f582cf1900e0d25f9f1063dbf11", 44 44 + "type": "github" 45 45 + }, 46 46 + "original": { 47 47 + "owner": "NixOS", 48 48 + "ref": "nixpkgs-unstable", 49 49 + "repo": "nixpkgs", 50 50 + "type": "github" 51 51 + } 52 52 + }, 53 53 + "root": { 54 54 + "inputs": { 55 55 + "flake-utils": "flake-utils", 56 56 + "nixpkgs": "nixpkgs", 57 57 + "rust-overlay": "rust-overlay" 58 58 + } 59 59 + }, 60 60 + "rust-overlay": { 61 61 + "inputs": { 62 62 + "nixpkgs": "nixpkgs_2" 63 63 + }, 64 64 + "locked": { 65 65 + "lastModified": 1767667566, 66 66 + "narHash": "sha256-COy+yxZGuhQRVD1r4bWVgeFt1GB+IB1k5WRpDKbLfI8=", 67 67 + "owner": "oxalica", 68 68 + "repo": "rust-overlay", 69 69 + "rev": "056ce5b125ab32ffe78c7d3e394d9da44733c95e", 70 70 + "type": "github" 71 71 + }, 72 72 + "original": { 73 73 + "owner": "oxalica", 74 74 + "repo": "rust-overlay", 75 75 + "type": "github" 76 76 + } 77 77 + }, 78 78 + "systems": { 79 79 + "locked": { 80 80 + "lastModified": 1681028828, 81 81 + "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", 82 82 + "owner": "nix-systems", 83 83 + "repo": "default", 84 84 + "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", 85 85 + "type": "github" 86 86 + }, 87 87 + "original": { 88 88 + "owner": "nix-systems", 89 89 + "repo": "default", 90 90 + "type": "github" 91 91 + } 92 92 + } 93 93 + }, 94 94 + "root": "root", 95 95 + "version": 7 96 96 + }

+130 -21

cli/flake.nix

··· 1 1 { 2 2 inputs = { 3 3 - nixpkgs.url = "nixpkgs/nixos-unstable"; 3 3 + nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable"; 4 4 rust-overlay.url = "github:oxalica/rust-overlay"; 5 5 + flake-utils.url = "github:numtide/flake-utils"; 5 6 }; 6 7 7 7 - outputs = { 8 8 - self, 9 9 - nixpkgs, 10 10 - rust-overlay, 11 11 - }: let 12 12 - system = "aarch64-darwin"; 13 13 - overlays = [(import rust-overlay)]; 14 14 - pkgs = import nixpkgs { 15 15 - inherit overlays system; 16 16 - crossSystem = { 17 17 - config = "x86_64-unknown-linux-gnu"; 18 18 - rustc.config = "x86_64-unknown-linux-gnu"; 19 19 - }; 20 20 - }; 21 21 - in { 22 22 - packages.${system} = { 23 23 - default = self.outputs.packages.${system}.x86_64-linux-example; 24 24 - x86_64-linux-example = pkgs.callPackage ./. {}; 25 25 - }; 26 26 - }; 8 8 + outputs = { self, nixpkgs, rust-overlay, flake-utils }: 9 9 + flake-utils.lib.eachDefaultSystem (system: 10 10 + let 11 11 + overlays = [ (import rust-overlay) ]; 12 12 + pkgs = import nixpkgs { inherit system overlays; }; 13 13 + 14 14 + rustToolchain = pkgs.rust-bin.stable.latest.default.override { 15 15 + targets = [ 16 16 + "x86_64-unknown-linux-musl" 17 17 + "aarch64-unknown-linux-musl" 18 18 + "x86_64-apple-darwin" 19 19 + "aarch64-apple-darwin" 20 20 + ]; 21 21 + }; 22 22 + 23 23 + cargoLockConfig = { 24 24 + lockFile = ./Cargo.lock; 25 25 + outputHashes = { 26 26 + "jacquard-0.9.5" = "sha256-75bas4VAYFcZAcBspSqS4vlJe8nmFn9ncTgeoT/OvnA="; 27 27 + }; 28 28 + }; 29 29 + 30 30 + # Native build for current system 31 31 + native = pkgs.rustPlatform.buildRustPackage { 32 32 + pname = "wisp-cli"; 33 33 + version = "0.4.2"; 34 34 + src = ./.; 35 35 + cargoLock = cargoLockConfig; 36 36 + nativeBuildInputs = [ rustToolchain ]; 37 37 + }; 38 38 + 39 39 + # Cross-compilation targets (Linux from macOS needs zigbuild) 40 40 + linuxTargets = let 41 41 + zigbuildPkgs = pkgs; 42 42 + in { 43 43 + x86_64-linux = pkgs.stdenv.mkDerivation { 44 44 + pname = "wisp-cli-x86_64-linux"; 45 45 + version = "0.4.2"; 46 46 + src = ./.; 47 47 + 48 48 + nativeBuildInputs = [ 49 49 + rustToolchain 50 50 + pkgs.cargo-zigbuild 51 51 + pkgs.zig 52 52 + ]; 53 53 + 54 54 + buildPhase = '' 55 55 + export HOME=$(mktemp -d) 56 56 + cargo zigbuild --release --target x86_64-unknown-linux-musl 57 57 + ''; 58 58 + 59 59 + installPhase = '' 60 60 + mkdir -p $out/bin 61 61 + cp target/x86_64-unknown-linux-musl/release/wisp-cli $out/bin/ 62 62 + ''; 63 63 + 64 64 + # Skip Nix's cargo vendor - we use network 65 65 + dontConfigure = true; 66 66 + dontFixup = true; 67 67 + }; 68 68 + 69 69 + aarch64-linux = pkgs.stdenv.mkDerivation { 70 70 + pname = "wisp-cli-aarch64-linux"; 71 71 + version = "0.4.2"; 72 72 + src = ./.; 73 73 + 74 74 + nativeBuildInputs = [ 75 75 + rustToolchain 76 76 + pkgs.cargo-zigbuild 77 77 + pkgs.zig 78 78 + ]; 79 79 + 80 80 + buildPhase = '' 81 81 + export HOME=$(mktemp -d) 82 82 + cargo zigbuild --release --target aarch64-unknown-linux-musl 83 83 + ''; 84 84 + 85 85 + installPhase = '' 86 86 + mkdir -p $out/bin 87 87 + cp target/aarch64-unknown-linux-musl/release/wisp-cli $out/bin/ 88 88 + ''; 89 89 + 90 90 + dontConfigure = true; 91 91 + dontFixup = true; 92 92 + }; 93 93 + }; 94 94 + 95 95 + in { 96 96 + packages = { 97 97 + default = native; 98 98 + inherit native; 99 99 + 100 100 + # macOS universal binary 101 101 + macos-universal = pkgs.stdenv.mkDerivation { 102 102 + pname = "wisp-cli-macos-universal"; 103 103 + version = "0.4.2"; 104 104 + src = ./.; 105 105 + 106 106 + nativeBuildInputs = [ rustToolchain pkgs.darwin.lipo ]; 107 107 + 108 108 + buildPhase = '' 109 109 + export HOME=$(mktemp -d) 110 110 + cargo build --release --target aarch64-apple-darwin 111 111 + cargo build --release --target x86_64-apple-darwin 112 112 + ''; 113 113 + 114 114 + installPhase = '' 115 115 + mkdir -p $out/bin 116 116 + lipo -create \ 117 117 + target/aarch64-apple-darwin/release/wisp-cli \ 118 118 + target/x86_64-apple-darwin/release/wisp-cli \ 119 119 + -output $out/bin/wisp-cli 120 120 + ''; 121 121 + 122 122 + dontConfigure = true; 123 123 + dontFixup = true; 124 124 + }; 125 125 + } // (if pkgs.stdenv.isDarwin then linuxTargets else {}); 126 126 + 127 127 + devShells.default = pkgs.mkShell { 128 128 + buildInputs = [ 129 129 + rustToolchain 130 130 + pkgs.cargo-zigbuild 131 131 + pkgs.zig 132 132 + ]; 133 133 + }; 134 134 + } 135 135 + ); 27 136 }

-318

flake.lock

··· 1 1 - { 2 2 - "nodes": { 3 3 - "crane": { 4 4 - "flake": false, 5 5 - "locked": { 6 6 - "lastModified": 1758758545, 7 7 - "narHash": "sha256-NU5WaEdfwF6i8faJ2Yh+jcK9vVFrofLcwlD/mP65JrI=", 8 8 - "owner": "ipetkov", 9 9 - "repo": "crane", 10 10 - "rev": "95d528a5f54eaba0d12102249ce42f4d01f4e364", 11 11 - "type": "github" 12 12 - }, 13 13 - "original": { 14 14 - "owner": "ipetkov", 15 15 - "ref": "v0.21.1", 16 16 - "repo": "crane", 17 17 - "type": "github" 18 18 - } 19 19 - }, 20 20 - "dream2nix": { 21 21 - "inputs": { 22 22 - "nixpkgs": [ 23 23 - "nci", 24 24 - "nixpkgs" 25 25 - ], 26 26 - "purescript-overlay": "purescript-overlay", 27 27 - "pyproject-nix": "pyproject-nix" 28 28 - }, 29 29 - "locked": { 30 30 - "lastModified": 1754978539, 31 31 - "narHash": "sha256-nrDovydywSKRbWim9Ynmgj8SBm8LK3DI2WuhIqzOHYI=", 32 32 - "owner": "nix-community", 33 33 - "repo": "dream2nix", 34 34 - "rev": "fbec3263cb4895ac86ee9506cdc4e6919a1a2214", 35 35 - "type": "github" 36 36 - }, 37 37 - "original": { 38 38 - "owner": "nix-community", 39 39 - "repo": "dream2nix", 40 40 - "type": "github" 41 41 - } 42 42 - }, 43 43 - "fenix": { 44 44 - "inputs": { 45 45 - "nixpkgs": [ 46 46 - "nixpkgs" 47 47 - ], 48 48 - "rust-analyzer-src": "rust-analyzer-src" 49 49 - }, 50 50 - "locked": { 51 51 - "lastModified": 1762584108, 52 52 - "narHash": "sha256-wZUW7dlXMXaRdvNbaADqhF8gg9bAfFiMV+iyFQiDv+Y=", 53 53 - "owner": "nix-community", 54 54 - "repo": "fenix", 55 55 - "rev": "32f3ad3b6c690061173e1ac16708874975ec6056", 56 56 - "type": "github" 57 57 - }, 58 58 - "original": { 59 59 - "owner": "nix-community", 60 60 - "repo": "fenix", 61 61 - "type": "github" 62 62 - } 63 63 - }, 64 64 - "flake-compat": { 65 65 - "flake": false, 66 66 - "locked": { 67 67 - "lastModified": 1696426674, 68 68 - "narHash": "sha256-kvjfFW7WAETZlt09AgDn1MrtKzP7t90Vf7vypd3OL1U=", 69 69 - "owner": "edolstra", 70 70 - "repo": "flake-compat", 71 71 - "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33", 72 72 - "type": "github" 73 73 - }, 74 74 - "original": { 75 75 - "owner": "edolstra", 76 76 - "repo": "flake-compat", 77 77 - "type": "github" 78 78 - } 79 79 - }, 80 80 - "mk-naked-shell": { 81 81 - "flake": false, 82 82 - "locked": { 83 83 - "lastModified": 1681286841, 84 84 - "narHash": "sha256-3XlJrwlR0nBiREnuogoa5i1b4+w/XPe0z8bbrJASw0g=", 85 85 - "owner": "90-008", 86 86 - "repo": "mk-naked-shell", 87 87 - "rev": "7612f828dd6f22b7fb332cc69440e839d7ffe6bd", 88 88 - "type": "github" 89 89 - }, 90 90 - "original": { 91 91 - "owner": "90-008", 92 92 - "repo": "mk-naked-shell", 93 93 - "type": "github" 94 94 - } 95 95 - }, 96 96 - "nci": { 97 97 - "inputs": { 98 98 - "crane": "crane", 99 99 - "dream2nix": "dream2nix", 100 100 - "mk-naked-shell": "mk-naked-shell", 101 101 - "nixpkgs": [ 102 102 - "nixpkgs" 103 103 - ], 104 104 - "parts": "parts", 105 105 - "rust-overlay": "rust-overlay", 106 106 - "treefmt": "treefmt" 107 107 - }, 108 108 - "locked": { 109 109 - "lastModified": 1762582646, 110 110 - "narHash": "sha256-MMzE4xccG+8qbLhdaZoeFDUKWUOn3B4lhp5dZmgukmM=", 111 111 - "owner": "90-008", 112 112 - "repo": "nix-cargo-integration", 113 113 - "rev": "0993c449377049fa8868a664e8290ac6658e0b9a", 114 114 - "type": "github" 115 115 - }, 116 116 - "original": { 117 117 - "owner": "90-008", 118 118 - "repo": "nix-cargo-integration", 119 119 - "type": "github" 120 120 - } 121 121 - }, 122 122 - "nixpkgs": { 123 123 - "locked": { 124 124 - "lastModified": 1762361079, 125 125 - "narHash": "sha256-lz718rr1BDpZBYk7+G8cE6wee3PiBUpn8aomG/vLLiY=", 126 126 - "owner": "nixos", 127 127 - "repo": "nixpkgs", 128 128 - "rev": "ffcdcf99d65c61956d882df249a9be53e5902ea5", 129 129 - "type": "github" 130 130 - }, 131 131 - "original": { 132 132 - "owner": "nixos", 133 133 - "ref": "nixpkgs-unstable", 134 134 - "repo": "nixpkgs", 135 135 - "type": "github" 136 136 - } 137 137 - }, 138 138 - "parts": { 139 139 - "inputs": { 140 140 - "nixpkgs-lib": [ 141 141 - "nci", 142 142 - "nixpkgs" 143 143 - ] 144 144 - }, 145 145 - "locked": { 146 146 - "lastModified": 1762440070, 147 147 - "narHash": "sha256-xxdepIcb39UJ94+YydGP221rjnpkDZUlykKuF54PsqI=", 148 148 - "owner": "hercules-ci", 149 149 - "repo": "flake-parts", 150 150 - "rev": "26d05891e14c88eb4a5d5bee659c0db5afb609d8", 151 151 - "type": "github" 152 152 - }, 153 153 - "original": { 154 154 - "owner": "hercules-ci", 155 155 - "repo": "flake-parts", 156 156 - "type": "github" 157 157 - } 158 158 - }, 159 159 - "parts_2": { 160 160 - "inputs": { 161 161 - "nixpkgs-lib": [ 162 162 - "nixpkgs" 163 163 - ] 164 164 - }, 165 165 - "locked": { 166 166 - "lastModified": 1762440070, 167 167 - "narHash": "sha256-xxdepIcb39UJ94+YydGP221rjnpkDZUlykKuF54PsqI=", 168 168 - "owner": "hercules-ci", 169 169 - "repo": "flake-parts", 170 170 - "rev": "26d05891e14c88eb4a5d5bee659c0db5afb609d8", 171 171 - "type": "github" 172 172 - }, 173 173 - "original": { 174 174 - "owner": "hercules-ci", 175 175 - "repo": "flake-parts", 176 176 - "type": "github" 177 177 - } 178 178 - }, 179 179 - "purescript-overlay": { 180 180 - "inputs": { 181 181 - "flake-compat": "flake-compat", 182 182 - "nixpkgs": [ 183 183 - "nci", 184 184 - "dream2nix", 185 185 - "nixpkgs" 186 186 - ], 187 187 - "slimlock": "slimlock" 188 188 - }, 189 189 - "locked": { 190 190 - "lastModified": 1728546539, 191 191 - "narHash": "sha256-Sws7w0tlnjD+Bjck1nv29NjC5DbL6nH5auL9Ex9Iz2A=", 192 192 - "owner": "thomashoneyman", 193 193 - "repo": "purescript-overlay", 194 194 - "rev": "4ad4c15d07bd899d7346b331f377606631eb0ee4", 195 195 - "type": "github" 196 196 - }, 197 197 - "original": { 198 198 - "owner": "thomashoneyman", 199 199 - "repo": "purescript-overlay", 200 200 - "type": "github" 201 201 - } 202 202 - }, 203 203 - "pyproject-nix": { 204 204 - "inputs": { 205 205 - "nixpkgs": [ 206 206 - "nci", 207 207 - "dream2nix", 208 208 - "nixpkgs" 209 209 - ] 210 210 - }, 211 211 - "locked": { 212 212 - "lastModified": 1752481895, 213 213 - "narHash": "sha256-luVj97hIMpCbwhx3hWiRwjP2YvljWy8FM+4W9njDhLA=", 214 214 - "owner": "pyproject-nix", 215 215 - "repo": "pyproject.nix", 216 216 - "rev": "16ee295c25107a94e59a7fc7f2e5322851781162", 217 217 - "type": "github" 218 218 - }, 219 219 - "original": { 220 220 - "owner": "pyproject-nix", 221 221 - "repo": "pyproject.nix", 222 222 - "type": "github" 223 223 - } 224 224 - }, 225 225 - "root": { 226 226 - "inputs": { 227 227 - "fenix": "fenix", 228 228 - "nci": "nci", 229 229 - "nixpkgs": "nixpkgs", 230 230 - "parts": "parts_2" 231 231 - } 232 232 - }, 233 233 - "rust-analyzer-src": { 234 234 - "flake": false, 235 235 - "locked": { 236 236 - "lastModified": 1762438844, 237 237 - "narHash": "sha256-ApIKJf6CcMsV2nYBXhGF95BmZMO/QXPhgfSnkA/rVUo=", 238 238 - "owner": "rust-lang", 239 239 - "repo": "rust-analyzer", 240 240 - "rev": "4bf516ee5a960c1e2eee9fedd9b1c9e976a19c86", 241 241 - "type": "github" 242 242 - }, 243 243 - "original": { 244 244 - "owner": "rust-lang", 245 245 - "ref": "nightly", 246 246 - "repo": "rust-analyzer", 247 247 - "type": "github" 248 248 - } 249 249 - }, 250 250 - "rust-overlay": { 251 251 - "inputs": { 252 252 - "nixpkgs": [ 253 253 - "nci", 254 254 - "nixpkgs" 255 255 - ] 256 256 - }, 257 257 - "locked": { 258 258 - "lastModified": 1762569282, 259 259 - "narHash": "sha256-vINZAJpXQTZd5cfh06Rcw7hesH7sGSvi+Tn+HUieJn8=", 260 260 - "owner": "oxalica", 261 261 - "repo": "rust-overlay", 262 262 - "rev": "a35a6144b976f70827c2fe2f5c89d16d8f9179d8", 263 263 - "type": "github" 264 264 - }, 265 265 - "original": { 266 266 - "owner": "oxalica", 267 267 - "repo": "rust-overlay", 268 268 - "type": "github" 269 269 - } 270 270 - }, 271 271 - "slimlock": { 272 272 - "inputs": { 273 273 - "nixpkgs": [ 274 274 - "nci", 275 275 - "dream2nix", 276 276 - "purescript-overlay", 277 277 - "nixpkgs" 278 278 - ] 279 279 - }, 280 280 - "locked": { 281 281 - "lastModified": 1688756706, 282 282 - "narHash": "sha256-xzkkMv3neJJJ89zo3o2ojp7nFeaZc2G0fYwNXNJRFlo=", 283 283 - "owner": "thomashoneyman", 284 284 - "repo": "slimlock", 285 285 - "rev": "cf72723f59e2340d24881fd7bf61cb113b4c407c", 286 286 - "type": "github" 287 287 - }, 288 288 - "original": { 289 289 - "owner": "thomashoneyman", 290 290 - "repo": "slimlock", 291 291 - "type": "github" 292 292 - } 293 293 - }, 294 294 - "treefmt": { 295 295 - "inputs": { 296 296 - "nixpkgs": [ 297 297 - "nci", 298 298 - "nixpkgs" 299 299 - ] 300 300 - }, 301 301 - "locked": { 302 302 - "lastModified": 1762410071, 303 303 - "narHash": "sha256-aF5fvoZeoXNPxT0bejFUBXeUjXfHLSL7g+mjR/p5TEg=", 304 304 - "owner": "numtide", 305 305 - "repo": "treefmt-nix", 306 306 - "rev": "97a30861b13c3731a84e09405414398fbf3e109f", 307 307 - "type": "github" 308 308 - }, 309 309 - "original": { 310 310 - "owner": "numtide", 311 311 - "repo": "treefmt-nix", 312 312 - "type": "github" 313 313 - } 314 314 - } 315 315 - }, 316 316 - "root": "root", 317 317 - "version": 7 318 318 - }

-59

flake.nix

··· 1 1 - { 2 2 - inputs.nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable"; 3 3 - inputs.nci.url = "github:90-008/nix-cargo-integration"; 4 4 - inputs.nci.inputs.nixpkgs.follows = "nixpkgs"; 5 5 - inputs.parts.url = "github:hercules-ci/flake-parts"; 6 6 - inputs.parts.inputs.nixpkgs-lib.follows = "nixpkgs"; 7 7 - inputs.fenix = { 8 8 - url = "github:nix-community/fenix"; 9 9 - inputs.nixpkgs.follows = "nixpkgs"; 10 10 - }; 11 11 - 12 12 - outputs = inputs @ { 13 13 - parts, 14 14 - nci, 15 15 - ... 16 16 - }: 17 17 - parts.lib.mkFlake {inherit inputs;} { 18 18 - systems = ["x86_64-linux" "aarch64-darwin"]; 19 19 - imports = [ 20 20 - nci.flakeModule 21 21 - ./crates.nix 22 22 - ]; 23 23 - perSystem = { 24 24 - pkgs, 25 25 - config, 26 26 - ... 27 27 - }: let 28 28 - crateOutputs = config.nci.outputs."wisp-cli"; 29 29 - mkRenamedPackage = name: pkg: isWindows: pkgs.runCommand name {} '' 30 30 - mkdir -p $out/bin 31 31 - if [ -f ${pkg}/bin/wisp-cli.exe ]; then 32 32 - cp ${pkg}/bin/wisp-cli.exe $out/bin/${name} 33 33 - elif [ -f ${pkg}/bin/wisp-cli ]; then 34 34 - cp ${pkg}/bin/wisp-cli $out/bin/${name} 35 35 - else 36 36 - echo "Error: Could not find wisp-cli binary in ${pkg}/bin/" 37 37 - ls -la ${pkg}/bin/ || true 38 38 - exit 1 39 39 - fi 40 40 - ''; 41 41 - in { 42 42 - devShells.default = crateOutputs.devShell; 43 43 - packages.default = crateOutputs.packages.release; 44 44 - packages.wisp-cli-x86_64-linux = mkRenamedPackage "wisp-cli-x86_64-linux" crateOutputs.packages.release false; 45 45 - packages.wisp-cli-aarch64-linux = mkRenamedPackage "wisp-cli-aarch64-linux" crateOutputs.allTargets."aarch64-unknown-linux-gnu".packages.release false; 46 46 - packages.wisp-cli-x86_64-windows = mkRenamedPackage "wisp-cli-x86_64-windows.exe" crateOutputs.allTargets."x86_64-pc-windows-gnu".packages.release true; 47 47 - packages.wisp-cli-aarch64-darwin = mkRenamedPackage "wisp-cli-aarch64-darwin" crateOutputs.allTargets."aarch64-apple-darwin".packages.release false; 48 48 - packages.all = pkgs.symlinkJoin { 49 49 - name = "wisp-cli-all"; 50 50 - paths = [ 51 51 - config.packages.wisp-cli-x86_64-linux 52 52 - config.packages.wisp-cli-aarch64-linux 53 53 - config.packages.wisp-cli-x86_64-windows 54 54 - config.packages.wisp-cli-aarch64-darwin 55 55 - ]; 56 56 - }; 57 57 - }; 58 58 - }; 59 59 - }