+31 -23

cli/Cargo.lock

··· 523 523 524 524 [[package]] 525 525 name = "clap" 526 526 - version = "4.5.51" 526 526 + version = "4.5.52" 527 527 source = "registry+https://github.com/rust-lang/crates.io-index" 528 528 - checksum = "4c26d721170e0295f191a69bd9a1f93efcdb0aff38684b61ab5750468972e5f5" 528 528 + checksum = "aa8120877db0e5c011242f96806ce3c94e0737ab8108532a76a3300a01db2ab8" 529 529 dependencies = [ 530 530 "clap_builder", 531 531 "clap_derive", ··· 533 533 534 534 [[package]] 535 535 name = "clap_builder" 536 536 - version = "4.5.51" 536 536 + version = "4.5.52" 537 537 source = "registry+https://github.com/rust-lang/crates.io-index" 538 538 - checksum = "75835f0c7bf681bfd05abe44e965760fea999a5286c6eb2d59883634fd02011a" 538 538 + checksum = "02576b399397b659c26064fbc92a75fede9d18ffd5f80ca1cd74ddab167016e1" 539 539 dependencies = [ 540 540 "anstream", 541 541 "anstyle", ··· 1752 1752 1753 1753 [[package]] 1754 1754 name = "jacquard" 1755 1755 - version = "0.9.0" 1756 1756 - source = "git+https://tangled.org/@nonbinary.computer/jacquard#d853091d7de59e18746a78532dc28cfc017079b0" 1755 1755 + version = "0.9.3" 1756 1756 + source = "git+https://tangled.org/@nonbinary.computer/jacquard#324cbb45078fe2f77b60ae2bd7765c5306ec8b5e" 1757 1757 dependencies = [ 1758 1758 "bytes", 1759 1759 "getrandom 0.2.16", ··· 1767 1767 "jose-jwk", 1768 1768 "miette", 1769 1769 "regex", 1770 1770 + "regex-lite", 1770 1771 "reqwest", 1771 1772 "serde", 1772 1773 "serde_html_form", ··· 1781 1782 1782 1783 [[package]] 1783 1784 name = "jacquard-api" 1784 1784 - version = "0.9.0" 1785 1785 - source = "git+https://tangled.org/@nonbinary.computer/jacquard#d853091d7de59e18746a78532dc28cfc017079b0" 1785 1785 + version = "0.9.2" 1786 1786 + source = "git+https://tangled.org/@nonbinary.computer/jacquard#324cbb45078fe2f77b60ae2bd7765c5306ec8b5e" 1786 1787 dependencies = [ 1787 1788 "bon", 1788 1789 "bytes", ··· 1799 1800 1800 1801 [[package]] 1801 1802 name = "jacquard-common" 1802 1802 - version = "0.9.0" 1803 1803 - source = "git+https://tangled.org/@nonbinary.computer/jacquard#d853091d7de59e18746a78532dc28cfc017079b0" 1803 1803 + version = "0.9.2" 1804 1804 + source = "git+https://tangled.org/@nonbinary.computer/jacquard#324cbb45078fe2f77b60ae2bd7765c5306ec8b5e" 1804 1805 dependencies = [ 1805 1806 "base64 0.22.1", 1806 1807 "bon", ··· 1823 1824 "p256", 1824 1825 "rand 0.9.2", 1825 1826 "regex", 1827 1827 + "regex-lite", 1826 1828 "reqwest", 1827 1829 "serde", 1828 1830 "serde_html_form", ··· 1840 1842 1841 1843 [[package]] 1842 1844 name = "jacquard-derive" 1843 1843 - version = "0.9.0" 1844 1844 - source = "git+https://tangled.org/@nonbinary.computer/jacquard#d853091d7de59e18746a78532dc28cfc017079b0" 1845 1845 + version = "0.9.3" 1846 1846 + source = "git+https://tangled.org/@nonbinary.computer/jacquard#324cbb45078fe2f77b60ae2bd7765c5306ec8b5e" 1845 1847 dependencies = [ 1846 1848 "heck 0.5.0", 1847 1849 "jacquard-lexicon", ··· 1852 1854 1853 1855 [[package]] 1854 1856 name = "jacquard-identity" 1855 1855 - version = "0.9.1" 1856 1856 - source = "git+https://tangled.org/@nonbinary.computer/jacquard#d853091d7de59e18746a78532dc28cfc017079b0" 1857 1857 + version = "0.9.2" 1858 1858 + source = "git+https://tangled.org/@nonbinary.computer/jacquard#324cbb45078fe2f77b60ae2bd7765c5306ec8b5e" 1857 1859 dependencies = [ 1858 1860 "bon", 1859 1861 "bytes", ··· 1878 1880 1879 1881 [[package]] 1880 1882 name = "jacquard-lexicon" 1881 1881 - version = "0.9.1" 1882 1882 - source = "git+https://tangled.org/@nonbinary.computer/jacquard#d853091d7de59e18746a78532dc28cfc017079b0" 1883 1883 + version = "0.9.2" 1884 1884 + source = "git+https://tangled.org/@nonbinary.computer/jacquard#324cbb45078fe2f77b60ae2bd7765c5306ec8b5e" 1883 1885 dependencies = [ 1884 1886 "cid", 1885 1887 "dashmap", ··· 1904 1906 1905 1907 [[package]] 1906 1908 name = "jacquard-oauth" 1907 1907 - version = "0.9.0" 1908 1908 - source = "git+https://tangled.org/@nonbinary.computer/jacquard#d853091d7de59e18746a78532dc28cfc017079b0" 1909 1909 + version = "0.9.2" 1910 1910 + source = "git+https://tangled.org/@nonbinary.computer/jacquard#324cbb45078fe2f77b60ae2bd7765c5306ec8b5e" 1909 1911 dependencies = [ 1910 1912 "base64 0.22.1", 1911 1913 "bytes", ··· 1925 1927 "serde_html_form", 1926 1928 "serde_json", 1927 1929 "sha2", 1928 1928 - "signature", 1929 1930 "smol_str", 1930 1931 "thiserror 2.0.17", 1931 1932 "tokio", ··· 2230 2231 2231 2232 [[package]] 2232 2233 name = "mini-moka" 2233 2233 - version = "0.11.0" 2234 2234 - source = "git+https://github.com/moka-rs/mini-moka?rev=da864e849f5d034f32e02197fee9bb5d5af36d3d#da864e849f5d034f32e02197fee9bb5d5af36d3d" 2234 2234 + version = "0.10.99" 2235 2235 + source = "git+https://tangled.org/@nonbinary.computer/jacquard#324cbb45078fe2f77b60ae2bd7765c5306ec8b5e" 2235 2236 dependencies = [ 2236 2237 "crossbeam-channel", 2237 2238 "crossbeam-utils", ··· 2999 3000 ] 3000 3001 3001 3002 [[package]] 3003 3003 + name = "regex-lite" 3004 3004 + version = "0.1.8" 3005 3005 + source = "registry+https://github.com/rust-lang/crates.io-index" 3006 3006 + checksum = "8d942b98df5e658f56f20d592c7f868833fe38115e65c33003d8cd224b0155da" 3007 3007 + 3008 3008 + [[package]] 3002 3009 name = "regex-syntax" 3003 3010 version = "0.8.8" 3004 3011 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 3051 3058 3052 3059 [[package]] 3053 3060 name = "resolv-conf" 3054 3054 - version = "0.7.5" 3061 3061 + version = "0.7.6" 3055 3062 source = "registry+https://github.com/rust-lang/crates.io-index" 3056 3056 - checksum = "6b3789b30bd25ba102de4beabd95d21ac45b69b1be7d14522bab988c526d6799" 3063 3063 + checksum = "1e061d1b48cb8d38042de4ae0a7a6401009d6143dc80d2e2d6f31f0bdd6470c7" 3057 3064 3058 3065 [[package]] 3059 3066 name = "rfc6979" ··· 4954 4961 "multibase", 4955 4962 "multihash", 4956 4963 "n0-future 0.3.1", 4964 4964 + "regex", 4957 4965 "reqwest", 4958 4966 "rustversion", 4959 4967 "serde",

+8 -7

cli/Cargo.toml

··· 8 8 place_wisp = [] 9 9 10 10 [dependencies] 11 11 - jacquard = { git = "https://tangled.org/@nonbinary.computer/jacquard", features = ["loopback"] } 12 12 - jacquard-oauth = { git = "https://tangled.org/@nonbinary.computer/jacquard" } 13 13 - jacquard-api = { git = "https://tangled.org/@nonbinary.computer/jacquard" } 14 14 - jacquard-common = { git = "https://tangled.org/@nonbinary.computer/jacquard", features = ["websocket"] } 15 15 - jacquard-identity = { git = "https://tangled.org/@nonbinary.computer/jacquard", features = ["dns"] } 16 16 - jacquard-derive = { git = "https://tangled.org/@nonbinary.computer/jacquard" } 17 17 - jacquard-lexicon = { git = "https://tangled.org/@nonbinary.computer/jacquard" } 11 11 + jacquard = { path = "/Users/regent/Developer/jacquard/crates/jacquard", features = ["loopback"] } 12 12 + jacquard-oauth = { path = "/Users/regent/Developer/jacquard/crates/jacquard-oauth" } 13 13 + jacquard-api = { path = "/Users/regent/Developer/jacquard/crates/jacquard-api", features = ["streaming"] } 14 14 + jacquard-common = { path = "/Users/regent/Developer/jacquard/crates/jacquard-common", features = ["websocket"] } 15 15 + jacquard-identity = { path = "/Users/regent/Developer/jacquard/crates/jacquard-identity", features = ["dns"] } 16 16 + jacquard-derive = { path = "/Users/regent/Developer/jacquard/crates/jacquard-derive" } 17 17 + jacquard-lexicon = { path = "/Users/regent/Developer/jacquard/crates/jacquard-lexicon" } 18 18 clap = { version = "4.5.51", features = ["derive"] } 19 19 tokio = { version = "1.48", features = ["full"] } 20 20 miette = { version = "7.6.0", features = ["fancy"] } ··· 39 39 n0-future = "0.3.1" 40 40 chrono = "0.4" 41 41 url = "2.5" 42 42 + regex = "1.11"

+61 -37

cli/src/main.rs

··· 7 7 mod pull; 8 8 mod serve; 9 9 mod subfs_utils; 10 10 + mod redirects; 10 11 11 12 use clap::{Parser, Subcommand}; 12 13 use jacquard::CowStr; ··· 168 169 site: Option<String>, 169 170 ) -> miette::Result<()> { 170 171 let (session, auth) = 171 171 - MemoryCredentialSession::authenticated(input, password, None).await?; 172 172 + MemoryCredentialSession::authenticated(input, password, None, None).await?; 172 173 println!("Signed in as {}", auth.handle); 173 174 174 175 let agent: Agent<_> = Agent::from(session); ··· 556 557 /// Process a single file: gzip -> base64 -> upload blob (or reuse existing) 557 558 /// Returns (File, reused: bool) 558 559 /// file_path_key is the full path from the site root (e.g., "config/file.json") for blob map lookup 560 560 + /// 561 561 + /// Special handling: _redirects files are NOT compressed (uploaded as-is) 559 562 async fn process_file( 560 563 agent: &Agent<impl jacquard::client::AgentSession + IdentityResolver>, 561 564 file_path: &Path, ··· 571 574 .first_or_octet_stream() 572 575 .to_string(); 573 576 574 574 - // Gzip compress 575 575 - let mut encoder = GzEncoder::new(Vec::new(), Compression::default()); 576 576 - encoder.write_all(&file_data).into_diagnostic()?; 577 577 - let gzipped = encoder.finish().into_diagnostic()?; 577 577 + // Check if this is a _redirects file (don't compress it) 578 578 + let is_redirects_file = file_path.file_name() 579 579 + .and_then(|n| n.to_str()) 580 580 + .map(|n| n == "_redirects") 581 581 + .unwrap_or(false); 578 582 579 579 - // Base64 encode the gzipped data 580 580 - let base64_bytes = base64::prelude::BASE64_STANDARD.encode(&gzipped).into_bytes(); 583 583 + let (upload_bytes, encoding, is_base64) = if is_redirects_file { 584 584 + // Don't compress _redirects - upload as-is 585 585 + (file_data.clone(), None, false) 586 586 + } else { 587 587 + // Gzip compress 588 588 + let mut encoder = GzEncoder::new(Vec::new(), Compression::default()); 589 589 + encoder.write_all(&file_data).into_diagnostic()?; 590 590 + let gzipped = encoder.finish().into_diagnostic()?; 581 591 582 582 - // Compute CID for this file (CRITICAL: on base64-encoded gzipped content) 583 583 - let file_cid = cid::compute_cid(&base64_bytes); 584 584 - 592 592 + // Base64 encode the gzipped data 593 593 + let base64_bytes = base64::prelude::BASE64_STANDARD.encode(&gzipped).into_bytes(); 594 594 + (base64_bytes, Some("gzip"), true) 595 595 + }; 596 596 + 597 597 + // Compute CID for this file 598 598 + let file_cid = cid::compute_cid(&upload_bytes); 599 599 + 585 600 // Check if we have an existing blob with the same CID 586 601 let existing_blob = existing_blobs.get(file_path_key); 587 587 - 602 602 + 588 603 if let Some((existing_blob_ref, existing_cid)) = existing_blob { 589 604 if existing_cid == &file_cid { 590 605 // CIDs match - reuse existing blob 591 606 println!(" ✓ Reusing blob for {} (CID: {})", file_path_key, file_cid); 592 592 - return Ok(( 593 593 - File::new() 594 594 - .r#type(CowStr::from("file")) 595 595 - .blob(existing_blob_ref.clone()) 596 596 - .encoding(CowStr::from("gzip")) 597 597 - .mime_type(CowStr::from(original_mime)) 598 598 - .base64(true) 599 599 - .build(), 600 600 - true 601 601 - )); 607 607 + let mut file_builder = File::new() 608 608 + .r#type(CowStr::from("file")) 609 609 + .blob(existing_blob_ref.clone()) 610 610 + .mime_type(CowStr::from(original_mime)); 611 611 + 612 612 + if let Some(enc) = encoding { 613 613 + file_builder = file_builder.encoding(CowStr::from(enc)); 614 614 + } 615 615 + if is_base64 { 616 616 + file_builder = file_builder.base64(true); 617 617 + } 618 618 + 619 619 + return Ok((file_builder.build(), true)); 602 620 } 603 621 } 604 604 - 622 622 + 605 623 // File is new or changed - upload it 606 606 - println!(" ↑ Uploading {} ({} bytes, CID: {})", file_path_key, base64_bytes.len(), file_cid); 607 607 - let blob = agent.upload_blob( 608 608 - base64_bytes, 609 609 - MimeType::new_static("application/octet-stream"), 610 610 - ).await?; 624 624 + let mime_type = if is_redirects_file { 625 625 + MimeType::new_static("text/plain") 626 626 + } else { 627 627 + MimeType::new_static("application/octet-stream") 628 628 + }; 629 629 + 630 630 + println!(" ↑ Uploading {} ({} bytes, CID: {})", file_path_key, upload_bytes.len(), file_cid); 631 631 + let blob = agent.upload_blob(upload_bytes, mime_type).await?; 632 632 + 633 633 + let mut file_builder = File::new() 634 634 + .r#type(CowStr::from("file")) 635 635 + .blob(blob) 636 636 + .mime_type(CowStr::from(original_mime)); 637 637 + 638 638 + if let Some(enc) = encoding { 639 639 + file_builder = file_builder.encoding(CowStr::from(enc)); 640 640 + } 641 641 + if is_base64 { 642 642 + file_builder = file_builder.base64(true); 643 643 + } 611 644 612 612 - Ok(( 613 613 - File::new() 614 614 - .r#type(CowStr::from("file")) 615 615 - .blob(blob) 616 616 - .encoding(CowStr::from("gzip")) 617 617 - .mime_type(CowStr::from(original_mime)) 618 618 - .base64(true) 619 619 - .build(), 620 620 - false 621 621 - )) 645 645 + Ok((file_builder.build(), false)) 622 646 } 623 647 624 648 /// Convert fs::Directory to subfs::Directory

+375

cli/src/redirects.rs

··· 1 1 + use regex::Regex; 2 2 + use std::collections::HashMap; 3 3 + use std::fs; 4 4 + use std::path::Path; 5 5 + 6 6 + /// Maximum number of redirect rules to prevent DoS attacks 7 7 + const MAX_REDIRECT_RULES: usize = 1000; 8 8 + 9 9 + #[derive(Debug, Clone)] 10 10 + pub struct RedirectRule { 11 11 + #[allow(dead_code)] 12 12 + pub from: String, 13 13 + pub to: String, 14 14 + pub status: u16, 15 15 + #[allow(dead_code)] 16 16 + pub force: bool, 17 17 + pub from_pattern: Regex, 18 18 + pub from_params: Vec<String>, 19 19 + pub query_params: Option<HashMap<String, String>>, 20 20 + } 21 21 + 22 22 + #[derive(Debug)] 23 23 + pub struct RedirectMatch { 24 24 + pub target_path: String, 25 25 + pub status: u16, 26 26 + pub force: bool, 27 27 + } 28 28 + 29 29 + /// Parse a _redirects file into an array of redirect rules 30 30 + pub fn parse_redirects_file(content: &str) -> Vec<RedirectRule> { 31 31 + let lines = content.lines(); 32 32 + let mut rules = Vec::new(); 33 33 + 34 34 + for (line_num, line_raw) in lines.enumerate() { 35 35 + if line_raw.trim().is_empty() || line_raw.trim().starts_with('#') { 36 36 + continue; 37 37 + } 38 38 + 39 39 + // Enforce max rules limit 40 40 + if rules.len() >= MAX_REDIRECT_RULES { 41 41 + eprintln!( 42 42 + "Redirect rules limit reached ({}), ignoring remaining rules", 43 43 + MAX_REDIRECT_RULES 44 44 + ); 45 45 + break; 46 46 + } 47 47 + 48 48 + match parse_redirect_line(line_raw.trim()) { 49 49 + Ok(Some(rule)) => rules.push(rule), 50 50 + Ok(None) => continue, 51 51 + Err(e) => { 52 52 + eprintln!( 53 53 + "Failed to parse redirect rule on line {}: {} ({})", 54 54 + line_num + 1, 55 55 + line_raw, 56 56 + e 57 57 + ); 58 58 + } 59 59 + } 60 60 + } 61 61 + 62 62 + rules 63 63 + } 64 64 + 65 65 + /// Parse a single redirect rule line 66 66 + /// Format: /from [query_params] /to [status] [conditions] 67 67 + fn parse_redirect_line(line: &str) -> Result<Option<RedirectRule>, String> { 68 68 + let parts: Vec<&str> = line.split_whitespace().collect(); 69 69 + 70 70 + if parts.len() < 2 { 71 71 + return Ok(None); 72 72 + } 73 73 + 74 74 + let mut idx = 0; 75 75 + let from = parts[idx]; 76 76 + idx += 1; 77 77 + 78 78 + let mut status = 301; // Default status 79 79 + let mut force = false; 80 80 + let mut query_params: HashMap<String, String> = HashMap::new(); 81 81 + 82 82 + // Parse query parameters that come before the destination path 83 83 + while idx < parts.len() { 84 84 + let part = parts[idx]; 85 85 + 86 86 + // If it starts with / or http, it's the destination path 87 87 + if part.starts_with('/') || part.starts_with("http://") || part.starts_with("https://") { 88 88 + break; 89 89 + } 90 90 + 91 91 + // If it contains = and comes before the destination, it's a query param 92 92 + if part.contains('=') { 93 93 + let split_index = part.find('=').unwrap(); 94 94 + let key = &part[..split_index]; 95 95 + let value = &part[split_index + 1..]; 96 96 + 97 97 + if !key.is_empty() && !value.is_empty() { 98 98 + query_params.insert(key.to_string(), value.to_string()); 99 99 + } 100 100 + idx += 1; 101 101 + } else { 102 102 + break; 103 103 + } 104 104 + } 105 105 + 106 106 + // Next part should be the destination 107 107 + if idx >= parts.len() { 108 108 + return Ok(None); 109 109 + } 110 110 + 111 111 + let to = parts[idx]; 112 112 + idx += 1; 113 113 + 114 114 + // Parse remaining parts for status code 115 115 + for part in parts.iter().skip(idx) { 116 116 + // Check for status code (with optional ! for force) 117 117 + if let Some(stripped) = part.strip_suffix('!') { 118 118 + if let Ok(s) = stripped.parse::<u16>() { 119 119 + force = true; 120 120 + status = s; 121 121 + } 122 122 + } else if let Ok(s) = part.parse::<u16>() { 123 123 + status = s; 124 124 + } 125 125 + // Note: We're ignoring conditional redirects (Country, Language, Cookie, Role) for now 126 126 + // They can be added later if needed 127 127 + } 128 128 + 129 129 + // Parse the 'from' pattern 130 130 + let (pattern, params) = convert_path_to_regex(from)?; 131 131 + 132 132 + Ok(Some(RedirectRule { 133 133 + from: from.to_string(), 134 134 + to: to.to_string(), 135 135 + status, 136 136 + force, 137 137 + from_pattern: pattern, 138 138 + from_params: params, 139 139 + query_params: if query_params.is_empty() { 140 140 + None 141 141 + } else { 142 142 + Some(query_params) 143 143 + }, 144 144 + })) 145 145 + } 146 146 + 147 147 + /// Convert a path pattern with placeholders and splats to a regex 148 148 + /// Examples: 149 149 + /// /blog/:year/:month/:day -> captures year, month, day 150 150 + /// /news/* -> captures splat 151 151 + fn convert_path_to_regex(pattern: &str) -> Result<(Regex, Vec<String>), String> { 152 152 + let mut params = Vec::new(); 153 153 + let mut regex_str = String::from("^"); 154 154 + 155 155 + // Split by query string if present 156 156 + let path_part = pattern.split('?').next().unwrap_or(pattern); 157 157 + 158 158 + // Escape special regex characters except * and : 159 159 + let mut escaped = String::new(); 160 160 + for ch in path_part.chars() { 161 161 + match ch { 162 162 + '.' | '+' | '^' | '$' | '{' | '}' | '(' | ')' | '|' | '[' | ']' | '\\' => { 163 163 + escaped.push('\\'); 164 164 + escaped.push(ch); 165 165 + } 166 166 + _ => escaped.push(ch), 167 167 + } 168 168 + } 169 169 + 170 170 + // Replace :param with named capture groups 171 171 + let param_regex = Regex::new(r":([a-zA-Z_][a-zA-Z0-9_]*)").map_err(|e| e.to_string())?; 172 172 + let mut last_end = 0; 173 173 + let mut result = String::new(); 174 174 + 175 175 + for cap in param_regex.captures_iter(&escaped) { 176 176 + let m = cap.get(0).unwrap(); 177 177 + result.push_str(&escaped[last_end..m.start()]); 178 178 + result.push_str("([^/?]+)"); 179 179 + params.push(cap[1].to_string()); 180 180 + last_end = m.end(); 181 181 + } 182 182 + result.push_str(&escaped[last_end..]); 183 183 + escaped = result; 184 184 + 185 185 + // Replace * with splat capture 186 186 + if escaped.contains('*') { 187 187 + escaped = escaped.replace('*', "(.*)"); 188 188 + params.push("splat".to_string()); 189 189 + } 190 190 + 191 191 + regex_str.push_str(&escaped); 192 192 + 193 193 + // Make trailing slash optional 194 194 + if !regex_str.ends_with(".*") { 195 195 + regex_str.push_str("/?"); 196 196 + } 197 197 + 198 198 + regex_str.push('$'); 199 199 + 200 200 + let pattern = Regex::new(&regex_str).map_err(|e| e.to_string())?; 201 201 + 202 202 + Ok((pattern, params)) 203 203 + } 204 204 + 205 205 + /// Match a request path against redirect rules 206 206 + pub fn match_redirect_rule( 207 207 + request_path: &str, 208 208 + rules: &[RedirectRule], 209 209 + query_params: Option<&HashMap<String, String>>, 210 210 + ) -> Option<RedirectMatch> { 211 211 + // Normalize path: ensure leading slash 212 212 + let normalized_path = if request_path.starts_with('/') { 213 213 + request_path.to_string() 214 214 + } else { 215 215 + format!("/{}", request_path) 216 216 + }; 217 217 + 218 218 + for rule in rules { 219 219 + // Check query parameter conditions first (if any) 220 220 + if let Some(required_params) = &rule.query_params { 221 221 + if let Some(actual_params) = query_params { 222 222 + let query_matches = required_params.iter().all(|(key, expected_value)| { 223 223 + if let Some(actual_value) = actual_params.get(key) { 224 224 + // If expected value is a placeholder (:name), any value is acceptable 225 225 + if expected_value.starts_with(':') { 226 226 + return true; 227 227 + } 228 228 + // Otherwise it must match exactly 229 229 + actual_value == expected_value 230 230 + } else { 231 231 + false 232 232 + } 233 233 + }); 234 234 + 235 235 + if !query_matches { 236 236 + continue; 237 237 + } 238 238 + } else { 239 239 + // Rule requires query params but none provided 240 240 + continue; 241 241 + } 242 242 + } 243 243 + 244 244 + // Match the path pattern 245 245 + if let Some(captures) = rule.from_pattern.captures(&normalized_path) { 246 246 + let mut target_path = rule.to.clone(); 247 247 + 248 248 + // Replace captured parameters 249 249 + for (i, param_name) in rule.from_params.iter().enumerate() { 250 250 + if let Some(param_value) = captures.get(i + 1) { 251 251 + let value = param_value.as_str(); 252 252 + 253 253 + if param_name == "splat" { 254 254 + target_path = target_path.replace(":splat", value); 255 255 + } else { 256 256 + target_path = target_path.replace(&format!(":{}", param_name), value); 257 257 + } 258 258 + } 259 259 + } 260 260 + 261 261 + // Handle query parameter replacements 262 262 + if let Some(required_params) = &rule.query_params { 263 263 + if let Some(actual_params) = query_params { 264 264 + for (key, placeholder) in required_params { 265 265 + if placeholder.starts_with(':') { 266 266 + if let Some(actual_value) = actual_params.get(key) { 267 267 + let param_name = &placeholder[1..]; 268 268 + target_path = target_path.replace( 269 269 + &format!(":{}", param_name), 270 270 + actual_value, 271 271 + ); 272 272 + } 273 273 + } 274 274 + } 275 275 + } 276 276 + } 277 277 + 278 278 + // Preserve query string for 200, 301, 302 redirects (unless target already has one) 279 279 + if [200, 301, 302].contains(&rule.status) 280 280 + && query_params.is_some() 281 281 + && !target_path.contains('?') 282 282 + { 283 283 + if let Some(params) = query_params { 284 284 + if !params.is_empty() { 285 285 + let query_string: String = params 286 286 + .iter() 287 287 + .map(|(k, v)| format!("{}={}", k, v)) 288 288 + .collect::<Vec<_>>() 289 289 + .join("&"); 290 290 + target_path = format!("{}?{}", target_path, query_string); 291 291 + } 292 292 + } 293 293 + } 294 294 + 295 295 + return Some(RedirectMatch { 296 296 + target_path, 297 297 + status: rule.status, 298 298 + force: rule.force, 299 299 + }); 300 300 + } 301 301 + } 302 302 + 303 303 + None 304 304 + } 305 305 + 306 306 + /// Load redirect rules from a _redirects file 307 307 + pub fn load_redirect_rules(directory: &Path) -> Vec<RedirectRule> { 308 308 + let redirects_path = directory.join("_redirects"); 309 309 + 310 310 + if !redirects_path.exists() { 311 311 + return Vec::new(); 312 312 + } 313 313 + 314 314 + match fs::read_to_string(&redirects_path) { 315 315 + Ok(content) => parse_redirects_file(&content), 316 316 + Err(e) => { 317 317 + eprintln!("Failed to load _redirects file: {}", e); 318 318 + Vec::new() 319 319 + } 320 320 + } 321 321 + } 322 322 + 323 323 + #[cfg(test)] 324 324 + mod tests { 325 325 + use super::*; 326 326 + 327 327 + #[test] 328 328 + fn test_parse_simple_redirect() { 329 329 + let content = "/old-path /new-path"; 330 330 + let rules = parse_redirects_file(content); 331 331 + assert_eq!(rules.len(), 1); 332 332 + assert_eq!(rules[0].from, "/old-path"); 333 333 + assert_eq!(rules[0].to, "/new-path"); 334 334 + assert_eq!(rules[0].status, 301); 335 335 + assert!(!rules[0].force); 336 336 + } 337 337 + 338 338 + #[test] 339 339 + fn test_parse_with_status() { 340 340 + let content = "/temp /target 302"; 341 341 + let rules = parse_redirects_file(content); 342 342 + assert_eq!(rules[0].status, 302); 343 343 + } 344 344 + 345 345 + #[test] 346 346 + fn test_parse_force_redirect() { 347 347 + let content = "/force /target 301!"; 348 348 + let rules = parse_redirects_file(content); 349 349 + assert!(rules[0].force); 350 350 + } 351 351 + 352 352 + #[test] 353 353 + fn test_match_exact_path() { 354 354 + let rules = parse_redirects_file("/old-path /new-path"); 355 355 + let m = match_redirect_rule("/old-path", &rules, None); 356 356 + assert!(m.is_some()); 357 357 + assert_eq!(m.unwrap().target_path, "/new-path"); 358 358 + } 359 359 + 360 360 + #[test] 361 361 + fn test_match_splat() { 362 362 + let rules = parse_redirects_file("/news/* /blog/:splat"); 363 363 + let m = match_redirect_rule("/news/2024/01/15/post", &rules, None); 364 364 + assert!(m.is_some()); 365 365 + assert_eq!(m.unwrap().target_path, "/blog/2024/01/15/post"); 366 366 + } 367 367 + 368 368 + #[test] 369 369 + fn test_match_placeholders() { 370 370 + let rules = parse_redirects_file("/blog/:year/:month/:day /posts/:year-:month-:day"); 371 371 + let m = match_redirect_rule("/blog/2024/01/15", &rules, None); 372 372 + assert!(m.is_some()); 373 373 + assert_eq!(m.unwrap().target_path, "/posts/2024-01-15"); 374 374 + } 375 375 + }

+237 -64

cli/src/serve.rs

··· 1 1 use crate::pull::pull_site; 2 2 - use axum::Router; 2 2 + use crate::redirects::{load_redirect_rules, match_redirect_rule, RedirectRule}; 3 3 + use axum::{ 4 4 + Router, 5 5 + extract::Request, 6 6 + response::{Response, IntoResponse, Redirect}, 7 7 + http::{StatusCode, Uri}, 8 8 + }; 3 9 use jacquard::CowStr; 4 4 - use jacquard_common::jetstream::{CommitOperation, JetstreamMessage, JetstreamParams}; 10 10 + use jacquard::api::com_atproto::sync::subscribe_repos::{SubscribeRepos, SubscribeReposMessage}; 5 11 use jacquard_common::types::string::Did; 6 12 use jacquard_common::xrpc::{SubscriptionClient, TungsteniteSubscriptionClient}; 7 13 use miette::IntoDiagnostic; 8 14 use n0_future::StreamExt; 15 15 + use std::collections::HashMap; 9 16 use std::path::PathBuf; 10 17 use std::sync::Arc; 11 18 use tokio::sync::RwLock; 19 19 + use tower::Service; 12 20 use tower_http::compression::CompressionLayer; 13 21 use tower_http::services::ServeDir; 14 14 - use url::Url; 15 22 16 23 /// Shared state for the server 17 24 #[derive(Clone)] ··· 20 27 rkey: CowStr<'static>, 21 28 output_dir: PathBuf, 22 29 last_cid: Arc<RwLock<Option<String>>>, 30 30 + redirect_rules: Arc<RwLock<Vec<RedirectRule>>>, 23 31 } 24 32 25 33 /// Serve a site locally with real-time firehose updates ··· 54 62 let did_str = CowStr::from(did.as_str().to_string()); 55 63 pull_site(did_str.clone(), rkey.clone(), output_dir.clone()).await?; 56 64 65 65 + // Load redirect rules 66 66 + let redirect_rules = load_redirect_rules(&output_dir); 67 67 + if !redirect_rules.is_empty() { 68 68 + println!("Loaded {} redirect rules from _redirects", redirect_rules.len()); 69 69 + } 70 70 + 57 71 // Create shared state 58 72 let state = ServerState { 59 73 did: did_str.clone(), 60 74 rkey: rkey.clone(), 61 75 output_dir: output_dir.clone(), 62 76 last_cid: Arc::new(RwLock::new(None)), 77 77 + redirect_rules: Arc::new(RwLock::new(redirect_rules)), 63 78 }; 64 79 65 80 // Start firehose listener in background ··· 70 85 } 71 86 }); 72 87 73 73 - // Create HTTP server with gzip compression 88 88 + // Create HTTP server with gzip compression and redirect handling 89 89 + let serve_dir = ServeDir::new(&output_dir).precompressed_gzip(); 90 90 + 74 91 let app = Router::new() 75 75 - .fallback_service( 76 76 - ServeDir::new(&output_dir) 77 77 - .precompressed_gzip() 78 78 - ) 79 79 - .layer(CompressionLayer::new()) 80 80 - .with_state(state); 92 92 + .fallback(move |req: Request| { 93 93 + let state = state.clone(); 94 94 + let mut serve_dir = serve_dir.clone(); 95 95 + async move { 96 96 + handle_request_with_redirects(req, state, &mut serve_dir).await 97 97 + } 98 98 + }) 99 99 + .layer(CompressionLayer::new()); 81 100 82 101 let addr = format!("0.0.0.0:{}", port); 83 102 let listener = tokio::net::TcpListener::bind(&addr) ··· 90 109 axum::serve(listener, app).await.into_diagnostic()?; 91 110 92 111 Ok(()) 112 112 + } 113 113 + 114 114 + /// Handle a request with redirect support 115 115 + async fn handle_request_with_redirects( 116 116 + req: Request, 117 117 + state: ServerState, 118 118 + serve_dir: &mut ServeDir, 119 119 + ) -> Response { 120 120 + let uri = req.uri().clone(); 121 121 + let path = uri.path(); 122 122 + let method = req.method().clone(); 123 123 + 124 124 + // Parse query parameters 125 125 + let query_params = uri.query().map(|q| { 126 126 + let mut params = HashMap::new(); 127 127 + for pair in q.split('&') { 128 128 + if let Some((key, value)) = pair.split_once('=') { 129 129 + params.insert(key.to_string(), value.to_string()); 130 130 + } 131 131 + } 132 132 + params 133 133 + }); 134 134 + 135 135 + // Check for redirect rules 136 136 + let redirect_rules = state.redirect_rules.read().await; 137 137 + if let Some(redirect_match) = match_redirect_rule(path, &redirect_rules, query_params.as_ref()) { 138 138 + let is_force = redirect_match.force; 139 139 + drop(redirect_rules); // Release the lock 140 140 + 141 141 + // If not forced, check if the file exists first 142 142 + if !is_force { 143 143 + // Try to serve the file normally first 144 144 + let test_req = Request::builder() 145 145 + .uri(uri.clone()) 146 146 + .method(&method) 147 147 + .body(axum::body::Body::empty()) 148 148 + .unwrap(); 149 149 + 150 150 + match serve_dir.call(test_req).await { 151 151 + Ok(response) if response.status().is_success() => { 152 152 + // File exists and was served successfully, return it 153 153 + return response.into_response(); 154 154 + } 155 155 + _ => { 156 156 + // File doesn't exist or error, apply redirect 157 157 + } 158 158 + } 159 159 + } 160 160 + 161 161 + // Handle different status codes 162 162 + match redirect_match.status { 163 163 + 200 => { 164 164 + // Rewrite: serve the target file but keep the URL the same 165 165 + if let Ok(target_uri) = redirect_match.target_path.parse::<Uri>() { 166 166 + let new_req = Request::builder() 167 167 + .uri(target_uri) 168 168 + .method(&method) 169 169 + .body(axum::body::Body::empty()) 170 170 + .unwrap(); 171 171 + 172 172 + match serve_dir.call(new_req).await { 173 173 + Ok(response) => response.into_response(), 174 174 + Err(_) => StatusCode::INTERNAL_SERVER_ERROR.into_response(), 175 175 + } 176 176 + } else { 177 177 + StatusCode::INTERNAL_SERVER_ERROR.into_response() 178 178 + } 179 179 + } 180 180 + 301 => { 181 181 + // Permanent redirect 182 182 + Redirect::permanent(&redirect_match.target_path).into_response() 183 183 + } 184 184 + 302 => { 185 185 + // Temporary redirect 186 186 + Redirect::temporary(&redirect_match.target_path).into_response() 187 187 + } 188 188 + 404 => { 189 189 + // Custom 404 page 190 190 + if let Ok(target_uri) = redirect_match.target_path.parse::<Uri>() { 191 191 + let new_req = Request::builder() 192 192 + .uri(target_uri) 193 193 + .method(&method) 194 194 + .body(axum::body::Body::empty()) 195 195 + .unwrap(); 196 196 + 197 197 + match serve_dir.call(new_req).await { 198 198 + Ok(mut response) => { 199 199 + *response.status_mut() = StatusCode::NOT_FOUND; 200 200 + response.into_response() 201 201 + } 202 202 + Err(_) => StatusCode::NOT_FOUND.into_response(), 203 203 + } 204 204 + } else { 205 205 + StatusCode::NOT_FOUND.into_response() 206 206 + } 207 207 + } 208 208 + _ => { 209 209 + // Unsupported status code, fall through to normal serving 210 210 + match serve_dir.call(req).await { 211 211 + Ok(response) => response.into_response(), 212 212 + Err(_) => StatusCode::INTERNAL_SERVER_ERROR.into_response(), 213 213 + } 214 214 + } 215 215 + } 216 216 + } else { 217 217 + drop(redirect_rules); 218 218 + // No redirect match, serve normally 219 219 + match serve_dir.call(req).await { 220 220 + Ok(response) => response.into_response(), 221 221 + Err(_) => StatusCode::NOT_FOUND.into_response(), 222 222 + } 223 223 + } 93 224 } 94 225 95 226 /// Watch the firehose for updates to the specific site 96 227 fn watch_firehose(state: ServerState) -> std::pin::Pin<Box<dyn std::future::Future<Output = miette::Result<()>> + Send>> { 97 228 Box::pin(async move { 98 98 - let jetstream_url = Url::parse("wss://jetstream1.us-east.fire.hose.cam") 99 99 - .into_diagnostic()?; 229 229 + use jacquard_identity::PublicResolver; 230 230 + use jacquard::prelude::IdentityResolver; 231 231 + 232 232 + // Resolve DID to PDS URL 233 233 + let resolver = PublicResolver::default(); 234 234 + let did = Did::new(&state.did).into_diagnostic()?; 235 235 + let pds_url = resolver.pds_for_did(&did).await.into_diagnostic()?; 236 236 + 237 237 + println!("[PDS] Resolved DID to PDS: {}", pds_url); 238 238 + 239 239 + // Convert HTTP(S) URL to WebSocket URL 240 240 + let mut ws_url = pds_url.clone(); 241 241 + let scheme = if pds_url.scheme() == "https" { "wss" } else { "ws" }; 242 242 + ws_url.set_scheme(scheme) 243 243 + .map_err(|_| miette::miette!("Failed to set WebSocket scheme"))?; 100 244 101 101 - println!("[Firehose] Connecting to Jetstream..."); 245 245 + println!("[PDS] Connecting to {}...", ws_url); 102 246 103 247 // Create subscription client 104 104 - let client = TungsteniteSubscriptionClient::from_base_uri(jetstream_url); 248 248 + let client = TungsteniteSubscriptionClient::from_base_uri(ws_url); 105 249 106 106 - // Subscribe with no filters (we'll filter manually) 107 107 - // Jetstream doesn't support filtering by collection in the params builder 108 108 - let params = JetstreamParams::new().build(); 250 250 + // Subscribe to the PDS firehose 251 251 + let params = SubscribeRepos::new().build(); 109 252 110 253 let stream = client.subscribe(&params).await.into_diagnostic()?; 111 111 - println!("[Firehose] Connected! Watching for updates..."); 254 254 + println!("[PDS] Connected! Watching for updates..."); 112 255 113 256 // Convert to typed message stream 114 257 let (_sink, mut messages) = stream.into_stream(); ··· 117 260 match messages.next().await { 118 261 Some(Ok(msg)) => { 119 262 if let Err(e) = handle_firehose_message(&state, msg).await { 120 120 - eprintln!("[Firehose] Error handling message: {}", e); 263 263 + eprintln!("[PDS] Error handling message: {}", e); 121 264 } 122 265 } 123 266 Some(Err(e)) => { 124 124 - eprintln!("[Firehose] Stream error: {}", e); 267 267 + eprintln!("[PDS] Stream error: {}", e); 125 268 // Try to reconnect after a delay 126 269 tokio::time::sleep(tokio::time::Duration::from_secs(5)).await; 127 270 return Box::pin(watch_firehose(state)).await; 128 271 } 129 272 None => { 130 130 - println!("[Firehose] Stream ended, reconnecting..."); 273 273 + println!("[PDS] Stream ended, reconnecting..."); 131 274 tokio::time::sleep(tokio::time::Duration::from_secs(5)).await; 132 275 return Box::pin(watch_firehose(state)).await; 133 276 } ··· 137 280 } 138 281 139 282 /// Handle a firehose message 140 140 - async fn handle_firehose_message( 283 283 + async fn handle_firehose_message<'a>( 141 284 state: &ServerState, 142 142 - msg: JetstreamMessage<'_>, 285 285 + msg: SubscribeReposMessage<'a>, 143 286 ) -> miette::Result<()> { 144 287 match msg { 145 145 - JetstreamMessage::Commit { 146 146 - did, 147 147 - commit, 148 148 - .. 149 149 - } => { 150 150 - // Check if this is our site 151 151 - if did.as_str() == state.did.as_str() 152 152 - && commit.collection.as_str() == "place.wisp.fs" 153 153 - && commit.rkey.as_str() == state.rkey.as_str() 154 154 - { 155 155 - match commit.operation { 156 156 - CommitOperation::Create | CommitOperation::Update => { 157 157 - let new_cid = commit.cid.as_ref().map(|c| c.to_string()); 158 158 - 159 159 - // Check if CID changed 160 160 - let should_update = { 161 161 - let last_cid = state.last_cid.read().await; 162 162 - new_cid != *last_cid 163 163 - }; 288 288 + SubscribeReposMessage::Commit(commit_msg) => { 289 289 + // Check if this commit is from our DID 290 290 + if commit_msg.repo.as_str() != state.did.as_str() { 291 291 + return Ok(()); 292 292 + } 164 293 165 165 - if should_update { 166 166 - println!("\n[Update] Detected change to site {} (CID: {:?})", state.rkey, new_cid); 167 167 - println!("[Update] Pulling latest version..."); 294 294 + // Check if any operation affects our site 295 295 + let target_path = format!("place.wisp.fs/{}", state.rkey); 296 296 + let has_site_update = commit_msg.ops.iter().any(|op| op.path.as_ref() == target_path); 168 297 169 169 - // Pull the updated site 170 170 - match pull_site( 171 171 - state.did.clone(), 172 172 - state.rkey.clone(), 173 173 - state.output_dir.clone(), 174 174 - ) 175 175 - .await 176 176 - { 177 177 - Ok(_) => { 178 178 - // Update last CID 179 179 - let mut last_cid = state.last_cid.write().await; 180 180 - *last_cid = new_cid; 181 181 - println!("[Update] ✓ Site updated successfully!\n"); 182 182 - } 183 183 - Err(e) => { 184 184 - eprintln!("[Update] Failed to pull site: {}", e); 185 185 - } 298 298 + if has_site_update { 299 299 + // Debug: log all operations for this commit 300 300 + println!("[Debug] Commit has {} ops for {}", commit_msg.ops.len(), state.rkey); 301 301 + for op in &commit_msg.ops { 302 302 + if op.path.as_ref() == target_path { 303 303 + println!("[Debug] - {} {}", op.action.as_ref(), op.path.as_ref()); 304 304 + } 305 305 + } 306 306 + } 307 307 + 308 308 + if has_site_update { 309 309 + // Use the commit CID as the version tracker 310 310 + let commit_cid = commit_msg.commit.to_string(); 311 311 + 312 312 + // Check if this is a new commit 313 313 + let should_update = { 314 314 + let last_cid = state.last_cid.read().await; 315 315 + Some(commit_cid.clone()) != *last_cid 316 316 + }; 317 317 + 318 318 + if should_update { 319 319 + // Check operation types 320 320 + let has_create_or_update = commit_msg.ops.iter().any(|op| { 321 321 + op.path.as_ref() == target_path && 322 322 + (op.action.as_ref() == "create" || op.action.as_ref() == "update") 323 323 + }); 324 324 + let has_delete = commit_msg.ops.iter().any(|op| { 325 325 + op.path.as_ref() == target_path && op.action.as_ref() == "delete" 326 326 + }); 327 327 + 328 328 + // If there's a create/update, pull the site (even if there's also a delete in the same commit) 329 329 + if has_create_or_update { 330 330 + println!("\n[Update] Detected change to site {} (commit: {})", state.rkey, commit_cid); 331 331 + println!("[Update] Pulling latest version..."); 332 332 + 333 333 + // Pull the updated site 334 334 + match pull_site( 335 335 + state.did.clone(), 336 336 + state.rkey.clone(), 337 337 + state.output_dir.clone(), 338 338 + ) 339 339 + .await 340 340 + { 341 341 + Ok(_) => { 342 342 + // Update last CID 343 343 + let mut last_cid = state.last_cid.write().await; 344 344 + *last_cid = Some(commit_cid); 345 345 + 346 346 + // Reload redirect rules 347 347 + let new_redirect_rules = load_redirect_rules(&state.output_dir); 348 348 + let mut redirect_rules = state.redirect_rules.write().await; 349 349 + *redirect_rules = new_redirect_rules; 350 350 + 351 351 + println!("[Update] ✓ Site updated successfully!\n"); 352 352 + } 353 353 + Err(e) => { 354 354 + eprintln!("[Update] Failed to pull site: {}", e); 186 355 } 187 356 } 188 188 - } 189 189 - CommitOperation::Delete => { 357 357 + } else if has_delete { 358 358 + // Only a delete, no create/update 190 359 println!("\n[Update] Site {} was deleted", state.rkey); 360 360 + 361 361 + // Update last CID so we don't process this commit again 362 362 + let mut last_cid = state.last_cid.write().await; 363 363 + *last_cid = Some(commit_cid); 191 364 } 192 365 } 193 366 }