feat: fun handle resolution during migration #17

+1 -6

TODO.md

··· 74 74 75 75 ### Misc 76 76 77 77 - migration handle preservation 78 78 - - [ ] allow users to keep their existing handle during migration (eg. lewis.moe instead of forcing lewis.newpds.com) 79 79 - - [ ] UI option to preserve external handle vs create new pds-subdomain handle 80 80 - - [ ] handle the DNS verification flow for external handles during migration 81 81 - 82 77 cross-pds delegation 83 78 when a client (eg. tangled.org) tries to log into a delegated account: 84 79 - [ ] client starts oauth flow to delegated account's pds ··· 162 157 163 158 Account Delegation: Delegated accounts controlled by other accounts instead of passwords. OAuth delegation flow (authenticate as controller), scope-based permissions (owner/admin/editor/viewer presets), scope intersection (tokens limited to granted permissions), `act` claim for delegation tracking, creating delegated account flow, controller management UI, "act as" account switcher, comprehensive audit logging with actor/controller tracking, delegation-aware OAuth consent with permission limitation notices. 164 159 165 165 - Migration: OAuth-based inbound migration wizard with PLC token flow, offline restore from CAR file + rotation key for disaster recovery, scheduled automatic backups, standalone repo/blob export, did:web DID document editor for self-service identity management. 160 160 + Migration: OAuth-based inbound migration wizard with PLC token flow, offline restore from CAR file + rotation key for disaster recovery, scheduled automatic backups, standalone repo/blob export, did:web DID document editor for self-service identity management, handle preservation (keep existing external handle via DNS/HTTP verification or create new PDS-subdomain handle).

+4 -4

crates/tranquil-db/src/postgres/repo.rs

··· 1159 1159 None => return Err(ImportRepoError::RepoNotFound), 1160 1160 }; 1161 1161 1162 1162 - if let Some(expected) = expected_root_cid { 1163 1163 - if repo.repo_root_cid.as_str() != expected.as_str() { 1164 1164 - return Err(ImportRepoError::ConcurrentModification); 1165 1165 - } 1162 1162 + if let Some(expected) = expected_root_cid 1163 1163 + && repo.repo_root_cid.as_str() != expected.as_str() 1164 1164 + { 1165 1165 + return Err(ImportRepoError::ConcurrentModification); 1166 1166 } 1167 1167 1168 1168 let block_chunks: Vec<Vec<&ImportBlock>> = blocks

+12 -9

crates/tranquil-pds/src/api/discord_webhook.rs

··· 108 108 1 => Json(json!({"type": 1})).into_response(), 109 109 2 => handle_command(state, interaction).await, 110 110 other => { 111 111 - debug!(interaction_type = other, "Received unknown Discord interaction type"); 111 111 + debug!( 112 112 + interaction_type = other, 113 113 + "Received unknown Discord interaction type" 114 114 + ); 112 115 StatusCode::OK.into_response() 113 116 } 114 117 } ··· 148 151 149 152 let handle = parse_start_handle(interaction.data.as_ref().and_then(|d| d.options.as_deref())); 150 153 151 151 - if let Some(ref h) = handle { 152 152 - if Handle::new(h).is_err() { 153 153 - return Json(json!({ 154 154 - "type": 4, 155 155 - "data": {"content": "Invalid handle format. Handle should look like: alice.example.com", "flags": 64} 156 156 - })) 157 157 - .into_response(); 158 158 - } 154 154 + if let Some(ref h) = handle 155 155 + && Handle::new(h).is_err() 156 156 + { 157 157 + return Json(json!({ 158 158 + "type": 4, 159 159 + "data": {"content": "Invalid handle format. Handle should look like: alice.example.com", "flags": 64} 160 160 + })) 161 161 + .into_response(); 159 162 } 160 163 161 164 debug!(

+76

crates/tranquil-pds/src/api/identity/handle.rs

··· 1 1 + use crate::api::error::ApiError; 2 2 + use crate::rate_limit::{HandleVerificationLimit, RateLimited}; 3 3 + use crate::types::{Did, Handle}; 4 4 + use axum::{ 5 5 + Json, 6 6 + response::{IntoResponse, Response}, 7 7 + }; 8 8 + use serde::{Deserialize, Serialize}; 9 9 + 10 10 + #[derive(Deserialize)] 11 11 + pub struct VerifyHandleOwnershipInput { 12 12 + pub handle: String, 13 13 + pub did: Did, 14 14 + } 15 15 + 16 16 + #[derive(Serialize)] 17 17 + #[serde(rename_all = "camelCase")] 18 18 + pub struct VerifyHandleOwnershipOutput { 19 19 + pub verified: bool, 20 20 + #[serde(skip_serializing_if = "Option::is_none")] 21 21 + pub method: Option<String>, 22 22 + #[serde(skip_serializing_if = "Option::is_none")] 23 23 + pub error: Option<String>, 24 24 + } 25 25 + 26 26 + pub async fn verify_handle_ownership( 27 27 + _rate_limit: RateLimited<HandleVerificationLimit>, 28 28 + Json(input): Json<VerifyHandleOwnershipInput>, 29 29 + ) -> Response { 30 30 + let handle: Handle = match input.handle.parse() { 31 31 + Ok(h) => h, 32 32 + Err(_) => { 33 33 + return ApiError::InvalidHandle(Some("Invalid handle format".into())).into_response(); 34 34 + } 35 35 + }; 36 36 + 37 37 + let handle_str = handle.as_str(); 38 38 + let did_str = input.did.as_str(); 39 39 + 40 40 + let dns_mismatch = match crate::handle::resolve_handle_dns(handle_str).await { 41 41 + Ok(did) if did == did_str => { 42 42 + return Json(VerifyHandleOwnershipOutput { 43 43 + verified: true, 44 44 + method: Some("dns".to_string()), 45 45 + error: None, 46 46 + }) 47 47 + .into_response(); 48 48 + } 49 49 + Ok(did) => Some(format!( 50 50 + "DNS record points to {}, expected {}", 51 51 + did, did_str 52 52 + )), 53 53 + Err(_) => None, 54 54 + }; 55 55 + 56 56 + match crate::handle::resolve_handle_http(handle_str).await { 57 57 + Ok(did) if did == did_str => Json(VerifyHandleOwnershipOutput { 58 58 + verified: true, 59 59 + method: Some("http".to_string()), 60 60 + error: None, 61 61 + }) 62 62 + .into_response(), 63 63 + Ok(did) => Json(VerifyHandleOwnershipOutput { 64 64 + verified: false, 65 65 + method: None, 66 66 + error: Some(format!("Handle resolves to {}, expected {}", did, did_str)), 67 67 + }) 68 68 + .into_response(), 69 69 + Err(e) => Json(VerifyHandleOwnershipOutput { 70 70 + verified: false, 71 71 + method: None, 72 72 + error: Some(dns_mismatch.unwrap_or_else(|| format!("Handle resolution failed: {}", e))), 73 73 + }) 74 74 + .into_response(), 75 75 + } 76 76 + }

+2

crates/tranquil-pds/src/api/identity/mod.rs

··· 1 1 pub mod account; 2 2 pub mod did; 3 3 + pub mod handle; 3 4 pub mod plc; 4 5 5 6 pub use account::create_account; ··· 7 8 get_recommended_did_credentials, resolve_handle, update_handle, user_did_doc, 8 9 well_known_atproto_did, well_known_did, 9 10 }; 11 11 + pub use handle::verify_handle_ownership; 10 12 pub use plc::{request_plc_operation_signature, sign_plc_operation, submit_plc_operation};

+6 -2

crates/tranquil-pds/src/api/validation.rs

··· 550 550 assert!(is_valid_discord_username("user.name")); 551 551 assert!(is_valid_discord_username("user123")); 552 552 assert!(is_valid_discord_username("a_b.c_d")); 553 553 - assert!(is_valid_discord_username("12345678901234567890123456789012")); 553 553 + assert!(is_valid_discord_username( 554 554 + "12345678901234567890123456789012" 555 555 + )); 554 556 } 555 557 556 558 #[test] ··· 564 566 assert!(!is_valid_discord_username("username.")); 565 567 assert!(!is_valid_discord_username("user..name")); 566 568 assert!(!is_valid_discord_username("user name")); 567 567 - assert!(!is_valid_discord_username("123456789012345678901234567890123")); 569 569 + assert!(!is_valid_discord_username( 570 570 + "123456789012345678901234567890123" 571 571 + )); 568 572 } 569 573 }

+1 -1

crates/tranquil-pds/src/auth/verification_token.rs

··· 300 300 } 301 301 302 302 pub fn normalize_token_input(input: &str) -> String { 303 303 - input.trim().to_string() 303 303 + input.chars().filter(|c| !c.is_whitespace()).collect() 304 304 } 305 305 306 306 #[cfg(test)]

+4

crates/tranquil-pds/src/lib.rs

··· 337 337 "/com.atproto.identity.submitPlcOperation", 338 338 post(api::identity::submit_plc_operation), 339 339 ) 340 340 + .route( 341 341 + "/_identity.verifyHandleOwnership", 342 342 + post(api::identity::verify_handle_ownership), 343 343 + ) 340 344 .route("/com.atproto.repo.importRepo", post(api::repo::import_repo)) 341 345 .route( 342 346 "/com.atproto.admin.deleteAccount",

+5

crates/tranquil-pds/src/rate_limit/extractor.rs

··· 110 110 const KIND: RateLimitKind = RateLimitKind::OAuthRegisterComplete; 111 111 } 112 112 113 113 + pub struct HandleVerificationLimit; 114 114 + impl RateLimitPolicy for HandleVerificationLimit { 115 115 + const KIND: RateLimitKind = RateLimitKind::HandleVerification; 116 116 + } 117 117 + 113 118 pub trait RateLimitRejection: IntoResponse + Send + 'static { 114 119 fn new() -> Self; 115 120 }

+4

crates/tranquil-pds/src/rate_limit/mod.rs

··· 33 33 pub sso_callback: Arc<KeyedRateLimiter>, 34 34 pub sso_unlink: Arc<KeyedRateLimiter>, 35 35 pub oauth_register_complete: Arc<KeyedRateLimiter>, 36 36 + pub handle_verification: Arc<KeyedRateLimiter>, 36 37 } 37 38 38 39 impl Default for RateLimiters { ··· 109 110 .unwrap() 110 111 .allow_burst(NonZeroU32::new(5).unwrap()), 111 112 )), 113 113 + handle_verification: Arc::new(RateLimiter::keyed(Quota::per_minute( 114 114 + NonZeroU32::new(10).unwrap(), 115 115 + ))), 112 116 } 113 117 } 114 118

+4

crates/tranquil-pds/src/state.rs

··· 71 71 SsoCallback, 72 72 SsoUnlink, 73 73 OAuthRegisterComplete, 74 74 + HandleVerification, 74 75 } 75 76 76 77 impl RateLimitKind { ··· 95 96 Self::SsoCallback => "sso_callback", 96 97 Self::SsoUnlink => "sso_unlink", 97 98 Self::OAuthRegisterComplete => "oauth_register_complete", 99 99 + Self::HandleVerification => "handle_verification", 98 100 } 99 101 } 100 102 ··· 119 121 Self::SsoCallback => (30, 60_000), 120 122 Self::SsoUnlink => (10, 60_000), 121 123 Self::OAuthRegisterComplete => (5, 300_000), 124 124 + Self::HandleVerification => (10, 60_000), 122 125 } 123 126 } 124 127 } ··· 271 274 RateLimitKind::SsoCallback => &self.rate_limiters.sso_callback, 272 275 RateLimitKind::SsoUnlink => &self.rate_limiters.sso_unlink, 273 276 RateLimitKind::OAuthRegisterComplete => &self.rate_limiters.oauth_register_complete, 277 277 + RateLimitKind::HandleVerification => &self.rate_limiters.handle_verification, 274 278 }; 275 279 276 280 let ok = limiter.check_key(&client_ip.to_string()).is_ok();

+96

crates/tranquil-pds/tests/identity.rs

··· 531 531 assert_eq!(body["error"], "InvalidHandle"); 532 532 assert!(body["message"].as_str().unwrap().contains("long")); 533 533 } 534 534 + 535 535 + #[tokio::test] 536 536 + async fn test_verify_handle_ownership_invalid_did() { 537 537 + let client = client(); 538 538 + let res = client 539 539 + .post(format!( 540 540 + "{}/xrpc/_identity.verifyHandleOwnership", 541 541 + base_url().await 542 542 + )) 543 543 + .json(&json!({ 544 544 + "handle": "some.handle.test", 545 545 + "did": "not-a-did" 546 546 + })) 547 547 + .send() 548 548 + .await 549 549 + .expect("Failed to send request"); 550 550 + assert_eq!(res.status(), StatusCode::UNPROCESSABLE_ENTITY); 551 551 + } 552 552 + 553 553 + #[tokio::test] 554 554 + async fn test_verify_handle_ownership_invalid_handle() { 555 555 + let client = client(); 556 556 + let res = client 557 557 + .post(format!( 558 558 + "{}/xrpc/_identity.verifyHandleOwnership", 559 559 + base_url().await 560 560 + )) 561 561 + .json(&json!({ 562 562 + "handle": "@#$!", 563 563 + "did": "did:plc:abc123" 564 564 + })) 565 565 + .send() 566 566 + .await 567 567 + .expect("Failed to send request"); 568 568 + assert_eq!(res.status(), StatusCode::BAD_REQUEST); 569 569 + let body: Value = res.json().await.expect("Response was not valid JSON"); 570 570 + assert_eq!(body["error"], "InvalidHandle"); 571 571 + } 572 572 + 573 573 + #[tokio::test] 574 574 + async fn test_verify_handle_ownership_missing_fields() { 575 575 + let client = client(); 576 576 + let res = client 577 577 + .post(format!( 578 578 + "{}/xrpc/_identity.verifyHandleOwnership", 579 579 + base_url().await 580 580 + )) 581 581 + .json(&json!({})) 582 582 + .send() 583 583 + .await 584 584 + .expect("Failed to send request"); 585 585 + assert_eq!(res.status(), StatusCode::UNPROCESSABLE_ENTITY); 586 586 + } 587 587 + 588 588 + #[tokio::test] 589 589 + async fn test_verify_handle_ownership_unresolvable() { 590 590 + let client = client(); 591 591 + let res = client 592 592 + .post(format!( 593 593 + "{}/xrpc/_identity.verifyHandleOwnership", 594 594 + base_url().await 595 595 + )) 596 596 + .json(&json!({ 597 597 + "handle": "nonexistent.example.com", 598 598 + "did": "did:plc:abc123def456" 599 599 + })) 600 600 + .send() 601 601 + .await 602 602 + .expect("Failed to send request"); 603 603 + assert_eq!(res.status(), StatusCode::OK); 604 604 + let body: Value = res.json().await.expect("Response was not valid JSON"); 605 605 + assert_eq!(body["verified"], false); 606 606 + assert!(body["error"].as_str().is_some()); 607 607 + } 608 608 + 609 609 + #[tokio::test] 610 610 + async fn test_verify_handle_ownership_wrong_did() { 611 611 + let client = client(); 612 612 + let res = client 613 613 + .post(format!( 614 614 + "{}/xrpc/_identity.verifyHandleOwnership", 615 615 + base_url().await 616 616 + )) 617 617 + .json(&json!({ 618 618 + "handle": "nonexistent.example.com", 619 619 + "did": "did:plc:aaaaaaaaaaaaaaaaaaaaaa" 620 620 + })) 621 621 + .send() 622 622 + .await 623 623 + .expect("Failed to send request"); 624 624 + assert_eq!(res.status(), StatusCode::OK); 625 625 + let body: Value = res.json().await.expect("Response was not valid JSON"); 626 626 + assert_eq!(body["verified"], false); 627 627 + assert!(body["error"].as_str().is_some()); 628 628 + assert!(body["method"].is_null()); 629 629 + }

+17 -10

crates/tranquil-pds/tests/security_fixes.rs

··· 1 1 mod common; 2 2 - use tranquil_pds::comms::{SendError, is_valid_phone_number, is_valid_signal_username, sanitize_header_value}; 2 2 + use tranquil_pds::comms::{ 3 3 + SendError, is_valid_phone_number, is_valid_signal_username, sanitize_header_value, 4 4 + }; 3 5 use tranquil_pds::image::{ImageError, ImageProcessor}; 4 6 5 7 #[test] ··· 101 103 102 104 assert!(!is_valid_signal_username("a".repeat(33).as_str())); 103 105 104 104 - ["alice.01; rm -rf /", "bob.01 && cat /etc/passwd", "user.01`id`", "test.01$(whoami)"] 105 105 - .iter() 106 106 - .for_each(|malicious| { 107 107 - assert!( 108 108 - !is_valid_signal_username(malicious), 109 109 - "Command injection '{}' should be rejected", 110 110 - malicious 111 111 - ); 112 112 - }); 106 106 + [ 107 107 + "alice.01; rm -rf /", 108 108 + "bob.01 && cat /etc/passwd", 109 109 + "user.01`id`", 110 110 + "test.01$(whoami)", 111 111 + ] 112 112 + .iter() 113 113 + .for_each(|malicious| { 114 114 + assert!( 115 115 + !is_valid_signal_username(malicious), 116 116 + "Command injection '{}' should be rejected", 117 117 + malicious 118 118 + ); 119 119 + }); 113 120 } 114 121 115 122 #[test]

+3 -22

frontend/src/components/dashboard/CommsContent.svelte

··· 333 333 placeholder={$_('register.signalUsernamePlaceholder')} 334 334 disabled={saving} 335 335 /> 336 336 - {#if signalUsername && signalUsername === savedSignalUsername && !signalVerified} 337 337 - <button type="button" class="verify-btn" onclick={() => verifyingChannel = 'signal'}>{$_('comms.verifyButton')}</button> 338 338 - {/if} 339 336 </div> 340 337 {#if signalInUse} 341 338 <p class="hint warning">{$_('comms.signalInUseWarning')}</p> 342 339 {/if} 343 343 - {#if verifyingChannel === 'signal'} 340 340 + {#if signalUsername && signalUsername === savedSignalUsername && !signalVerified} 344 341 <div class="verify-form"> 345 345 - <input type="text" bind:value={verificationCode} placeholder={$_('comms.verifyCodePlaceholder')} maxlength="128" /> 342 342 + <input type="text" bind:value={verificationCode} placeholder={$_('comms.verifyCodePlaceholder')} maxlength="512" /> 346 343 <button type="button" onclick={() => handleVerify('signal')}>{$_('comms.submit')}</button> 347 347 - <button type="button" class="cancel" onclick={() => { verifyingChannel = null; verificationCode = '' }}>{$_('common.cancel')}</button> 348 344 </div> 349 345 {/if} 350 346 </div> ··· 553 549 color: var(--text-secondary); 554 550 } 555 551 556 556 - .verify-btn { 557 557 - padding: var(--space-2) var(--space-3); 558 558 - font-size: var(--text-sm); 559 559 - } 560 552 561 553 .verify-form { 562 554 display: flex; 555 555 + flex-direction: column; 563 556 gap: var(--space-2); 564 564 - align-items: center; 565 565 - } 566 566 - 567 567 - .verify-form input { 568 568 - flex: 1; 569 569 - min-width: 0; 570 557 } 571 558 572 559 .verify-form button { ··· 574 561 font-size: var(--text-sm); 575 562 } 576 563 577 577 - .verify-form button.cancel { 578 578 - background: transparent; 579 579 - border: 1px solid var(--border-color); 580 580 - color: var(--text-secondary); 581 581 - } 582 582 - 583 564 .actions { 584 565 margin-bottom: var(--space-5); 585 566 }

+253 -32

frontend/src/components/migration/ChooseHandleStep.svelte

··· 1 1 <script lang="ts"> 2 2 - import type { AuthMethod, ServerDescription } from '../../lib/migration/types' 2 2 + import type { AuthMethod, HandlePreservation, ServerDescription } from '../../lib/migration/types' 3 3 import { _ } from '../../lib/i18n' 4 4 5 5 interface Props { ··· 15 15 migratingFromLabel: string 16 16 migratingFromValue: string 17 17 loading?: boolean 18 18 + sourceHandle: string 19 19 + sourceDid: string 20 20 + handlePreservation: HandlePreservation 21 21 + existingHandleVerified: boolean 22 22 + verifyingExistingHandle?: boolean 23 23 + existingHandleError?: string | null 18 24 onHandleChange: (handle: string) => void 19 25 onDomainChange: (domain: string) => void 20 26 onCheckHandle: () => void ··· 22 28 onPasswordChange: (password: string) => void 23 29 onAuthMethodChange: (method: AuthMethod) => void 24 30 onInviteCodeChange: (code: string) => void 31 31 + onHandlePreservationChange?: (preservation: HandlePreservation) => void 32 32 + onVerifyExistingHandle?: () => void 25 33 onBack: () => void 26 34 onContinue: () => void 27 35 } ··· 39 47 migratingFromLabel, 40 48 migratingFromValue, 41 49 loading = false, 50 50 + sourceHandle, 51 51 + sourceDid, 52 52 + handlePreservation, 53 53 + existingHandleVerified, 54 54 + verifyingExistingHandle = false, 55 55 + existingHandleError = null, 42 56 onHandleChange, 43 57 onDomainChange, 44 58 onCheckHandle, ··· 46 60 onPasswordChange, 47 61 onAuthMethodChange, 48 62 onInviteCodeChange, 63 63 + onHandlePreservationChange, 64 64 + onVerifyExistingHandle, 49 65 onBack, 50 66 onContinue, 51 67 }: Props = $props() 52 68 53 69 const handleTooShort = $derived(handleInput.trim().length > 0 && handleInput.trim().length < 3) 54 70 71 71 + const isExternalHandle = $derived( 72 72 + serverInfo != null && 73 73 + sourceHandle.includes('.') && 74 74 + !serverInfo.availableUserDomains.some(d => sourceHandle.endsWith(`.${d}`)) 75 75 + ) 76 76 + 55 77 const canContinue = $derived( 56 56 - handleInput.trim().length >= 3 && 57 78 email && 58 79 (authMethod === 'passkey' || password) && 59 59 - handleAvailable !== false 80 80 + ( 81 81 + (handlePreservation === 'existing' && existingHandleVerified) || 82 82 + (handlePreservation === 'new' && handleInput.trim().length >= 3 && handleAvailable !== false) 83 83 + ) 60 84 ) 61 85 </script> 62 86 ··· 69 93 <span class="value">{migratingFromValue}</span> 70 94 </div> 71 95 72 72 - <div class="field"> 73 73 - <label for="new-handle">{$_('migration.inbound.chooseHandle.newHandle')}</label> 74 74 - <div class="handle-input-group"> 75 75 - <input 76 76 - id="new-handle" 77 77 - type="text" 78 78 - placeholder="username" 79 79 - value={handleInput} 80 80 - oninput={(e) => onHandleChange((e.target as HTMLInputElement).value)} 81 81 - onblur={onCheckHandle} 82 82 - /> 83 83 - {#if serverInfo && serverInfo.availableUserDomains.length > 0 && !handleInput.includes('.')} 84 84 - <select value={selectedDomain} onchange={(e) => onDomainChange((e.target as HTMLSelectElement).value)}> 85 85 - {#each serverInfo.availableUserDomains as domain} 86 86 - <option value={domain}>.{domain}</option> 87 87 - {/each} 88 88 - </select> 96 96 + {#if isExternalHandle} 97 97 + <div class="field"> 98 98 + <span class="field-label">{$_('migration.inbound.chooseHandle.handleChoice')}</span> 99 99 + <div class="handle-choice-options"> 100 100 + <label class="handle-choice-option" class:selected={handlePreservation === 'existing'}> 101 101 + <input 102 102 + type="radio" 103 103 + name="handle-preservation" 104 104 + value="existing" 105 105 + checked={handlePreservation === 'existing'} 106 106 + onchange={() => onHandlePreservationChange?.('existing')} 107 107 + /> 108 108 + <div class="handle-choice-content"> 109 109 + <strong>{$_('migration.inbound.chooseHandle.keepExisting')}</strong> 110 110 + <span class="handle-preview">@{sourceHandle}</span> 111 111 + </div> 112 112 + </label> 113 113 + <label class="handle-choice-option" class:selected={handlePreservation === 'new'}> 114 114 + <input 115 115 + type="radio" 116 116 + name="handle-preservation" 117 117 + value="new" 118 118 + checked={handlePreservation === 'new'} 119 119 + onchange={() => onHandlePreservationChange?.('new')} 120 120 + /> 121 121 + <div class="handle-choice-content"> 122 122 + <strong>{$_('migration.inbound.chooseHandle.createNew')}</strong> 123 123 + </div> 124 124 + </label> 125 125 + </div> 126 126 + </div> 127 127 + {/if} 128 128 + 129 129 + {#if handlePreservation === 'existing' && isExternalHandle} 130 130 + <div class="field"> 131 131 + <span class="field-label">{$_('migration.inbound.chooseHandle.existingHandle')}</span> 132 132 + <div class="existing-handle-display"> 133 133 + <span class="handle-value">@{sourceHandle}</span> 134 134 + {#if existingHandleVerified} 135 135 + <span class="verified-badge">{$_('migration.inbound.chooseHandle.verified')}</span> 136 136 + {/if} 137 137 + </div> 138 138 + 139 139 + {#if !existingHandleVerified} 140 140 + <div class="verification-instructions"> 141 141 + <p class="instruction-header">{$_('migration.inbound.chooseHandle.verifyInstructions')}</p> 142 142 + <div class="verification-record"> 143 143 + <code>_atproto.{sourceHandle} TXT "did={sourceDid}"</code> 144 144 + </div> 145 145 + <p class="instruction-or">{$_('migration.inbound.chooseHandle.or')}</p> 146 146 + <div class="verification-record"> 147 147 + <code>https://{sourceHandle}/.well-known/atproto-did</code> 148 148 + <span class="record-content">{$_('migration.inbound.chooseHandle.returning')} <code>{sourceDid}</code></span> 149 149 + </div> 150 150 + </div> 151 151 + 152 152 + <button 153 153 + class="verify-btn" 154 154 + onclick={() => onVerifyExistingHandle?.()} 155 155 + disabled={verifyingExistingHandle} 156 156 + > 157 157 + {#if verifyingExistingHandle} 158 158 + {$_('migration.inbound.chooseHandle.verifying')} 159 159 + {:else if existingHandleError} 160 160 + {$_('migration.inbound.chooseHandle.checkAgain')} 161 161 + {:else} 162 162 + {$_('migration.inbound.chooseHandle.verifyOwnership')} 163 163 + {/if} 164 164 + </button> 165 165 + 166 166 + {#if existingHandleError} 167 167 + <p class="hint error">{existingHandleError}</p> 168 168 + {/if} 89 169 {/if} 90 170 </div> 171 171 + {:else} 172 172 + <div class="field"> 173 173 + <label for="new-handle">{$_('migration.inbound.chooseHandle.newHandle')}</label> 174 174 + <div class="handle-input-group"> 175 175 + <input 176 176 + id="new-handle" 177 177 + type="text" 178 178 + placeholder="username" 179 179 + value={handleInput} 180 180 + oninput={(e) => onHandleChange((e.target as HTMLInputElement).value)} 181 181 + onblur={onCheckHandle} 182 182 + /> 183 183 + {#if serverInfo && serverInfo.availableUserDomains.length > 0 && !handleInput.includes('.')} 184 184 + <select value={selectedDomain} onchange={(e) => onDomainChange((e.target as HTMLSelectElement).value)}> 185 185 + {#each serverInfo.availableUserDomains as domain} 186 186 + <option value={domain}>.{domain}</option> 187 187 + {/each} 188 188 + </select> 189 189 + {/if} 190 190 + </div> 91 191 92 92 - {#if handleTooShort} 93 93 - <p class="hint error">{$_('migration.inbound.chooseHandle.handleTooShort')}</p> 94 94 - {:else if checkingHandle} 95 95 - <p class="hint">{$_('migration.inbound.chooseHandle.checkingAvailability')}</p> 96 96 - {:else if handleAvailable === true} 97 97 - <p class="hint" style="color: var(--success-text)">{$_('migration.inbound.chooseHandle.handleAvailable')}</p> 98 98 - {:else if handleAvailable === false} 99 99 - <p class="hint error">{$_('migration.inbound.chooseHandle.handleTaken')}</p> 100 100 - {:else} 101 101 - <p class="hint">{$_('migration.inbound.chooseHandle.handleHint')}</p> 102 102 - {/if} 103 103 - </div> 192 192 + {#if handleTooShort} 193 193 + <p class="hint error">{$_('migration.inbound.chooseHandle.handleTooShort')}</p> 194 194 + {:else if checkingHandle} 195 195 + <p class="hint">{$_('migration.inbound.chooseHandle.checkingAvailability')}</p> 196 196 + {:else if handleAvailable === true} 197 197 + <p class="hint" style="color: var(--success-text)">{$_('migration.inbound.chooseHandle.handleAvailable')}</p> 198 198 + {:else if handleAvailable === false} 199 199 + <p class="hint error">{$_('migration.inbound.chooseHandle.handleTaken')}</p> 200 200 + {:else} 201 201 + <p class="hint">{$_('migration.inbound.chooseHandle.handleHint')}</p> 202 202 + {/if} 203 203 + </div> 204 204 + {/if} 104 205 105 206 <div class="field"> 106 207 <label for="email">{$_('migration.inbound.chooseHandle.email')}</label> ··· 187 288 </button> 188 289 </div> 189 290 </div> 291 291 + 292 292 + <style> 293 293 + .handle-choice-options { 294 294 + display: flex; 295 295 + flex-direction: column; 296 296 + gap: var(--space-3); 297 297 + } 298 298 + 299 299 + .handle-choice-option { 300 300 + display: flex; 301 301 + align-items: center; 302 302 + gap: var(--space-3); 303 303 + padding: var(--space-4); 304 304 + border: 1px solid var(--border-color); 305 305 + border-radius: var(--radius-lg); 306 306 + cursor: pointer; 307 307 + transition: border-color var(--transition-normal), background var(--transition-normal); 308 308 + } 309 309 + 310 310 + .handle-choice-option:hover { 311 311 + border-color: var(--accent); 312 312 + } 313 313 + 314 314 + .handle-choice-option.selected { 315 315 + border-color: var(--accent); 316 316 + background: var(--accent-muted); 317 317 + } 318 318 + 319 319 + .handle-choice-option input[type="radio"] { 320 320 + flex-shrink: 0; 321 321 + width: 18px; 322 322 + height: 18px; 323 323 + margin: 0; 324 324 + } 325 325 + 326 326 + .handle-choice-content { 327 327 + display: flex; 328 328 + flex-direction: column; 329 329 + gap: var(--space-1); 330 330 + } 331 331 + 332 332 + .handle-preview { 333 333 + font-family: var(--font-mono); 334 334 + font-size: var(--text-sm); 335 335 + color: var(--text-secondary); 336 336 + } 337 337 + 338 338 + .existing-handle-display { 339 339 + display: flex; 340 340 + align-items: center; 341 341 + gap: var(--space-4); 342 342 + padding: var(--space-4); 343 343 + background: var(--bg-secondary); 344 344 + border-radius: var(--radius-lg); 345 345 + margin-bottom: var(--space-4); 346 346 + } 347 347 + 348 348 + .handle-value { 349 349 + font-family: var(--font-mono); 350 350 + font-size: var(--text-base); 351 351 + } 352 352 + 353 353 + .verified-badge { 354 354 + font-size: var(--text-xs); 355 355 + padding: var(--space-1) var(--space-3); 356 356 + background: var(--success-bg); 357 357 + color: var(--success-text); 358 358 + border-radius: var(--radius-md); 359 359 + } 360 360 + 361 361 + .verification-instructions { 362 362 + background: var(--bg-secondary); 363 363 + padding: var(--space-5); 364 364 + border-radius: var(--radius-lg); 365 365 + margin-bottom: var(--space-4); 366 366 + } 367 367 + 368 368 + .instruction-header { 369 369 + margin: 0 0 var(--space-4) 0; 370 370 + font-size: var(--text-sm); 371 371 + color: var(--text-secondary); 372 372 + } 373 373 + 374 374 + .instruction-or { 375 375 + margin: var(--space-3) 0; 376 376 + font-size: var(--text-xs); 377 377 + color: var(--text-muted); 378 378 + text-align: center; 379 379 + } 380 380 + 381 381 + .verification-record { 382 382 + display: flex; 383 383 + flex-direction: column; 384 384 + gap: var(--space-2); 385 385 + } 386 386 + 387 387 + .verification-record code { 388 388 + font-size: var(--text-sm); 389 389 + padding: var(--space-3); 390 390 + background: var(--bg-tertiary); 391 391 + border-radius: var(--radius-md); 392 392 + overflow-x: auto; 393 393 + word-break: break-all; 394 394 + } 395 395 + 396 396 + .record-content { 397 397 + font-size: var(--text-xs); 398 398 + color: var(--text-secondary); 399 399 + padding-left: var(--space-3); 400 400 + } 401 401 + 402 402 + .record-content code { 403 403 + padding: var(--space-1) var(--space-2); 404 404 + font-size: var(--text-xs); 405 405 + } 406 406 + 407 407 + .verify-btn { 408 408 + width: 100%; 409 409 + } 410 410 + </style>

+47 -5

frontend/src/components/migration/InboundWizard.svelte

··· 1 1 <script lang="ts"> 2 2 import type { InboundMigrationFlow } from '../../lib/migration' 3 3 - import type { AuthMethod, ServerDescription } from '../../lib/migration/types' 3 3 + import type { AuthMethod, HandlePreservation, ServerDescription } from '../../lib/migration/types' 4 4 import { getErrorMessage } from '../../lib/migration/types' 5 5 import { base64UrlEncode, prepareWebAuthnCreationOptions } from '../../lib/migration/atproto-client' 6 6 import { _ } from '../../lib/i18n' ··· 43 43 let checkingHandle = $state(false) 44 44 let selectedAuthMethod = $state<AuthMethod>('password') 45 45 let passkeyName = $state('') 46 46 + let verifyingExistingHandle = $state(false) 47 47 + let existingHandleError = $state<string | null>(null) 46 48 47 49 const isResuming = $derived(flow.state.needsReauth === true) 48 50 const isDidWeb = $derived(flow.state.sourceDid.startsWith("did:web:")) ··· 54 56 if (flow.state.step === 'choose-handle') { 55 57 handleInput = '' 56 58 handleAvailable = null 59 59 + existingHandleError = null 60 60 + flow.updateField('handlePreservation', 'new') 61 61 + flow.updateField('existingHandleVerified', false) 57 62 } 58 63 if (flow.state.step === 'source-handle' && resumeInfo) { 59 64 handleInput = resumeInfo.sourceHandle ··· 112 117 } 113 118 } 114 119 120 120 + function handlePreservationChange(preservation: HandlePreservation) { 121 121 + flow.updateField('handlePreservation', preservation) 122 122 + existingHandleError = null 123 123 + if (preservation === 'existing') { 124 124 + flow.updateField('existingHandleVerified', false) 125 125 + } 126 126 + } 127 127 + 128 128 + async function verifyExistingHandle() { 129 129 + verifyingExistingHandle = true 130 130 + existingHandleError = null 131 131 + 132 132 + try { 133 133 + const result = await flow.verifyExistingHandle() 134 134 + if (!result.verified && result.error) { 135 135 + existingHandleError = result.error 136 136 + } 137 137 + } catch (err) { 138 138 + existingHandleError = getErrorMessage(err) 139 139 + } finally { 140 140 + verifyingExistingHandle = false 141 141 + } 142 142 + } 143 143 + 115 144 function proceedToReview() { 116 145 const fullHandle = handleInput.includes('.') 117 146 ? handleInput ··· 265 294 } 266 295 267 296 function proceedToReviewWithAuth() { 268 268 - const fullHandle = handleInput.includes('.') 269 269 - ? handleInput 270 270 - : `${handleInput}.${selectedDomain}` 297 297 + let targetHandle: string 298 298 + if (flow.state.handlePreservation === 'existing' && flow.state.existingHandleVerified) { 299 299 + targetHandle = flow.state.sourceHandle 300 300 + } else { 301 301 + targetHandle = handleInput.includes('.') 302 302 + ? handleInput 303 303 + : `${handleInput}.${selectedDomain}` 304 304 + } 271 305 272 272 - flow.updateField('targetHandle', fullHandle) 306 306 + flow.updateField('targetHandle', targetHandle) 273 307 flow.updateField('authMethod', selectedAuthMethod) 274 308 flow.setStep('review') 275 309 } ··· 420 454 migratingFromLabel={$_('migration.inbound.chooseHandle.migratingFrom')} 421 455 migratingFromValue={flow.state.sourceHandle} 422 456 {loading} 457 457 + sourceHandle={flow.state.sourceHandle} 458 458 + sourceDid={flow.state.sourceDid} 459 459 + handlePreservation={flow.state.handlePreservation} 460 460 + existingHandleVerified={flow.state.existingHandleVerified} 461 461 + {verifyingExistingHandle} 462 462 + {existingHandleError} 423 463 onHandleChange={(h) => handleInput = h} 424 464 onDomainChange={(d) => selectedDomain = d} 425 465 onCheckHandle={checkHandle} ··· 427 467 onPasswordChange={(p) => flow.updateField('targetPassword', p)} 428 468 onAuthMethodChange={(m) => selectedAuthMethod = m} 429 469 onInviteCodeChange={(c) => flow.updateField('inviteCode', c)} 470 470 + onHandlePreservationChange={handlePreservationChange} 471 471 + onVerifyExistingHandle={verifyExistingHandle} 430 472 onBack={() => flow.setStep('source-handle')} 431 473 onContinue={proceedToReviewWithAuth} 432 474 />

+6

frontend/src/components/migration/OfflineInboundWizard.svelte

··· 412 412 migratingFromLabel={$_('migration.offline.chooseHandle.migratingDid')} 413 413 migratingFromValue={flow.state.userDid} 414 414 {loading} 415 415 + sourceHandle="" 416 416 + sourceDid={flow.state.userDid} 417 417 + handlePreservation="new" 418 418 + existingHandleVerified={false} 419 419 + verifyingExistingHandle={false} 420 420 + existingHandleError={null} 415 421 onHandleChange={(h) => handleInput = h} 416 422 onDomainChange={(d) => selectedDomain = d} 417 423 onCheckHandle={checkHandle}

+21 -7

frontend/src/lib/api.ts

··· 327 327 return { 328 328 did: unsafeAsDid(c.did as string), 329 329 handle: unsafeAsHandle(c.handle as string), 330 330 - grantedScopes: unsafeAsScopeSet((c.granted_scopes ?? c.grantedScopes) as string), 331 331 - grantedAt: unsafeAsISODate((c.granted_at ?? c.grantedAt ?? c.added_at) as string), 330 330 + grantedScopes: unsafeAsScopeSet( 331 331 + (c.granted_scopes ?? c.grantedScopes) as string, 332 332 + ), 333 333 + grantedAt: unsafeAsISODate( 334 334 + (c.granted_at ?? c.grantedAt ?? c.added_at) as string, 335 335 + ), 332 336 isActive: (c.is_active ?? c.isActive ?? true) as boolean, 333 337 }; 334 338 } ··· 340 344 return { 341 345 did: unsafeAsDid(a.did as string), 342 346 handle: unsafeAsHandle(a.handle as string), 343 343 - grantedScopes: unsafeAsScopeSet((a.granted_scopes ?? a.grantedScopes) as string), 344 344 - grantedAt: unsafeAsISODate((a.granted_at ?? a.grantedAt ?? a.added_at) as string), 347 347 + grantedScopes: unsafeAsScopeSet( 348 348 + (a.granted_scopes ?? a.grantedScopes) as string, 349 349 + ), 350 350 + grantedAt: unsafeAsISODate( 351 351 + (a.granted_at ?? a.grantedAt ?? a.added_at) as string, 352 352 + ), 345 353 }; 346 354 } 347 355 348 356 function _castDelegationAuditEntry(raw: unknown): DelegationAuditEntry { 349 357 const e = raw as Record<string, unknown>; 350 358 const actorDid = (e.actor_did ?? e.actorDid) as string; 351 351 - const targetDid = (e.target_did ?? e.targetDid ?? e.delegatedDid) as string | undefined; 359 359 + const targetDid = (e.target_did ?? e.targetDid ?? e.delegatedDid) as 360 360 + | string 361 361 + | undefined; 352 362 const createdAt = (e.created_at ?? e.createdAt) as string; 353 363 const action = (e.action ?? e.actionType) as string; 354 364 const details = e.details ?? e.actionDetails; ··· 1434 1444 ); 1435 1445 if (!result.ok) return result; 1436 1446 return ok({ 1437 1437 - controllers: (result.value.controllers ?? []).map(_castDelegationController), 1447 1447 + controllers: (result.value.controllers ?? []).map( 1448 1448 + _castDelegationController, 1449 1449 + ), 1438 1450 }); 1439 1451 }, 1440 1452 ··· 1447 1459 ); 1448 1460 if (!result.ok) return result; 1449 1461 return ok({ 1450 1450 - accounts: (result.value.accounts ?? []).map(_castDelegationControlledAccount), 1462 1462 + accounts: (result.value.accounts ?? []).map( 1463 1463 + _castDelegationControlledAccount, 1464 1464 + ), 1451 1465 }); 1452 1466 }, 1453 1467

+10

frontend/src/lib/migration/atproto-client.ts

··· 615 615 }); 616 616 } 617 617 618 618 + async verifyHandleOwnership( 619 619 + handle: string, 620 620 + did: string, 621 621 + ): Promise<{ verified: boolean; method?: string; error?: string }> { 622 622 + return this.xrpc("_identity.verifyHandleOwnership", { 623 623 + httpMethod: "POST", 624 624 + body: { handle, did }, 625 625 + }); 626 626 + } 627 627 + 618 628 async resendMigrationVerification(): Promise<void> { 619 629 await this.xrpc("com.atproto.server.resendMigrationVerification", { 620 630 httpMethod: "POST",

+30 -4

frontend/src/lib/migration/flow.svelte.ts

··· 80 80 localAccessToken: null, 81 81 generatedAppPassword: null, 82 82 generatedAppPasswordName: null, 83 83 + handlePreservation: "new", 84 84 + existingHandleVerified: false, 83 85 }); 84 86 85 87 let sourceClient: AtprotoClient | null = null; ··· 118 120 } 119 121 120 122 async function resolveSourcePds(handle: string): Promise<void> { 123 123 + const normalized = handle.startsWith("@") ? handle.slice(1) : handle; 121 124 try { 122 122 - const { did, pdsUrl } = await resolvePdsUrl(handle); 125 125 + const { did, pdsUrl } = await resolvePdsUrl(normalized); 123 126 state.sourcePdsUrl = pdsUrl; 124 127 state.sourceDid = did; 125 125 - state.sourceHandle = handle; 128 128 + state.sourceHandle = normalized; 126 129 sourceClient = new AtprotoClient(pdsUrl); 127 130 } catch (e) { 128 131 throw new Error(`Could not resolve handle: ${(e as Error).message}`); ··· 132 135 async function initiateOAuthLogin(handle: string): Promise<void> { 133 136 migrationLog("initiateOAuthLogin START", { handle }); 134 137 135 135 - if (!state.sourcePdsUrl) { 136 136 - await resolveSourcePds(handle); 138 138 + const normalizedHandle = handle.startsWith("@") ? handle.slice(1) : handle; 139 139 + if (!state.sourcePdsUrl || state.sourceHandle !== normalizedHandle) { 140 140 + await resolveSourcePds(normalizedHandle); 137 141 } 138 142 139 143 const metadata = await getOAuthServerMetadata(state.sourcePdsUrl); ··· 322 326 } 323 327 } 324 328 329 329 + async function verifyExistingHandle(): Promise<{ 330 330 + verified: boolean; 331 331 + method?: string; 332 332 + error?: string; 333 333 + }> { 334 334 + if (!localClient) { 335 335 + localClient = createLocalClient(); 336 336 + } 337 337 + const result = await localClient.verifyHandleOwnership( 338 338 + state.sourceHandle, 339 339 + state.sourceDid, 340 340 + ); 341 341 + if (result.verified) { 342 342 + state.existingHandleVerified = true; 343 343 + state.targetHandle = state.sourceHandle; 344 344 + } 345 345 + return result; 346 346 + } 347 347 + 325 348 async function authenticateToLocal( 326 349 email: string, 327 350 password: string, ··· 921 944 localAccessToken: null, 922 945 generatedAppPassword: null, 923 946 generatedAppPasswordName: null, 947 947 + handlePreservation: "new", 948 948 + existingHandleVerified: false, 924 949 }; 925 950 sourceClient = null; 926 951 passkeySetup = null; ··· 1005 1030 handleOAuthCallback, 1006 1031 authenticateToLocal, 1007 1032 checkHandleAvailability, 1033 1033 + verifyExistingHandle, 1008 1034 startMigration, 1009 1035 submitEmailVerifyToken, 1010 1036 resendEmailVerification,

+4

frontend/src/lib/migration/offline-flow.svelte.ts

··· 169 169 progress: createInitialProgress(), 170 170 error: null, 171 171 plcUpdatedTemporarily: false, 172 172 + handlePreservation: "new", 173 173 + existingHandleVerified: false, 172 174 }); 173 175 174 176 let localServerInfo: ServerDescription | null = null; ··· 671 673 progress: createInitialProgress(), 672 674 error: null, 673 675 plcUpdatedTemporarily: false, 676 676 + handlePreservation: "new", 677 677 + existingHandleVerified: false, 674 678 }; 675 679 localServerInfo = null; 676 680 }

+6

frontend/src/lib/migration/types.ts

··· 48 48 currentOperation: string; 49 49 } 50 50 51 51 + export type HandlePreservation = "new" | "existing"; 52 52 + 51 53 export interface InboundMigrationState { 52 54 direction: "inbound"; 53 55 step: InboundStep; ··· 74 76 generatedAppPasswordName: string | null; 75 77 needsReauth?: boolean; 76 78 resumeToStep?: InboundStep; 79 79 + handlePreservation: HandlePreservation; 80 80 + existingHandleVerified: boolean; 77 81 } 78 82 79 83 export interface OfflineInboundMigrationState { ··· 101 105 progress: MigrationProgress; 102 106 error: string | null; 103 107 plcUpdatedTemporarily: boolean; 108 108 + handlePreservation: HandlePreservation; 109 109 + existingHandleVerified: boolean; 104 110 } 105 111 106 112 export type MigrationState = InboundMigrationState;

+2

frontend/src/lib/types/api.ts

··· 233 233 availableCommsChannels?: VerificationChannel[]; 234 234 selfHostedDidWebEnabled?: boolean; 235 235 telegramBotUsername?: string; 236 236 + discordBotUsername?: string; 237 237 + discordAppId?: string; 236 238 } 237 239 238 240 export interface UpdateNotificationPrefsResponse {

+11

frontend/src/locales/en.json

··· 986 986 "title": "Choose Your New Handle", 987 987 "desc": "Select a handle for your account on this PDS.", 988 988 "migratingFrom": "Migrating from", 989 989 + "handleChoice": "Handle", 990 990 + "keepExisting": "Keep existing handle", 991 991 + "createNew": "Create new handle", 992 992 + "existingHandle": "Your handle", 993 993 + "verifyInstructions": "Verify ownership via DNS or HTTP", 994 994 + "or": "or", 995 995 + "returning": "returning", 996 996 + "verifyOwnership": "Verify ownership", 997 997 + "verifying": "Verifying", 998 998 + "verified": "Verified", 999 999 + "checkAgain": "Check again", 989 1000 "newHandle": "New Handle", 990 1001 "checkingAvailability": "Checking availability...", 991 1002 "handleAvailable": "Handle is available!",

+11

frontend/src/locales/fi.json

··· 986 986 "title": "Valitse uusi käyttäjätunnuksesi", 987 987 "desc": "Valitse käyttäjätunnus tilillesi tässä PDS:ssä.", 988 988 "migratingFrom": "Siirretään tililtä", 989 989 + "handleChoice": "Käyttäjätunnus", 990 990 + "keepExisting": "Säilytä nykyinen tunnus", 991 991 + "createNew": "Luo uusi tunnus", 992 992 + "existingHandle": "Nykyinen tunnus", 993 993 + "verifyInstructions": "Vahvista omistajuus DNS- tai HTTP-tietueella", 994 994 + "or": "tai", 995 995 + "returning": "palauttaa", 996 996 + "verifyOwnership": "Vahvista omistajuus", 997 997 + "verifying": "Vahvistetaan", 998 998 + "verified": "Vahvistettu", 999 999 + "checkAgain": "Tarkista uudelleen", 989 1000 "newHandle": "Uusi käyttäjätunnus", 990 1001 "checkingAvailability": "Tarkistetaan saatavuutta...", 991 1002 "handleAvailable": "Käyttäjätunnus on saatavilla!",

+11

frontend/src/locales/ja.json

··· 986 986 "title": "新しいハンドルを選択", 987 987 "desc": "このPDSでのアカウントのハンドルを選択してください。", 988 988 "migratingFrom": "移行元", 989 989 + "handleChoice": "ハンドル", 990 990 + "keepExisting": "既存のハンドルを維持", 991 991 + "createNew": "新しいハンドルを作成", 992 992 + "existingHandle": "現在のハンドル", 993 993 + "verifyInstructions": "DNSまたはHTTPで所有権を確認", 994 994 + "or": "または", 995 995 + "returning": "返却値", 996 996 + "verifyOwnership": "所有権を確認", 997 997 + "verifying": "確認中", 998 998 + "verified": "確認済み", 999 999 + "checkAgain": "再確認", 989 1000 "newHandle": "新しいハンドル", 990 1001 "checkingAvailability": "利用可能か確認中...", 991 1002 "handleAvailable": "ハンドルは利用可能です！",

+11

frontend/src/locales/ko.json

··· 986 986 "title": "새 핸들 선택", 987 987 "desc": "이 PDS에서 사용할 계정 핸들을 선택하세요.", 988 988 "migratingFrom": "마이그레이션 원본", 989 989 + "handleChoice": "핸들", 990 990 + "keepExisting": "기존 핸들 유지", 991 991 + "createNew": "새 핸들 생성", 992 992 + "existingHandle": "현재 핸들", 993 993 + "verifyInstructions": "DNS 또는 HTTP로 소유권 확인", 994 994 + "or": "또는", 995 995 + "returning": "반환값", 996 996 + "verifyOwnership": "소유권 확인", 997 997 + "verifying": "확인 중", 998 998 + "verified": "확인됨", 999 999 + "checkAgain": "다시 확인", 989 1000 "newHandle": "새 핸들", 990 1001 "checkingAvailability": "사용 가능 여부 확인 중...", 991 1002 "handleAvailable": "핸들을 사용할 수 있습니다!",

+11

frontend/src/locales/sv.json

··· 986 986 "title": "Välj ditt nya användarnamn", 987 987 "desc": "Välj ett användarnamn för ditt konto på denna PDS.", 988 988 "migratingFrom": "Flyttar från", 989 989 + "handleChoice": "Användarnamn", 990 990 + "keepExisting": "Behåll befintligt användarnamn", 991 991 + "createNew": "Skapa nytt användarnamn", 992 992 + "existingHandle": "Ditt användarnamn", 993 993 + "verifyInstructions": "Verifiera ägarskap via DNS eller HTTP", 994 994 + "or": "eller", 995 995 + "returning": "returnerar", 996 996 + "verifyOwnership": "Verifiera ägarskap", 997 997 + "verifying": "Verifierar", 998 998 + "verified": "Verifierad", 999 999 + "checkAgain": "Kontrollera igen", 989 1000 "newHandle": "Nytt användarnamn", 990 1001 "checkingAvailability": "Kontrollerar tillgänglighet...", 991 1002 "handleAvailable": "Användarnamnet är tillgängligt!",

+11

frontend/src/locales/zh.json

··· 986 986 "title": "选择新用户名", 987 987 "desc": "为您在此PDS上的账户选择用户名。", 988 988 "migratingFrom": "迁移自", 989 989 + "handleChoice": "用户名", 990 990 + "keepExisting": "保留现有用户名", 991 991 + "createNew": "创建新用户名", 992 992 + "existingHandle": "当前用户名", 993 993 + "verifyInstructions": "通过DNS或HTTP验证所有权", 994 994 + "or": "或", 995 995 + "returning": "返回值", 996 996 + "verifyOwnership": "验证所有权", 997 997 + "verifying": "验证中", 998 998 + "verified": "已验证", 999 999 + "checkAgain": "重新验证", 989 1000 "newHandle": "新用户名", 990 1001 "checkingAvailability": "检查可用性...", 991 1002 "handleAvailable": "用户名可用！",

+1 -1

frontend/src/styles/migration.css

··· 1 1 .migration-wizard { 2 2 - max-width: var(--width-sm); 2 2 + max-width: var(--width-md); 3 3 margin: 0 auto; 4 4 } 5 5

+87

frontend/src/tests/migration/atproto-client.test.ts

··· 1 1 import { beforeEach, describe, expect, it } from "vitest"; 2 2 import { 3 3 + AtprotoClient, 3 4 base64UrlDecode, 4 5 base64UrlEncode, 5 6 buildOAuthAuthorizationUrl, ··· 517 518 expect(prepared.user?.displayName).toBe("Test User"); 518 519 }); 519 520 }); 521 521 + 522 522 + describe("AtprotoClient.verifyHandleOwnership", () => { 523 523 + function createMockJsonResponse(data: unknown, status = 200) { 524 524 + return new Response(JSON.stringify(data), { 525 525 + status, 526 526 + headers: { "Content-Type": "application/json" }, 527 527 + }); 528 528 + } 529 529 + 530 530 + it("sends POST with handle and did", async () => { 531 531 + globalThis.fetch = vi.fn().mockResolvedValue( 532 532 + createMockJsonResponse({ verified: true, method: "dns" }), 533 533 + ); 534 534 + 535 535 + const client = new AtprotoClient("https://pds.example.com"); 536 536 + await client.verifyHandleOwnership("alice.custom.com", "did:plc:abc123"); 537 537 + 538 538 + expect(fetch).toHaveBeenCalledWith( 539 539 + "https://pds.example.com/xrpc/_identity.verifyHandleOwnership", 540 540 + expect.objectContaining({ 541 541 + method: "POST", 542 542 + }), 543 543 + ); 544 544 + }); 545 545 + 546 546 + it("returns verified result with method", async () => { 547 547 + globalThis.fetch = vi.fn().mockResolvedValue( 548 548 + createMockJsonResponse({ verified: true, method: "dns" }), 549 549 + ); 550 550 + 551 551 + const client = new AtprotoClient("https://pds.example.com"); 552 552 + const result = await client.verifyHandleOwnership( 553 553 + "alice.custom.com", 554 554 + "did:plc:abc123", 555 555 + ); 556 556 + 557 557 + expect(result.verified).toBe(true); 558 558 + expect(result.method).toBe("dns"); 559 559 + }); 560 560 + 561 561 + it("returns unverified result with error", async () => { 562 562 + globalThis.fetch = vi.fn().mockResolvedValue( 563 563 + createMockJsonResponse({ 564 564 + verified: false, 565 565 + error: "Handle resolution failed", 566 566 + }), 567 567 + ); 568 568 + 569 569 + const client = new AtprotoClient("https://pds.example.com"); 570 570 + const result = await client.verifyHandleOwnership( 571 571 + "nonexistent.example.com", 572 572 + "did:plc:abc123", 573 573 + ); 574 574 + 575 575 + expect(result.verified).toBe(false); 576 576 + expect(result.error).toBe("Handle resolution failed"); 577 577 + }); 578 578 + 579 579 + it("throws on server error responses", async () => { 580 580 + globalThis.fetch = vi.fn().mockResolvedValue( 581 581 + createMockJsonResponse( 582 582 + { error: "InvalidHandle", message: "Invalid handle format" }, 583 583 + 400, 584 584 + ), 585 585 + ); 586 586 + 587 587 + const client = new AtprotoClient("https://pds.example.com"); 588 588 + await expect( 589 589 + client.verifyHandleOwnership("@#$!", "did:plc:abc123"), 590 590 + ).rejects.toThrow("Invalid handle format"); 591 591 + }); 592 592 + 593 593 + it("strips trailing slash from base URL", async () => { 594 594 + globalThis.fetch = vi.fn().mockResolvedValue( 595 595 + createMockJsonResponse({ verified: true, method: "http" }), 596 596 + ); 597 597 + 598 598 + const client = new AtprotoClient("https://pds.example.com/"); 599 599 + await client.verifyHandleOwnership("alice.example.com", "did:plc:abc"); 600 600 + 601 601 + expect(fetch).toHaveBeenCalledWith( 602 602 + "https://pds.example.com/xrpc/_identity.verifyHandleOwnership", 603 603 + expect.anything(), 604 604 + ); 605 605 + }); 606 606 + }); 520 607 });

+206

frontend/src/tests/migration/flow-handle-preservation.test.ts

··· 1 1 + import { beforeEach, describe, expect, it, vi } from "vitest"; 2 2 + import { createInboundMigrationFlow } from "../../lib/migration/flow.svelte.ts"; 3 3 + 4 4 + const STORAGE_KEY = "tranquil_migration_state"; 5 5 + 6 6 + function createMockJsonResponse(data: unknown, status = 200) { 7 7 + return new Response(JSON.stringify(data), { 8 8 + status, 9 9 + headers: { "Content-Type": "application/json" }, 10 10 + }); 11 11 + } 12 12 + 13 13 + describe("migration/flow handle preservation", () => { 14 14 + beforeEach(() => { 15 15 + localStorage.removeItem(STORAGE_KEY); 16 16 + vi.restoreAllMocks(); 17 17 + }); 18 18 + 19 19 + describe("initial state", () => { 20 20 + it("defaults handlePreservation to 'new'", () => { 21 21 + const flow = createInboundMigrationFlow(); 22 22 + expect(flow.state.handlePreservation).toBe("new"); 23 23 + }); 24 24 + 25 25 + it("defaults existingHandleVerified to false", () => { 26 26 + const flow = createInboundMigrationFlow(); 27 27 + expect(flow.state.existingHandleVerified).toBe(false); 28 28 + }); 29 29 + }); 30 30 + 31 31 + describe("updateField for handle preservation", () => { 32 32 + it("sets handlePreservation to 'existing'", () => { 33 33 + const flow = createInboundMigrationFlow(); 34 34 + flow.updateField("handlePreservation", "existing"); 35 35 + expect(flow.state.handlePreservation).toBe("existing"); 36 36 + }); 37 37 + 38 38 + it("sets handlePreservation back to 'new'", () => { 39 39 + const flow = createInboundMigrationFlow(); 40 40 + flow.updateField("handlePreservation", "existing"); 41 41 + flow.updateField("handlePreservation", "new"); 42 42 + expect(flow.state.handlePreservation).toBe("new"); 43 43 + }); 44 44 + 45 45 + it("sets existingHandleVerified", () => { 46 46 + const flow = createInboundMigrationFlow(); 47 47 + flow.updateField("existingHandleVerified", true); 48 48 + expect(flow.state.existingHandleVerified).toBe(true); 49 49 + }); 50 50 + }); 51 51 + 52 52 + describe("verifyExistingHandle", () => { 53 53 + it("sets existingHandleVerified and targetHandle on success", async () => { 54 54 + globalThis.fetch = vi.fn().mockResolvedValue( 55 55 + createMockJsonResponse({ verified: true, method: "dns" }), 56 56 + ); 57 57 + 58 58 + const flow = createInboundMigrationFlow(); 59 59 + flow.updateField("sourceHandle", "alice.custom.com"); 60 60 + flow.updateField("sourceDid", "did:plc:abc123"); 61 61 + 62 62 + const result = await flow.verifyExistingHandle(); 63 63 + 64 64 + expect(result.verified).toBe(true); 65 65 + expect(result.method).toBe("dns"); 66 66 + expect(flow.state.existingHandleVerified).toBe(true); 67 67 + expect(flow.state.targetHandle).toBe("alice.custom.com"); 68 68 + }); 69 69 + 70 70 + it("does not set existingHandleVerified on failure", async () => { 71 71 + globalThis.fetch = vi.fn().mockResolvedValue( 72 72 + createMockJsonResponse({ 73 73 + verified: false, 74 74 + error: "Handle resolution failed", 75 75 + }), 76 76 + ); 77 77 + 78 78 + const flow = createInboundMigrationFlow(); 79 79 + flow.updateField("sourceHandle", "alice.custom.com"); 80 80 + flow.updateField("sourceDid", "did:plc:abc123"); 81 81 + 82 82 + const result = await flow.verifyExistingHandle(); 83 83 + 84 84 + expect(result.verified).toBe(false); 85 85 + expect(result.error).toBe("Handle resolution failed"); 86 86 + expect(flow.state.existingHandleVerified).toBe(false); 87 87 + }); 88 88 + 89 89 + it("sends correct handle and did to endpoint", async () => { 90 90 + globalThis.fetch = vi.fn().mockResolvedValue( 91 91 + createMockJsonResponse({ verified: true, method: "http" }), 92 92 + ); 93 93 + 94 94 + const flow = createInboundMigrationFlow(); 95 95 + flow.updateField("sourceHandle", "bob.example.org"); 96 96 + flow.updateField("sourceDid", "did:plc:xyz789"); 97 97 + 98 98 + await flow.verifyExistingHandle(); 99 99 + 100 100 + expect(fetch).toHaveBeenCalledWith( 101 101 + expect.stringContaining("_identity.verifyHandleOwnership"), 102 102 + expect.objectContaining({ 103 103 + method: "POST", 104 104 + body: JSON.stringify({ 105 105 + handle: "bob.example.org", 106 106 + did: "did:plc:xyz789", 107 107 + }), 108 108 + }), 109 109 + ); 110 110 + }); 111 111 + 112 112 + it("handles http verification method", async () => { 113 113 + globalThis.fetch = vi.fn().mockResolvedValue( 114 114 + createMockJsonResponse({ verified: true, method: "http" }), 115 115 + ); 116 116 + 117 117 + const flow = createInboundMigrationFlow(); 118 118 + flow.updateField("sourceHandle", "alice.custom.com"); 119 119 + flow.updateField("sourceDid", "did:plc:abc123"); 120 120 + 121 121 + const result = await flow.verifyExistingHandle(); 122 122 + 123 123 + expect(result.method).toBe("http"); 124 124 + }); 125 125 + 126 126 + it("propagates xrpc errors as thrown exceptions", async () => { 127 127 + globalThis.fetch = vi.fn().mockResolvedValue( 128 128 + createMockJsonResponse( 129 129 + { error: "InvalidHandle", message: "Invalid handle format" }, 130 130 + 400, 131 131 + ), 132 132 + ); 133 133 + 134 134 + const flow = createInboundMigrationFlow(); 135 135 + flow.updateField("sourceHandle", "@#$!"); 136 136 + flow.updateField("sourceDid", "did:plc:abc123"); 137 137 + 138 138 + await expect(flow.verifyExistingHandle()).rejects.toThrow(); 139 139 + }); 140 140 + }); 141 141 + 142 142 + describe("reset clears handle preservation state", () => { 143 143 + it("resets handlePreservation to 'new'", () => { 144 144 + const flow = createInboundMigrationFlow(); 145 145 + flow.updateField("handlePreservation", "existing"); 146 146 + flow.updateField("existingHandleVerified", true); 147 147 + 148 148 + flow.reset(); 149 149 + 150 150 + expect(flow.state.handlePreservation).toBe("new"); 151 151 + expect(flow.state.existingHandleVerified).toBe(false); 152 152 + }); 153 153 + }); 154 154 + 155 155 + describe("handle @ normalization", () => { 156 156 + it("resolveSourcePds strips leading @", async () => { 157 157 + globalThis.fetch = vi.fn() 158 158 + .mockResolvedValueOnce( 159 159 + createMockJsonResponse({ 160 160 + Answer: [{ data: '"did=did:plc:test123"' }], 161 161 + }), 162 162 + ) 163 163 + .mockResolvedValueOnce( 164 164 + createMockJsonResponse({ 165 165 + id: "did:plc:test123", 166 166 + service: [ 167 167 + { 168 168 + type: "AtprotoPersonalDataServer", 169 169 + serviceEndpoint: "https://pds.example.com", 170 170 + }, 171 171 + ], 172 172 + }), 173 173 + ); 174 174 + 175 175 + const flow = createInboundMigrationFlow(); 176 176 + await flow.resolveSourcePds("@alice.example.com"); 177 177 + 178 178 + expect(flow.state.sourceHandle).toBe("alice.example.com"); 179 179 + }); 180 180 + 181 181 + it("resolveSourcePds preserves handle without @", async () => { 182 182 + globalThis.fetch = vi.fn() 183 183 + .mockResolvedValueOnce( 184 184 + createMockJsonResponse({ 185 185 + Answer: [{ data: '"did=did:plc:test456"' }], 186 186 + }), 187 187 + ) 188 188 + .mockResolvedValueOnce( 189 189 + createMockJsonResponse({ 190 190 + id: "did:plc:test456", 191 191 + service: [ 192 192 + { 193 193 + type: "AtprotoPersonalDataServer", 194 194 + serviceEndpoint: "https://pds.example.com", 195 195 + }, 196 196 + ], 197 197 + }), 198 198 + ); 199 199 + 200 200 + const flow = createInboundMigrationFlow(); 201 201 + await flow.resolveSourcePds("bob.example.com"); 202 202 + 203 203 + expect(flow.state.sourceHandle).toBe("bob.example.com"); 204 204 + }); 205 205 + }); 206 206 + });

+20

frontend/src/tests/migration/storage.test.ts

··· 86 86 localAccessToken: null, 87 87 generatedAppPassword: null, 88 88 generatedAppPasswordName: null, 89 89 + handlePreservation: "new", 90 90 + existingHandleVerified: false, 89 91 ...overrides, 90 92 }; 91 93 } ··· 203 205 expect(stored.passkeySetupToken).toBe("setup-token-123"); 204 206 }); 205 207 208 208 + it("does not persist handlePreservation to storage (transient state)", () => { 209 209 + const state = createInboundState({ handlePreservation: "existing" }); 210 210 + 211 211 + saveMigrationState(state); 212 212 + 213 213 + const stored = JSON.parse(localStorage.getItem(STORAGE_KEY)!); 214 214 + expect(stored.handlePreservation).toBeUndefined(); 215 215 + }); 216 216 + 217 217 + it("does not persist existingHandleVerified to storage (transient state)", () => { 218 218 + const state = createInboundState({ existingHandleVerified: true }); 219 219 + 220 220 + saveMigrationState(state); 221 221 + 222 222 + const stored = JSON.parse(localStorage.getItem(STORAGE_KEY)!); 223 223 + expect(stored.existingHandleVerified).toBeUndefined(); 224 224 + }); 225 225 + 206 226 it("saves error information", () => { 207 227 const state = createInboundState({ 208 228 step: "error",

+15

frontend/src/tests/setup.ts

··· 10 10 initialLocale: "en", 11 11 }); 12 12 13 13 + Object.defineProperty(window, "matchMedia", { 14 14 + writable: true, 15 15 + configurable: true, 16 16 + value: vi.fn((query: string) => ({ 17 17 + matches: false, 18 18 + media: query, 19 19 + onchange: null, 20 20 + addListener: vi.fn(), 21 21 + removeListener: vi.fn(), 22 22 + addEventListener: vi.fn(), 23 23 + removeEventListener: vi.fn(), 24 24 + dispatchEvent: vi.fn(), 25 25 + })), 26 26 + }); 27 27 + 13 28 let locationHash = ""; 14 29 15 30 Object.defineProperty(window, "location", {