add landing page and nostr-relay-builder relay on same port

2 files changed, 74 insertions, 87 deletions

diff --git a/tests/nip01_compliance.rs b/tests/nip01_compliance.rs
index 3e2fdd3..05957fd 100644
--- a/tests/nip01_compliance.rs
+++ b/tests/nip01_compliance.rs
@@ -39,22 +39,22 @@ use grasp_audit::*;
 async fn test_nip01_smoke() {
     // Start test relay
     let relay = TestRelay::start().await;
-    
+
     // Create audit client in CI mode (isolated, no cleanup needed)
     let config = AuditConfig::ci();
     let client = AuditClient::new(relay.url(), config)
         .await
         .expect("Failed to create audit client");
-    
+
     // Run all NIP-01 smoke tests
     let results = specs::Nip01SmokeTests::run_all(&client).await;
-    
+
     // Print detailed report
     results.print_report();
-    
+
     // Stop relay
     relay.stop().await;
-    
+
     // Assert all tests passed
     assert!(
         results.all_passed(),
@@ -70,20 +70,20 @@ async fn test_nip01_smoke() {
 /// for more granular testing or debugging.
 #[tokio::test]
 async fn test_nip01_individual_tests() {
-    use grasp_audit::specs::nip01_smoke::Nip01SmokeTests;
-    
+    use grasp_audit::specs::grasp01::Nip01SmokeTests;
+
     let relay = TestRelay::start().await;
     let config = AuditConfig::ci();
     let client = AuditClient::new(relay.url(), config)
         .await
         .expect("Failed to create audit client");
-    
+
     // We can't call private methods, so we'll run the full suite
     // This test is mainly to show the pattern
     let all_results = Nip01SmokeTests::run_all(&client).await;
-    
+
     relay.stop().await;
-    
+
     // Verify
     assert!(all_results.all_passed());
 }
@@ -99,25 +99,25 @@ async fn test_relay_validates_events() {
     let client = AuditClient::new(relay.url(), config)
         .await
         .expect("Failed to create audit client");
-    
+
     // The validation tests are part of the smoke tests
     let results = specs::Nip01SmokeTests::run_all(&client).await;
-    
+
     // Check that validation tests exist and pass
     let validation_tests: Vec<_> = results
         .results
         .iter()
         .filter(|t| t.spec_ref.contains("validation"))
         .collect();
-    
+
     relay.stop().await;
-    
+
     // Should have validation tests
     assert!(
         !validation_tests.is_empty(),
         "No validation tests found in NIP-01 smoke tests"
     );
-    
+
     // All validation tests should pass
     for test in validation_tests {
         assert!(
@@ -137,18 +137,18 @@ async fn test_relay_lifecycle() {
     // Start relay
     let relay = TestRelay::start().await;
     let url = relay.url().to_string();
-    
+
     // Verify we can connect
     let config = AuditConfig::ci();
     let client = AuditClient::new(&url, config)
         .await
         .expect("Failed to connect to relay");
-    
+
     assert!(client.is_connected().await, "Client should be connected");
-    
+
     // Stop relay
     relay.stop().await;
-    
+
     // Note: We can't easily verify disconnection without modifying grasp-audit
     // to expose connection state after relay shutdown. That's okay - the
     // important part is that the relay starts and stops cleanly.
@@ -162,28 +162,28 @@ async fn test_parallel_relays() {
     // Start two relays simultaneously
     let relay1 = TestRelay::start().await;
     let relay2 = TestRelay::start().await;
-    
+
     // Should have different URLs (different ports)
     assert_ne!(
         relay1.url(),
         relay2.url(),
         "Relays should use different ports"
     );
-    
+
     // Both should be connectable
     let config = AuditConfig::ci();
-    
+
     let client1 = AuditClient::new(relay1.url(), config.clone())
         .await
         .expect("Failed to connect to relay 1");
-    
+
     let client2 = AuditClient::new(relay2.url(), config)
         .await
         .expect("Failed to connect to relay 2");
-    
+
     assert!(client1.is_connected().await);
     assert!(client2.is_connected().await);
-    
+
     // Clean up
     relay1.stop().await;
     relay2.stop().await;
diff --git a/tests/nip34_announcements.rs b/tests/nip34_announcements.rs
index 6e83bb6..535425d 100644
--- a/tests/nip34_announcements.rs
+++ b/tests/nip34_announcements.rs
@@ -36,7 +36,9 @@ const KIND_REPOSITORY_ANNOUNCEMENT: u16 = 30617;
 const KIND_REPOSITORY_STATE: u16 = 30618;
 
 /// Helper to connect to a test relay
-async fn connect_to_relay(url: &str) -> tokio_tungstenite::WebSocketStream<tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>> {
+async fn connect_to_relay(
+    url: &str,
+) -> tokio_tungstenite::WebSocketStream<tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>> {
     let (ws, _) = connect_async(url)
         .await
         .expect("Failed to connect to relay");
@@ -54,10 +56,7 @@ fn create_announcement(
     let mut tags = vec![Tag::custom(TagKind::d(), vec![identifier.to_string()])];
 
     for url in clone_urls {
-        tags.push(Tag::custom(
-            TagKind::Clone,
-            vec![url],
-        ));
+        tags.push(Tag::custom(TagKind::Clone, vec![url]));
     }
 
     for relay in relays {
@@ -94,10 +93,10 @@ fn create_state(keys: &Keys, identifier: &str, branches: Vec<(&str, &str)>) -> n
 #[tokio::test]
 async fn test_relay_accepts_connection() {
     let relay = TestRelay::start().await;
-    
+
     // Try to connect
     let ws = connect_to_relay(relay.url()).await;
-    
+
     drop(ws); // Clean disconnect
 }
 
@@ -119,14 +118,14 @@ async fn test_accepts_valid_announcement() {
 
     // Send event
     let event_msg = json!(["EVENT", event]);
-    ws.send(Message::Text(event_msg.to_string()))
+    ws.send(Message::Text(event_msg.to_string().into()))
         .await
         .expect("Failed to send event");
 
     // Read response
     if let Some(Ok(Message::Text(text))) = ws.next().await {
         let response: Value = serde_json::from_str(&text).expect("Failed to parse response");
-        
+
         // Should be ["OK", event_id, true, ""]
         assert_eq!(response[0], "OK");
         assert_eq!(response[1], event.id.to_hex());
@@ -146,9 +145,7 @@ async fn test_rejects_announcement_without_clone() {
     let relay = TestRelay::start().await;
     let keys = Keys::generate();
 
-    let (mut ws, _) = connect_async(relay.url())
-        .await
-        .expect("Failed to connect");
+    let (mut ws, _) = connect_async(relay.url()).await.expect("Failed to connect");
 
     // Missing clone tag
     let event = create_announcement(
@@ -160,18 +157,18 @@ async fn test_rejects_announcement_without_clone() {
     );
 
     let event_msg = json!(["EVENT", event]);
-    ws.send(Message::Text(event_msg.to_string()))
+    ws.send(Message::Text(event_msg.to_string().into()))
         .await
         .expect("Failed to send event");
 
     if let Some(Ok(Message::Text(text))) = ws.next().await {
         let response: Value = serde_json::from_str(&text).expect("Failed to parse");
-        
+
         // Should be rejected
         assert_eq!(response[0], "OK");
         assert_eq!(response[1], event.id.to_hex());
         assert_eq!(response[2], false, "Event should be rejected");
-        
+
         let message = response[3].as_str().unwrap();
         assert!(
             message.contains("clone") || message.contains("invalid"),
@@ -190,9 +187,7 @@ async fn test_rejects_announcement_without_relay() {
     let relay = TestRelay::start().await;
     let keys = Keys::generate();
 
-    let (mut ws, _) = connect_async(relay.url())
-        .await
-        .expect("Failed to connect");
+    let (mut ws, _) = connect_async(relay.url()).await.expect("Failed to connect");
 
     // Missing relay tag
     let event = create_announcement(
@@ -204,18 +199,18 @@ async fn test_rejects_announcement_without_relay() {
     );
 
     let event_msg = json!(["EVENT", event]);
-    ws.send(Message::Text(event_msg.to_string()))
+    ws.send(Message::Text(event_msg.to_string().into()))
         .await
         .expect("Failed to send event");
 
     if let Some(Ok(Message::Text(text))) = ws.next().await {
         let response: Value = serde_json::from_str(&text).expect("Failed to parse");
-        
+
         // Should be rejected
         assert_eq!(response[0], "OK");
         assert_eq!(response[1], event.id.to_hex());
         assert_eq!(response[2], false, "Event should be rejected");
-        
+
         let message = response[3].as_str().unwrap();
         assert!(
             message.contains("relays") || message.contains("invalid"),
@@ -233,9 +228,7 @@ async fn test_rejects_announcement_for_other_service() {
     let relay = TestRelay::start().await;
     let keys = Keys::generate();
 
-    let (mut ws, _) = connect_async(relay.url())
-        .await
-        .expect("Failed to connect");
+    let (mut ws, _) = connect_async(relay.url()).await.expect("Failed to connect");
 
     // Lists different service
     let event = create_announcement(
@@ -247,13 +240,13 @@ async fn test_rejects_announcement_for_other_service() {
     );
 
     let event_msg = json!(["EVENT", event]);
-    ws.send(Message::Text(event_msg.to_string()))
+    ws.send(Message::Text(event_msg.to_string().into()))
         .await
         .expect("Failed to send event");
 
     if let Some(Ok(Message::Text(text))) = ws.next().await {
         let response: Value = serde_json::from_str(&text).expect("Failed to parse");
-        
+
         // Should be rejected
         assert_eq!(response[0], "OK");
         assert_eq!(response[1], event.id.to_hex());
@@ -269,9 +262,7 @@ async fn test_accepts_valid_state() {
     let relay = TestRelay::start().await;
     let keys = Keys::generate();
 
-    let (mut ws, _) = connect_async(relay.url())
-        .await
-        .expect("Failed to connect");
+    let (mut ws, _) = connect_async(relay.url()).await.expect("Failed to connect");
 
     let event = create_state(
         &keys,
@@ -280,13 +271,13 @@ async fn test_accepts_valid_state() {
     );
 
     let event_msg = json!(["EVENT", event]);
-    ws.send(Message::Text(event_msg.to_string()))
+    ws.send(Message::Text(event_msg.to_string().into()))
         .await
         .expect("Failed to send event");
 
     if let Some(Ok(Message::Text(text))) = ws.next().await {
         let response: Value = serde_json::from_str(&text).expect("Failed to parse");
-        
+
         // Should be accepted
         assert_eq!(response[0], "OK");
         assert_eq!(response[1], event.id.to_hex());
@@ -302,9 +293,7 @@ async fn test_accepts_state_with_multiple_branches() {
     let relay = TestRelay::start().await;
     let keys = Keys::generate();
 
-    let (mut ws, _) = connect_async(relay.url())
-        .await
-        .expect("Failed to connect");
+    let (mut ws, _) = connect_async(relay.url()).await.expect("Failed to connect");
 
     let event = create_state(
         &keys,
@@ -317,13 +306,13 @@ async fn test_accepts_state_with_multiple_branches() {
     );
 
     let event_msg = json!(["EVENT", event]);
-    ws.send(Message::Text(event_msg.to_string()))
+    ws.send(Message::Text(event_msg.to_string().into()))
         .await
         .expect("Failed to send event");
 
     if let Some(Ok(Message::Text(text))) = ws.next().await {
         let response: Value = serde_json::from_str(&text).expect("Failed to parse");
-        
+
         assert_eq!(response[0], "OK");
         assert_eq!(response[2], true, "State event should be accepted");
     } else {
@@ -337,9 +326,7 @@ async fn test_rejects_state_without_identifier() {
     let relay = TestRelay::start().await;
     let keys = Keys::generate();
 
-    let (mut ws, _) = connect_async(relay.url())
-        .await
-        .expect("Failed to connect");
+    let (mut ws, _) = connect_async(relay.url()).await.expect("Failed to connect");
 
     // Create state without identifier
     let event = EventBuilder::new(Kind::from(KIND_REPOSITORY_STATE), "")
@@ -347,18 +334,18 @@ async fn test_rejects_state_without_identifier() {
         .expect("Failed to sign event");
 
     let event_msg = json!(["EVENT", event]);
-    ws.send(Message::Text(event_msg.to_string()))
+    ws.send(Message::Text(event_msg.to_string().into()))
         .await
         .expect("Failed to send event");
 
     if let Some(Ok(Message::Text(text))) = ws.next().await {
         let response: Value = serde_json::from_str(&text).expect("Failed to parse");
-        
+
         // Should be rejected
         assert_eq!(response[0], "OK");
         assert_eq!(response[1], event.id.to_hex());
         assert_eq!(response[2], false, "Event should be rejected");
-        
+
         let message = response[3].as_str().unwrap();
         assert!(
             message.contains("identifier") || message.contains("invalid"),
@@ -376,21 +363,22 @@ async fn test_query_announcements() {
     let relay = TestRelay::start().await;
     let keys = Keys::generate();
 
-    let (mut ws, _) = connect_async(relay.url())
-        .await
-        .expect("Failed to connect");
+    let (mut ws, _) = connect_async(relay.url()).await.expect("Failed to connect");
 
     // Send an announcement
     let event = create_announcement(
         &keys,
         &relay.domain(),
         "query-test-repo",
-        vec![format!("https://{}/alice/query-test-repo.git", relay.domain())],
+        vec![format!(
+            "https://{}/alice/query-test-repo.git",
+            relay.domain()
+        )],
         vec![format!("wss://{}", relay.domain())],
     );
 
     let event_msg = json!(["EVENT", event]);
-    ws.send(Message::Text(event_msg.to_string()))
+    ws.send(Message::Text(event_msg.to_string().into()))
         .await
         .expect("Failed to send event");
 
@@ -409,7 +397,7 @@ async fn test_query_announcements() {
         }
     ]);
 
-    ws.send(Message::Text(req.to_string()))
+    ws.send(Message::Text(req.to_string().into()))
         .await
         .expect("Failed to send REQ");
 
@@ -420,7 +408,7 @@ async fn test_query_announcements() {
     for _ in 0..10 {
         if let Some(Ok(Message::Text(text))) = ws.next().await {
             let response: Value = serde_json::from_str(&text).expect("Failed to parse");
-            
+
             if response[0] == "EVENT" {
                 assert_eq!(response[1], "test-sub");
                 found_event = true;
@@ -442,9 +430,7 @@ async fn test_query_states() {
     let relay = TestRelay::start().await;
     let keys = Keys::generate();
 
-    let (mut ws, _) = connect_async(relay.url())
-        .await
-        .expect("Failed to connect");
+    let (mut ws, _) = connect_async(relay.url()).await.expect("Failed to connect");
 
     // Send a state event
     let event = create_state(
@@ -454,7 +440,7 @@ async fn test_query_states() {
     );
 
     let event_msg = json!(["EVENT", event]);
-    ws.send(Message::Text(event_msg.to_string()))
+    ws.send(Message::Text(event_msg.to_string().into()))
         .await
         .expect("Failed to send event");
 
@@ -473,7 +459,7 @@ async fn test_query_states() {
         }
     ]);
 
-    ws.send(Message::Text(req.to_string()))
+    ws.send(Message::Text(req.to_string().into()))
         .await
         .expect("Failed to send REQ");
 
@@ -484,7 +470,7 @@ async fn test_query_states() {
     for _ in 0..10 {
         if let Some(Ok(Message::Text(text))) = ws.next().await {
             let response: Value = serde_json::from_str(&text).expect("Failed to parse");
-            
+
             if response[0] == "EVENT" {
                 assert_eq!(response[1], "test-sub");
                 found_event = true;
@@ -506,21 +492,22 @@ async fn test_duplicate_announcement() {
     let relay = TestRelay::start().await;
     let keys = Keys::generate();
 
-    let (mut ws, _) = connect_async(relay.url())
-        .await
-        .expect("Failed to connect");
+    let (mut ws, _) = connect_async(relay.url()).await.expect("Failed to connect");
 
     let event = create_announcement(
         &keys,
         &relay.domain(),
         "duplicate-test",
-        vec![format!("https://{}/alice/duplicate-test.git", relay.domain())],
+        vec![format!(
+            "https://{}/alice/duplicate-test.git",
+            relay.domain()
+        )],
         vec![format!("wss://{}", relay.domain())],
     );
 
     // Send first time
     let event_msg = json!(["EVENT", event]);
-    ws.send(Message::Text(event_msg.to_string()))
+    ws.send(Message::Text(event_msg.to_string().into()))
         .await
         .expect("Failed to send event");
 
@@ -531,14 +518,14 @@ async fn test_duplicate_announcement() {
 
     // Send second time (duplicate)
     let event_msg = json!(["EVENT", event]);
-    ws.send(Message::Text(event_msg.to_string()))
+    ws.send(Message::Text(event_msg.to_string().into()))
         .await
         .expect("Failed to send event");
 
     if let Some(Ok(Message::Text(text))) = ws.next().await {
         let response2: Value = serde_json::from_str(&text).expect("Failed to parse");
         assert_eq!(response2[2], true, "Duplicate should be acknowledged");
-        
+
         let message = response2[3].as_str().unwrap();
         assert!(
             message.contains("duplicate") || message.is_empty(),