+5 -18

README.md

··· 59 59 60 60 `apps/main-app` exposes domain claim/status XRPC endpoints: 61 61 62 62 + - `place.wisp.v2.domain.claimSubdomain` (procedure / POST, wisp handles) 62 63 - `place.wisp.v2.domain.claim` (procedure / POST) 64 64 + - `place.wisp.v2.domain.delete` (procedure / POST) 65 65 + - `place.wisp.v2.domain.getList` (query / GET) 63 66 - `place.wisp.v2.domain.getStatus` (query / GET) 64 67 65 68 The server validates **serviceAuth JWTs** (not cookie auth, not direct end-user access JWTs) on `/xrpc/*`. ··· 83 86 84 87 ### Local TLS Requirement (No Auto Cert Generation) 85 88 86 86 - Some PDS proxy flows require HTTPS on `:443` for the proxied service endpoint. 87 87 - Cert generation is intentionally manual so SANs are explicit and correct for your environment. 88 88 - 89 89 - Example with `mkcert`: 90 90 - 91 91 - ```bash 92 92 - mkcert -cert-file certs/dev-cert.pem -key-file certs/dev-key.pem regentsmacbookair localhost 100.64.0.2 93 93 - ``` 94 94 - 95 95 - Use SANs that match exactly what your PDS will call (hostname and/or IP). 96 96 - `apps/main-app` can terminate TLS directly in local dev with: 97 97 - 98 98 - ```env 99 99 - PORT=443 100 100 - LOCAL_DEV_TLS=true 101 101 - LOCAL_TLS_CERT_PATH=./certs/dev-cert.pem 102 102 - LOCAL_TLS_KEY_PATH=./certs/dev-key.pem 103 103 - ``` 89 89 + `apps/main-app` now serves HTTP only. If you need HTTPS in local/proxy flows, 90 90 + terminate TLS in your reverse proxy or tunnel layer and forward plain HTTP to main-app. 104 91 105 92 106 93 ```bash

+25 -38

apps/main-app/src/index.ts

··· 1 1 // Fix for Elysia issue with Bun, (see https://github.com/oven-sh/bun/issues/12161) 2 2 process.getBuiltinModule = require; 3 3 4 4 - import { existsSync } from 'node:fs' 5 5 - 6 4 import { Elysia, t } from 'elysia' 7 5 import type { Context } from 'elysia' 8 6 import { cors } from '@elysiajs/cors' ··· 50 48 const didServiceIds = parsedServiceIds.length > 0 51 49 ? Array.from(new Set(parsedServiceIds)) 52 50 : ['#wisp_xrpc'] 53 53 - const serverPort = Number(Bun.env.PORT ?? (isLocalDev ? '443' : '80')) 54 54 - const localTlsEnabled = isLocalDev && Bun.env.LOCAL_DEV_TLS !== 'false' 55 55 - const localTlsCertPath = Bun.env.LOCAL_TLS_CERT_PATH ?? './certs/dev-cert.pem' 56 56 - const localTlsKeyPath = Bun.env.LOCAL_TLS_KEY_PATH ?? './certs/dev-key.pem' 51 51 + const serverPort = Number(Bun.env.PORT ?? (isLocalDev ? '8000' : '80')) 57 52 58 58 - logger.info('[Server] Local TLS config', { 53 53 + logger.info('[Server] Startup config', { 59 54 isLocalDev, 60 60 - localTlsEnabled, 61 61 - port: serverPort, 62 62 - certPath: localTlsEnabled ? localTlsCertPath : undefined, 63 63 - keyPath: localTlsEnabled ? localTlsKeyPath : undefined 55 55 + port: serverPort 64 56 }) 65 57 66 58 const config: Config = { ··· 124 116 }) 125 117 // Observability middleware 126 118 .onBeforeHandle(observabilityMiddleware('main-app').beforeHandle) 119 119 + .onRequest(({ request }) => { 120 120 + if (isLocalDev) { 121 121 + const pathname = new URL(request.url).pathname 122 122 + if (pathname.startsWith('/xrpc/')) { 123 123 + console.log('[Server] Incoming /xrpc request', { 124 124 + method: request.method, 125 125 + path: pathname 126 126 + }) 127 127 + } 128 128 + } 129 129 + }) 127 130 .onAfterHandle((ctx: Context) => { 128 131 observabilityMiddleware('main-app').afterHandle(ctx) 129 132 // Security headers middleware ··· 214 217 return html.replaceAll('{{ATPROTO_LOGIN_URL}}', atprotoLoginUrl) 215 218 }) 216 219 .use(authRoutes(client, cookieSecret)) 217 217 - .use(xrpcRoutes()) 218 220 .use(wispRoutes(client, cookieSecret)) 219 221 .use(domainRoutes(client, cookieSecret)) 220 222 .use(userRoutes(client, cookieSecret)) ··· 223 225 .use( 224 226 await staticPlugin({ 225 227 assets: './apps/main-app/public', 226 226 - prefix: '/' 228 228 + prefix: '/', 229 229 + // Prevent dev-mode GET /* fallback from swallowing XRPC GET routes. 230 230 + alwaysStatic: true, 231 231 + staticLimit: 10000 227 232 }) 228 233 ) 229 234 // Production only: serve built assets from dist ··· 257 262 }) 258 263 : (app) => app 259 264 ) 265 265 + // Keep XRPC after static in dev, since staticPlugin(prefix='/') installs GET /* fallback. 266 266 + .use(xrpcRoutes()) 260 267 // Production only: serve built admin assets 261 268 .use( 262 269 Bun.env.NODE_ENV === 'production' ··· 436 443 exposeHeaders: ['Content-Type', 'DPoP-Nonce', 'dpop-nonce'], 437 444 maxAge: 86400 // 24 hours 438 445 })) 439 439 - .listen( 440 440 - localTlsEnabled 441 441 - ? (() => { 442 442 - if (!existsSync(localTlsCertPath)) { 443 443 - throw new Error(`LOCAL_DEV TLS cert not found at ${localTlsCertPath}`) 444 444 - } 445 445 - if (!existsSync(localTlsKeyPath)) { 446 446 - throw new Error(`LOCAL_DEV TLS key not found at ${localTlsKeyPath}`) 447 447 - } 448 448 - 449 449 - return { 450 450 - port: serverPort, 451 451 - hostname: '0.0.0.0', 452 452 - tls: { 453 453 - cert: Bun.file(localTlsCertPath), 454 454 - key: Bun.file(localTlsKeyPath) 455 455 - } 456 456 - } 457 457 - })() 458 458 - : { 459 459 - port: serverPort, 460 460 - hostname: '0.0.0.0' 461 461 - } 462 462 - ) 446 446 + .listen({ 447 447 + port: serverPort, 448 448 + hostname: '0.0.0.0' 449 449 + }) 463 450 464 451 console.log( 465 465 - `🦊 Elysia is running at ${localTlsEnabled ? 'https' : 'http'}://${app.server?.hostname}:${app.server?.port}` 452 452 + `🦊 Elysia is running at http://${app.server?.hostname}:${app.server?.port}` 466 453 ) 467 454 468 455 // Graceful shutdown

+1 -2

apps/main-app/src/lib/db.ts

··· 421 421 export const claimCustomDomain = async (did: string, domain: string, hash: string, rkey: string | null = null) => { 422 422 const domainLower = domain.toLowerCase(); 423 423 try { 424 424 - // Use UPSERT with ON CONFLICT to handle existing pending domains 425 424 const result = await db` 426 425 INSERT INTO custom_domains (id, domain, did, rkey, verified, created_at) 427 426 VALUES (${hash}, ${domainLower}, ${did}, ${rkey}, false, EXTRACT(EPOCH FROM NOW())) ··· 436 435 `; 437 436 438 437 if (result.length === 0) { 439 439 - // No rows were updated, meaning the domain exists and is verified 438 438 + console.log('Failed to claim custom domain - already verified by another user'); 440 439 throw new Error('conflict'); 441 440 } 442 441

+12 -3

apps/main-app/src/routes/domain.ts

··· 219 219 throw new Error(`Invalid domain: ${domainError}`) 220 220 } 221 221 222 222 - // Check if already exists and is verified 222 222 + // Verified claims are DID-locked. Pending claims can be reclaimed. 223 223 const existing = await getCustomDomainInfo(domainLower); 224 224 - if (existing && existing.verified) { 224 224 + if (existing && existing.verified && existing.did !== auth.did) { 225 225 set.status = 409 226 226 - throw new Error('Domain already verified and claimed'); 226 226 + throw new Error('Domain already claimed'); 227 227 + } 228 228 + 229 229 + if (existing && existing.did === auth.did) { 230 230 + return { 231 231 + success: true, 232 232 + id: existing.id, 233 233 + domain: domainLower, 234 234 + verified: Boolean(existing.verified) 235 235 + }; 227 236 } 228 237 229 238 // Create hash for ID

+353 -98

apps/main-app/src/routes/xrpc.ts

··· 5 5 import { CompositeDidDocumentResolver, PlcDidDocumentResolver, WebDidDocumentResolver } from '@atcute/identity-resolver'; 6 6 import { json, XRPCRouter, XRPCError } from '@atcute/xrpc-server'; 7 7 import { ServiceJwtVerifier } from '@atcute/xrpc-server/auth'; 8 8 - import { PlaceWispV2DomainClaim, PlaceWispV2DomainGetStatus } from '@wispplace/lexicons/atcute'; 8 8 + import { 9 9 + PlaceWispV2DomainClaim, 10 10 + PlaceWispV2DomainClaimSubdomain, 11 11 + PlaceWispV2DomainDelete, 12 12 + PlaceWispV2DomainGetList, 13 13 + PlaceWispV2DomainGetStatus, 14 14 + } from '@wispplace/lexicons/atcute'; 9 15 import { BASE_HOST } from '@wispplace/constants'; 10 16 11 17 import { createLogger } from '@wispplace/observability'; ··· 13 19 import { 14 20 claimCustomDomain, 15 21 claimDomain, 22 22 + deleteCustomDomain, 23 23 + deleteWispDomain, 24 24 + getAllWispDomains, 25 25 + getCustomDomainsByDid, 16 26 getCustomDomainInfo, 17 27 isDomainRegistered, 18 28 updateCustomDomainRkey, ··· 22 32 extractWispHandle, 23 33 isValidHandle, 24 34 normalizeDomain, 35 35 + toDomain, 25 36 validateCustomDomain, 26 37 } from '../lib/domain-utils'; 27 38 ··· 45 56 }); 46 57 47 58 const NSID_ALIASES: Record<string, string> = { 59 59 + 'place.wisp.v2.domain.claim-subdomain': 'place.wisp.v2.domain.claimSubdomain', 60 60 + 'place.wisp.v2.domain.claimsubdomain': 'place.wisp.v2.domain.claimSubdomain', 61 61 + 'place.wisp.v2.domain.claimsub-domain': 'place.wisp.v2.domain.claimSubdomain', 62 62 + 'place.wisp.v2.domain.get-list': 'place.wisp.v2.domain.getList', 63 63 + 'place.wisp.v2.domain.getlist': 'place.wisp.v2.domain.getList', 48 64 'place.wisp.v2.domain.getstatus': 'place.wisp.v2.domain.getStatus', 49 65 'place.wisp.v2.domain.get-status': 'place.wisp.v2.domain.getStatus', 50 66 }; 67 67 + 68 68 + const XRPC_NSIDS = { 69 69 + getStatus: 'place.wisp.v2.domain.getStatus', 70 70 + getList: 'place.wisp.v2.domain.getList', 71 71 + claimSubdomain: 'place.wisp.v2.domain.claimSubdomain', 72 72 + claim: 'place.wisp.v2.domain.claim', 73 73 + delete: 'place.wisp.v2.domain.delete', 74 74 + } as const; 51 75 52 76 const toIsoFromEpoch = (epoch: unknown): string | undefined => { 53 77 let numeric: number | undefined; ··· 111 135 }); 112 136 }; 113 137 138 138 + const notFound = (description = 'domain not found'): never => { 139 139 + throw new XRPCError({ 140 140 + status: 404, 141 141 + error: 'NotFound', 142 142 + description, 143 143 + }); 144 144 + }; 145 145 + 114 146 const requireAuthenticated = (auth: XrpcAuthContext | undefined): XrpcAuthContext => { 115 147 if (!auth) { 116 148 authRequired(); ··· 193 225 194 226 const normalizeNsidPath = (request: Request): { request: Request; rawNsid: string; nsid: string } => { 195 227 const url = new URL(request.url); 196 196 - const rawNsid = url.pathname.startsWith('/xrpc/') ? url.pathname.slice('/xrpc/'.length) : url.pathname; 228 228 + const rawNsidFull = url.pathname.startsWith('/xrpc/') ? url.pathname.slice('/xrpc/'.length) : url.pathname; 229 229 + const rawNsid = rawNsidFull.replace(/^\/+|\/+$/g, ''); 197 230 const nsid = NSID_ALIASES[rawNsid] ?? rawNsid; 198 231 199 232 if (nsid === rawNsid) { ··· 209 242 }; 210 243 }; 211 244 245 245 + const withNsid = <T extends { nsid: string }>(schema: T, nsid: string): T => { 246 246 + if (schema.nsid === nsid) { 247 247 + return schema; 248 248 + } 249 249 + 250 250 + return { ...schema, nsid } as T; 251 251 + }; 252 252 + 253 253 + const addQueryWithAliases = ( 254 254 + router: XRPCRouter, 255 255 + schema: { nsid: string }, 256 256 + aliases: readonly string[], 257 257 + config: { handler: (ctx: any) => Promise<Response> | Response }, 258 258 + ) => { 259 259 + const seen = new Set<string>(); 260 260 + for (const nsid of [schema.nsid, ...aliases]) { 261 261 + if (seen.has(nsid)) { 262 262 + continue; 263 263 + } 264 264 + seen.add(nsid); 265 265 + router.addQuery(withNsid(schema as any, nsid), config as any); 266 266 + } 267 267 + }; 268 268 + 269 269 + const addProcedureWithAliases = ( 270 270 + router: XRPCRouter, 271 271 + schema: { nsid: string }, 272 272 + aliases: readonly string[], 273 273 + config: { handler: (ctx: any) => Promise<Response> | Response }, 274 274 + ) => { 275 275 + const seen = new Set<string>(); 276 276 + for (const nsid of [schema.nsid, ...aliases]) { 277 277 + if (seen.has(nsid)) { 278 278 + continue; 279 279 + } 280 280 + seen.add(nsid); 281 281 + router.addProcedure(withNsid(schema as any, nsid), config as any); 282 282 + } 283 283 + }; 284 284 + 285 285 + const claimWispSubdomain = async ( 286 286 + did: DidString, 287 287 + input: { handle: string; siteRkey?: string }, 288 288 + ) => { 289 289 + const handle = input.handle.trim().toLowerCase(); 290 290 + if (!isValidHandle(handle)) { 291 291 + invalidDomain('invalid wisp subdomain handle'); 292 292 + } 293 293 + 294 294 + const domain = toDomain(handle); 295 295 + const existing = await isDomainRegistered(domain); 296 296 + if (existing.registered && existing.did !== did) { 297 297 + alreadyClaimed('domain is already claimed'); 298 298 + } 299 299 + 300 300 + if (existing.registered && existing.did === did) { 301 301 + if (input.siteRkey !== undefined) { 302 302 + await updateWispDomainSite(domain, input.siteRkey); 303 303 + } 304 304 + 305 305 + return json({ 306 306 + domain, 307 307 + kind: 'wisp', 308 308 + status: 'verified', 309 309 + siteRkey: input.siteRkey ?? existing.rkey ?? undefined, 310 310 + }); 311 311 + } 312 312 + 313 313 + try { 314 314 + await claimDomain(did, handle); 315 315 + } catch (err) { 316 316 + const message = err instanceof Error ? err.message : ''; 317 317 + 318 318 + if (message === 'domain_limit_reached') { 319 319 + domainLimitReached(); 320 320 + } 321 321 + if (message === 'invalid_handle') { 322 322 + invalidDomain('invalid wisp subdomain handle'); 323 323 + } 324 324 + 325 325 + alreadyClaimed('domain is already claimed'); 326 326 + } 327 327 + 328 328 + if (input.siteRkey !== undefined) { 329 329 + await updateWispDomainSite(domain, input.siteRkey); 330 330 + } 331 331 + 332 332 + return json({ 333 333 + domain, 334 334 + kind: 'wisp', 335 335 + status: 'verified', 336 336 + siteRkey: input.siteRkey, 337 337 + }); 338 338 + }; 339 339 + 340 340 + const claimCustomDomainForDid = async ( 341 341 + did: DidString, 342 342 + input: { domain: string; siteRkey?: string }, 343 343 + ) => { 344 344 + const domain = normalizeDomain(input.domain); 345 345 + if (domain.length === 0) { 346 346 + invalidDomain('domain is required'); 347 347 + } 348 348 + 349 349 + if (extractWispHandle(domain) !== null) { 350 350 + invalidDomain('wisp subdomains must be claimed via place.wisp.v2.domain.claimSubdomain'); 351 351 + } 352 352 + 353 353 + const customError = validateCustomDomain(domain); 354 354 + if (customError !== null) { 355 355 + invalidDomain(customError); 356 356 + } 357 357 + 358 358 + const existing = await getCustomDomainInfo(domain); 359 359 + if (existing && existing.verified && existing.did !== did) { 360 360 + alreadyClaimed('domain is already claimed'); 361 361 + } 362 362 + 363 363 + if (existing && existing.did === did) { 364 364 + if (input.siteRkey !== undefined) { 365 365 + await updateCustomDomainRkey(existing.id, input.siteRkey); 366 366 + } 367 367 + 368 368 + const status = existing.verified ? 'verified' : 'pendingVerification'; 369 369 + 370 370 + return json({ 371 371 + domain, 372 372 + kind: 'custom', 373 373 + status, 374 374 + siteRkey: input.siteRkey ?? existing.rkey ?? undefined, 375 375 + ...buildCustomDnsInstructions(domain, did, existing.id), 376 376 + }); 377 377 + } 378 378 + 379 379 + const challengeId = createHash('sha256').update(`${did}:${domain}`).digest('hex').substring(0, 16); 380 380 + 381 381 + try { 382 382 + await claimCustomDomain(did, domain, challengeId, input.siteRkey ?? null); 383 383 + } catch { 384 384 + alreadyClaimed('domain is already claimed'); 385 385 + } 386 386 + 387 387 + return json({ 388 388 + domain, 389 389 + kind: 'custom', 390 390 + status: 'pendingVerification', 391 391 + siteRkey: input.siteRkey, 392 392 + ...buildCustomDnsInstructions(domain, did, challengeId), 393 393 + }); 394 394 + }; 395 395 + 212 396 export const xrpcRoutes = () => { 213 397 const authByRequest = new WeakMap<Request, XrpcAuthContext>(); 214 398 const router = new XRPCRouter(); 399 399 + const registeredNsids = [ 400 400 + XRPC_NSIDS.getStatus, 401 401 + XRPC_NSIDS.getList, 402 402 + XRPC_NSIDS.claimSubdomain, 403 403 + XRPC_NSIDS.claim, 404 404 + XRPC_NSIDS.delete, 405 405 + ]; 215 406 216 216 - router.addQuery(PlaceWispV2DomainGetStatus.mainSchema, { 407 407 + addQueryWithAliases( 408 408 + router, 409 409 + withNsid(PlaceWispV2DomainGetStatus.mainSchema as any, XRPC_NSIDS.getStatus), 410 410 + ['place.wisp.v2.domain.getstatus', 'place.wisp.v2.domain.get-status'], 411 411 + { 217 412 async handler({ params, request }) { 218 413 const domain = normalizeDomain(params.domain); 219 414 const auth = authByRequest.get(request); ··· 233 428 const kind = info.type; 234 429 const ownedByCaller = auth ? auth.did === info.did : undefined; 235 430 236 236 - if (auth && ownedByCaller === false) { 431 431 + if ( 432 432 + auth && 433 433 + ownedByCaller === false && 434 434 + (kind === 'wisp' || (kind === 'custom' && Boolean(info.verified))) 435 435 + ) { 237 436 return json({ 238 437 domain, 239 438 kind, ··· 265 464 siteRkey: info.rkey ?? undefined, 266 465 }); 267 466 }, 268 268 - }); 467 467 + }, 468 468 + ); 269 469 270 270 - router.addProcedure(PlaceWispV2DomainClaim.mainSchema, { 271 271 - async handler({ input, request }) { 470 470 + addQueryWithAliases( 471 471 + router, 472 472 + withNsid(PlaceWispV2DomainGetList.mainSchema as any, XRPC_NSIDS.getList), 473 473 + ['place.wisp.v2.domain.getlist', 'place.wisp.v2.domain.get-list'], 474 474 + { 475 475 + async handler({ request }) { 272 476 const auth = requireAuthenticated(authByRequest.get(request)); 273 477 const did = auth.did as DidString; 274 478 275 275 - const domain = normalizeDomain(input.domain); 276 276 - if (domain.length === 0) { 277 277 - invalidDomain('domain is required'); 278 278 - } 479 479 + const [wispDomains, customDomains] = await Promise.all([ 480 480 + getAllWispDomains(did), 481 481 + getCustomDomainsByDid(did), 482 482 + ]); 279 483 280 280 - const wispHandle = extractWispHandle(domain); 281 281 - if (wispHandle !== null) { 282 282 - if (!isValidHandle(wispHandle)) { 283 283 - invalidDomain('invalid wisp subdomain handle'); 284 284 - } 484 484 + const domains = [ 485 485 + ...wispDomains.map((entry: { domain: string; rkey: string | null }) => ({ 486 486 + domain: entry.domain as string, 487 487 + kind: 'wisp' as const, 488 488 + status: 'verified' as const, 489 489 + verified: true, 490 490 + siteRkey: entry.rkey ?? undefined, 491 491 + })), 492 492 + ...customDomains.map((entry: { 493 493 + domain: string; 494 494 + verified: boolean; 495 495 + rkey: string | null; 496 496 + last_verified_at?: number | string | null; 497 497 + }) => ({ 498 498 + domain: entry.domain as string, 499 499 + kind: 'custom' as const, 500 500 + status: entry.verified ? 'verified' as const : 'pendingVerification' as const, 501 501 + verified: Boolean(entry.verified), 502 502 + siteRkey: entry.rkey ?? undefined, 503 503 + lastCheckedAt: toIsoFromEpoch(entry.last_verified_at), 504 504 + })), 505 505 + ].sort((a, b) => a.domain.localeCompare(b.domain)); 285 506 286 286 - const existing = await isDomainRegistered(domain); 287 287 - if (existing.registered && existing.did !== did) { 288 288 - alreadyClaimed('domain is already claimed'); 289 289 - } 507 507 + return json({ domains }); 508 508 + }, 509 509 + }, 510 510 + ); 290 511 291 291 - if (existing.registered && existing.did === did) { 292 292 - if (input.siteRkey !== undefined) { 293 293 - await updateWispDomainSite(domain, input.siteRkey); 294 294 - } 512 512 + addProcedureWithAliases( 513 513 + router, 514 514 + withNsid(PlaceWispV2DomainClaimSubdomain.mainSchema as any, XRPC_NSIDS.claimSubdomain), 515 515 + ['place.wisp.v2.domain.claimsubdomain', 'place.wisp.v2.domain.claim-subdomain'], 516 516 + { 517 517 + async handler({ input, request }) { 518 518 + const auth = requireAuthenticated(authByRequest.get(request)); 519 519 + const did = auth.did as DidString; 295 520 296 296 - return json({ 297 297 - domain, 298 298 - kind: 'wisp', 299 299 - status: 'alreadyClaimed', 300 300 - siteRkey: input.siteRkey ?? existing.rkey ?? undefined, 301 301 - }); 302 302 - } 521 521 + return claimWispSubdomain(did, { 522 522 + handle: input.handle, 523 523 + siteRkey: input.siteRkey, 524 524 + }); 525 525 + }, 526 526 + }, 527 527 + ); 303 528 304 304 - try { 305 305 - await claimDomain(did, wispHandle); 306 306 - } catch (err) { 307 307 - const message = err instanceof Error ? err.message : ''; 308 308 - 309 309 - if (message === 'domain_limit_reached') { 310 310 - domainLimitReached(); 311 311 - } 312 312 - if (message === 'invalid_handle') { 313 313 - invalidDomain('invalid wisp subdomain handle'); 314 314 - } 529 529 + addProcedureWithAliases( 530 530 + router, 531 531 + withNsid(PlaceWispV2DomainClaim.mainSchema as any, XRPC_NSIDS.claim), 532 532 + [], 533 533 + { 534 534 + async handler({ input, request }) { 535 535 + const auth = requireAuthenticated(authByRequest.get(request)); 536 536 + const did = auth.did as DidString; 315 537 316 316 - alreadyClaimed('domain is already claimed'); 317 317 - } 538 538 + return claimCustomDomainForDid(did, { 539 539 + domain: input.domain, 540 540 + siteRkey: input.siteRkey, 541 541 + }); 542 542 + }, 543 543 + }, 544 544 + ); 318 545 319 319 - if (input.siteRkey !== undefined) { 320 320 - await updateWispDomainSite(domain, input.siteRkey); 321 321 - } 546 546 + addProcedureWithAliases( 547 547 + router, 548 548 + withNsid(PlaceWispV2DomainDelete.mainSchema as any, XRPC_NSIDS.delete), 549 549 + [], 550 550 + { 551 551 + async handler({ params, request }) { 552 552 + const auth = requireAuthenticated(authByRequest.get(request)); 553 553 + const did = auth.did as DidString; 322 554 323 323 - return json({ 324 324 - domain, 325 325 - kind: 'wisp', 326 326 - status: 'verified', 327 327 - siteRkey: input.siteRkey, 328 328 - }); 555 555 + const domain = normalizeDomain(params.domain); 556 556 + if (domain.length === 0) { 557 557 + invalidDomain('domain is required'); 329 558 } 330 559 331 331 - const customError = validateCustomDomain(domain); 332 332 - if (customError !== null) { 333 333 - invalidDomain(customError); 560 560 + const existing = await isDomainRegistered(domain); 561 561 + if (!existing.registered) { 562 562 + notFound(); 334 563 } 335 564 336 336 - const existing = await getCustomDomainInfo(domain); 337 337 - if (existing && existing.verified && existing.did !== did) { 338 338 - alreadyClaimed('domain already verified and owned by another user'); 565 565 + if (existing.did !== did) { 566 566 + notFound(); 339 567 } 340 568 341 341 - if (existing && existing.did === did) { 342 342 - if (input.siteRkey !== undefined) { 343 343 - await updateCustomDomainRkey(existing.id, input.siteRkey); 569 569 + if (existing.type === 'wisp') { 570 570 + await deleteWispDomain(domain); 571 571 + } else { 572 572 + const custom = await getCustomDomainInfo(domain); 573 573 + if (!custom || custom.did !== did) { 574 574 + notFound(); 344 575 } 345 576 346 346 - const status = existing.verified ? 'verified' : 'pendingVerification'; 347 347 - 348 348 - return json({ 349 349 - domain, 350 350 - kind: 'custom', 351 351 - status, 352 352 - siteRkey: input.siteRkey ?? existing.rkey ?? undefined, 353 353 - ...buildCustomDnsInstructions(domain, did, existing.id), 354 354 - }); 355 355 - } 356 356 - 357 357 - const challengeId = createHash('sha256').update(`${did}:${domain}`).digest('hex').substring(0, 16); 358 358 - 359 359 - try { 360 360 - await claimCustomDomain(did, domain, challengeId, input.siteRkey ?? null); 361 361 - } catch (err) { 362 362 - alreadyClaimed('domain already verified and owned by another user'); 577 577 + await deleteCustomDomain(custom.id as string); 363 578 } 364 579 365 580 return json({ 366 581 domain, 367 367 - kind: 'custom', 368 368 - status: 'pendingVerification', 369 369 - siteRkey: input.siteRkey, 370 370 - ...buildCustomDnsInstructions(domain, did, challengeId), 582 582 + deleted: true, 371 583 }); 372 584 }, 585 585 + }, 586 586 + ); 587 587 + 588 588 + const schemaNsids = { 589 589 + getStatus: (PlaceWispV2DomainGetStatus.mainSchema as any).nsid, 590 590 + getList: (PlaceWispV2DomainGetList.mainSchema as any).nsid, 591 591 + claimSubdomain: (PlaceWispV2DomainClaimSubdomain.mainSchema as any).nsid, 592 592 + claim: (PlaceWispV2DomainClaim.mainSchema as any).nsid, 593 593 + delete: (PlaceWispV2DomainDelete.mainSchema as any).nsid, 594 594 + }; 595 595 + logger.info('[XRPC] Registered methods', { 596 596 + expectedNsids: registeredNsids, 597 597 + schemaNsids, 373 598 }); 599 599 + if (isLocalDev) { 600 600 + console.log('[XRPC] Registered methods', { 601 601 + expectedNsids: registeredNsids, 602 602 + schemaNsids, 603 603 + }); 604 604 + } 374 605 375 375 - return new Elysia().all('/xrpc/*', async ({ body, request }) => { 606 606 + const handleXrpcRequest = async (request: Request, body: unknown): Promise<Response> => { 376 607 const startedAt = Date.now(); 377 608 let xrpcRequest: Request | undefined; 378 609 let nsid = ''; ··· 387 618 nsid = normalized.nsid; 388 619 389 620 const authorization = xrpcRequest.headers.get('authorization'); 390 390 - logger.info('[XRPC] Incoming request', { 621 621 + const origin = xrpcRequest.headers.get('origin') ?? '-'; 622 622 + const authScheme = authorization ? authorization.split(' ')[0] : '-'; 623 623 + logger.info('[XRPC] Incoming', { 391 624 method: xrpcRequest.method, 392 625 rawNsid, 393 626 nsid, 394 394 - origin: xrpcRequest.headers.get('origin') ?? undefined, 395 395 - hasAuthorization: Boolean(authorization), 396 396 - authorizationScheme: authorization ? authorization.split(' ')[0] : undefined, 627 627 + origin, 628 628 + hasAuth: Boolean(authorization), 629 629 + scheme: authScheme, 397 630 }); 631 631 + if (isLocalDev) { 632 632 + console.log('[XRPC] Incoming', { 633 633 + method: xrpcRequest.method, 634 634 + rawNsid, 635 635 + nsid, 636 636 + origin, 637 637 + hasAuth: Boolean(authorization), 638 638 + scheme: authScheme, 639 639 + }); 640 640 + } 398 641 399 642 auth = await resolveServiceAuth(xrpcRequest, nsid); 400 643 if (auth) { ··· 411 654 responseData = await response.clone().text(); 412 655 } 413 656 414 414 - logger.warn('[XRPC] Request failed', { 657 657 + logger.warn('[XRPC] Failed', { 415 658 method: xrpcRequest.method, 416 659 rawNsid, 417 660 nsid, 418 661 status: response.status, 419 419 - did: auth?.did, 662 662 + did: auth?.did ?? '-', 663 663 + durationMs: Date.now() - startedAt, 420 664 origin: xrpcRequest.headers.get('origin') ?? undefined, 421 665 requestBodyUsed: request.bodyUsed, 422 666 error: responseData, 423 423 - durationMs: Date.now() - startedAt, 424 667 }); 425 668 } else { 426 426 - logger.info('[XRPC] Request succeeded', { 669 669 + logger.info('[XRPC] Succeeded', { 427 670 method: xrpcRequest.method, 428 671 rawNsid, 429 672 nsid, 430 673 status: response.status, 431 431 - did: auth?.did, 674 674 + did: auth?.did ?? '-', 432 675 durationMs: Date.now() - startedAt, 433 676 }); 434 677 } 435 678 436 679 return response; 437 680 } catch (err) { 438 438 - logger.error('[XRPC] Handler error', { 681 681 + logger.error('[XRPC] Handler error', err, { 439 682 method: xrpcRequest?.method ?? request.method, 440 440 - rawNsid: rawNsid || undefined, 441 441 - nsid: nsid || undefined, 442 442 - origin: request.headers.get('origin') ?? undefined, 683 683 + rawNsid: rawNsid || '-', 684 684 + nsid: nsid || '-', 443 685 durationMs: Date.now() - startedAt, 444 686 error: err instanceof Error ? err.message : String(err), 687 687 + origin: request.headers.get('origin') ?? undefined, 445 688 }); 446 689 throw err; 447 690 } finally { ··· 449 692 authByRequest.delete(xrpcRequest); 450 693 } 451 694 } 452 452 - }); 695 695 + }; 696 696 + 697 697 + return new Elysia() 698 698 + .all('/xrpc/:nsid', ({ body, request }) => handleXrpcRequest(request, body)) 699 699 + .all('/xrpc/:nsid/', async ({ body, request }) => { 700 700 + const url = new URL(request.url); 701 701 + if (url.pathname.endsWith('/') && url.pathname.length > '/xrpc/'.length) { 702 702 + url.pathname = url.pathname.slice(0, -1); 703 703 + } 704 704 + 705 705 + const rewritten = new Request(url.toString(), request); 706 706 + return handleXrpcRequest(rewritten, body); 707 707 + }); 453 708 };

+61

lexicons/domain-claim-subdomain-v2.json

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "place.wisp.v2.domain.claimSubdomain", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Claim a wisp.place subdomain handle for the authenticated DID.", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["handle"], 13 13 + "properties": { 14 14 + "handle": { 15 15 + "type": "string", 16 16 + "description": "Subdomain label only (for example, alice).", 17 17 + "minLength": 3, 18 18 + "maxLength": 63 19 19 + }, 20 20 + "siteRkey": { 21 21 + "type": "string", 22 22 + "format": "record-key", 23 23 + "description": "Optional place.wisp.fs rkey to map immediately after claim." 24 24 + } 25 25 + } 26 26 + } 27 27 + }, 28 28 + "output": { 29 29 + "encoding": "application/json", 30 30 + "schema": { 31 31 + "type": "object", 32 32 + "required": ["domain", "kind", "status"], 33 33 + "properties": { 34 34 + "domain": { 35 35 + "type": "string" 36 36 + }, 37 37 + "kind": { 38 38 + "type": "string", 39 39 + "enum": ["wisp"] 40 40 + }, 41 41 + "status": { 42 42 + "type": "string", 43 43 + "enum": ["verified", "alreadyClaimed"] 44 44 + }, 45 45 + "siteRkey": { 46 46 + "type": "string", 47 47 + "format": "record-key" 48 48 + } 49 49 + } 50 50 + } 51 51 + }, 52 52 + "errors": [ 53 53 + { "name": "AuthenticationRequired" }, 54 54 + { "name": "InvalidDomain" }, 55 55 + { "name": "AlreadyClaimed" }, 56 56 + { "name": "DomainLimitReached" }, 57 57 + { "name": "RateLimitExceeded" } 58 58 + ] 59 59 + } 60 60 + } 61 61 + }

+3 -3

lexicons/domain-claim-v2.json

··· 4 4 "defs": { 5 5 "main": { 6 6 "type": "procedure", 7 7 - "description": "Claim a domain for the authenticated DID. Returns DNS setup instructions for custom domains.", 7 7 + "description": "Claim a custom domain for the authenticated DID. Returns DNS setup instructions.", 8 8 "input": { 9 9 "encoding": "application/json", 10 10 "schema": { ··· 13 13 "properties": { 14 14 "domain": { 15 15 "type": "string", 16 16 - "description": "Domain to claim (wisp subdomain FQDN or custom domain FQDN).", 16 16 + "description": "Custom domain FQDN to claim (for example, example.com).", 17 17 "minLength": 3, 18 18 "maxLength": 253 19 19 }, ··· 36 36 }, 37 37 "kind": { 38 38 "type": "string", 39 39 - "enum": ["wisp", "custom"] 39 39 + "enum": ["custom"] 40 40 }, 41 41 "status": { 42 42 "type": "string",

+43

lexicons/domain-delete-v2.json

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "place.wisp.v2.domain.delete", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Delete a claimed domain owned by the authenticated DID.", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["domain"], 11 11 + "properties": { 12 12 + "domain": { 13 13 + "type": "string", 14 14 + "description": "Fully-qualified domain to delete (wisp subdomain or custom domain).", 15 15 + "minLength": 3, 16 16 + "maxLength": 253 17 17 + } 18 18 + } 19 19 + }, 20 20 + "output": { 21 21 + "encoding": "application/json", 22 22 + "schema": { 23 23 + "type": "object", 24 24 + "required": ["domain", "deleted"], 25 25 + "properties": { 26 26 + "domain": { 27 27 + "type": "string" 28 28 + }, 29 29 + "deleted": { 30 30 + "type": "boolean", 31 31 + "const": true 32 32 + } 33 33 + } 34 34 + } 35 35 + }, 36 36 + "errors": [ 37 37 + { "name": "AuthenticationRequired" }, 38 38 + { "name": "InvalidDomain" }, 39 39 + { "name": "NotFound" } 40 40 + ] 41 41 + } 42 42 + } 43 43 + }

+62

lexicons/domain-get-list-v2.json

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "place.wisp.v2.domain.getList", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "List domains for the authenticated DID (wisp subdomains + custom).", 8 8 + "output": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["domains"], 13 13 + "properties": { 14 14 + "domains": { 15 15 + "type": "array", 16 16 + "description": "Domains owned by the caller DID.", 17 17 + "items": { 18 18 + "type": "ref", 19 19 + "ref": "#domainSummary" 20 20 + } 21 21 + } 22 22 + } 23 23 + } 24 24 + }, 25 25 + "errors": [ 26 26 + { "name": "AuthenticationRequired" }, 27 27 + { "name": "InvalidRequest" } 28 28 + ] 29 29 + }, 30 30 + "domainSummary": { 31 31 + "type": "object", 32 32 + "description": "Summary of a claimed domain for list views.", 33 33 + "required": ["domain", "kind", "status", "verified"], 34 34 + "properties": { 35 35 + "domain": { 36 36 + "type": "string", 37 37 + "minLength": 3, 38 38 + "maxLength": 253 39 39 + }, 40 40 + "kind": { 41 41 + "type": "string", 42 42 + "enum": ["wisp", "custom"] 43 43 + }, 44 44 + "status": { 45 45 + "type": "string", 46 46 + "enum": ["pendingVerification", "verified"] 47 47 + }, 48 48 + "verified": { 49 49 + "type": "boolean" 50 50 + }, 51 51 + "siteRkey": { 52 52 + "type": "string", 53 53 + "format": "record-key" 54 54 + }, 55 55 + "lastCheckedAt": { 56 56 + "type": "string", 57 57 + "format": "datetime" 58 58 + } 59 59 + } 60 60 + } 61 61 + } 62 62 + }

+14 -2

packages/@wispplace/lexicons/package.json

··· 30 30 "types": "./src/types/place/wisp/v2/domain/claim.ts", 31 31 "default": "./src/types/place/wisp/v2/domain/claim.ts" 32 32 }, 33 33 + "./types/place/wisp/v2/domain/claimSubdomain": { 34 34 + "types": "./src/types/place/wisp/v2/domain/claimSubdomain.ts", 35 35 + "default": "./src/types/place/wisp/v2/domain/claimSubdomain.ts" 36 36 + }, 37 37 + "./types/place/wisp/v2/domain/delete": { 38 38 + "types": "./src/types/place/wisp/v2/domain/delete.ts", 39 39 + "default": "./src/types/place/wisp/v2/domain/delete.ts" 40 40 + }, 41 41 + "./types/place/wisp/v2/domain/getList": { 42 42 + "types": "./src/types/place/wisp/v2/domain/getList.ts", 43 43 + "default": "./src/types/place/wisp/v2/domain/getList.ts" 44 44 + }, 33 45 "./types/place/wisp/v2/domain/getStatus": { 34 46 "types": "./src/types/place/wisp/v2/domain/getStatus.ts", 35 47 "default": "./src/types/place/wisp/v2/domain/getStatus.ts" 36 48 }, 37 49 "./atcute": { 38 38 - "types": "./src/atcute/index.ts", 39 39 - "default": "./src/atcute/index.ts" 50 50 + "types": "./src/atcute/lexicons/index.ts", 51 51 + "default": "./src/atcute/lexicons/index.ts" 40 52 }, 41 53 "./lexicons": { 42 54 "types": "./src/lexicons.ts",

-1

packages/@wispplace/lexicons/src/atcute/index.ts

··· 1 1 - export * from './lexicons/index';

+3

packages/@wispplace/lexicons/src/atcute/lexicons/index.ts

··· 1 1 export * as PlaceWispV2DomainClaim from "./types/place/wisp/v2/domain/claim.js"; 2 2 + export * as PlaceWispV2DomainClaimSubdomain from "./types/place/wisp/v2/domain/claimSubdomain.js"; 3 3 + export * as PlaceWispV2DomainDelete from "./types/place/wisp/v2/domain/delete.js"; 4 4 + export * as PlaceWispV2DomainGetList from "./types/place/wisp/v2/domain/getList.js"; 2 5 export * as PlaceWispV2DomainGetStatus from "./types/place/wisp/v2/domain/getStatus.js"; 3 6 export * as PlaceWispV2Domains from "./types/place/wisp/v2/domains.js";

+2 -4

packages/@wispplace/lexicons/src/atcute/lexicons/types/place/wisp/v2/domain/claim.ts

··· 8 8 type: "lex", 9 9 schema: /*#__PURE__*/ v.object({ 10 10 /** 11 11 - * Domain to claim (wisp subdomain FQDN or custom domain FQDN). 11 11 + * Custom domain FQDN to claim (for example, example.com). 12 12 * @minLength 3 13 13 * @maxLength 253 14 14 */ ··· 45 45 ]), 46 46 ), 47 47 domain: /*#__PURE__*/ v.string(), 48 48 - kind: /*#__PURE__*/ v.optional( 49 49 - /*#__PURE__*/ v.literalEnum(["custom", "wisp"]), 50 50 - ), 48 48 + kind: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literalEnum(["custom"])), 51 49 siteRkey: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.recordKeyString()), 52 50 status: /*#__PURE__*/ v.literalEnum([ 53 51 "alreadyClaimed",

+52

packages/@wispplace/lexicons/src/atcute/lexicons/types/place/wisp/v2/domain/claimSubdomain.ts

··· 1 1 + import type {} from "@atcute/lexicons"; 2 2 + import * as v from "@atcute/lexicons/validations"; 3 3 + import type {} from "@atcute/lexicons/ambient"; 4 4 + 5 5 + const _mainSchema = /*#__PURE__*/ v.procedure( 6 6 + "place.wisp.v2.domain.claimSubdomain", 7 7 + { 8 8 + params: null, 9 9 + input: { 10 10 + type: "lex", 11 11 + schema: /*#__PURE__*/ v.object({ 12 12 + /** 13 13 + * Subdomain label only (for example, alice). 14 14 + * @minLength 3 15 15 + * @maxLength 63 16 16 + */ 17 17 + handle: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [ 18 18 + /*#__PURE__*/ v.stringLength(3, 63), 19 19 + ]), 20 20 + /** 21 21 + * Optional place.wisp.fs rkey to map immediately after claim. 22 22 + */ 23 23 + siteRkey: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.recordKeyString()), 24 24 + }), 25 25 + }, 26 26 + output: { 27 27 + type: "lex", 28 28 + schema: /*#__PURE__*/ v.object({ 29 29 + domain: /*#__PURE__*/ v.string(), 30 30 + kind: /*#__PURE__*/ v.literalEnum(["wisp"]), 31 31 + siteRkey: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.recordKeyString()), 32 32 + status: /*#__PURE__*/ v.literalEnum(["alreadyClaimed", "verified"]), 33 33 + }), 34 34 + }, 35 35 + }, 36 36 + ); 37 37 + 38 38 + type main$schematype = typeof _mainSchema; 39 39 + 40 40 + export interface mainSchema extends main$schematype {} 41 41 + 42 42 + export const mainSchema = _mainSchema as mainSchema; 43 43 + 44 44 + export interface $params {} 45 45 + export interface $input extends v.InferXRPCBodyInput<mainSchema["input"]> {} 46 46 + export interface $output extends v.InferXRPCBodyInput<mainSchema["output"]> {} 47 47 + 48 48 + declare module "@atcute/lexicons/ambient" { 49 49 + interface XRPCProcedures { 50 50 + "place.wisp.v2.domain.claimSubdomain": mainSchema; 51 51 + } 52 52 + }

+39

packages/@wispplace/lexicons/src/atcute/lexicons/types/place/wisp/v2/domain/delete.ts

··· 1 1 + import type {} from "@atcute/lexicons"; 2 2 + import * as v from "@atcute/lexicons/validations"; 3 3 + import type {} from "@atcute/lexicons/ambient"; 4 4 + 5 5 + const _mainSchema = /*#__PURE__*/ v.procedure("place.wisp.v2.domain.delete", { 6 6 + params: /*#__PURE__*/ v.object({ 7 7 + /** 8 8 + * Fully-qualified domain to delete (wisp subdomain or custom domain). 9 9 + * @minLength 3 10 10 + * @maxLength 253 11 11 + */ 12 12 + domain: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [ 13 13 + /*#__PURE__*/ v.stringLength(3, 253), 14 14 + ]), 15 15 + }), 16 16 + input: null, 17 17 + output: { 18 18 + type: "lex", 19 19 + schema: /*#__PURE__*/ v.object({ 20 20 + deleted: /*#__PURE__*/ v.literal(true), 21 21 + domain: /*#__PURE__*/ v.string(), 22 22 + }), 23 23 + }, 24 24 + }); 25 25 + 26 26 + type main$schematype = typeof _mainSchema; 27 27 + 28 28 + export interface mainSchema extends main$schematype {} 29 29 + 30 30 + export const mainSchema = _mainSchema as mainSchema; 31 31 + 32 32 + export interface $params extends v.InferInput<mainSchema["params"]> {} 33 33 + export interface $output extends v.InferXRPCBodyInput<mainSchema["output"]> {} 34 34 + 35 35 + declare module "@atcute/lexicons/ambient" { 36 36 + interface XRPCProcedures { 37 37 + "place.wisp.v2.domain.delete": mainSchema; 38 38 + } 39 39 + }

+57

packages/@wispplace/lexicons/src/atcute/lexicons/types/place/wisp/v2/domain/getList.ts

··· 1 1 + import type {} from "@atcute/lexicons"; 2 2 + import * as v from "@atcute/lexicons/validations"; 3 3 + import type {} from "@atcute/lexicons/ambient"; 4 4 + 5 5 + const _domainSummarySchema = /*#__PURE__*/ v.object({ 6 6 + $type: /*#__PURE__*/ v.optional( 7 7 + /*#__PURE__*/ v.literal("place.wisp.v2.domain.getList#domainSummary"), 8 8 + ), 9 9 + /** 10 10 + * @minLength 3 11 11 + * @maxLength 253 12 12 + */ 13 13 + domain: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [ 14 14 + /*#__PURE__*/ v.stringLength(3, 253), 15 15 + ]), 16 16 + kind: /*#__PURE__*/ v.literalEnum(["custom", "wisp"]), 17 17 + lastCheckedAt: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.datetimeString()), 18 18 + siteRkey: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.recordKeyString()), 19 19 + status: /*#__PURE__*/ v.literalEnum(["pendingVerification", "verified"]), 20 20 + verified: /*#__PURE__*/ v.boolean(), 21 21 + }); 22 22 + const _mainSchema = /*#__PURE__*/ v.query("place.wisp.v2.domain.getList", { 23 23 + params: null, 24 24 + output: { 25 25 + type: "lex", 26 26 + schema: /*#__PURE__*/ v.object({ 27 27 + /** 28 28 + * Domains owned by the caller DID. 29 29 + */ 30 30 + get domains() { 31 31 + return /*#__PURE__*/ v.array(domainSummarySchema); 32 32 + }, 33 33 + }), 34 34 + }, 35 35 + }); 36 36 + 37 37 + type domainSummary$schematype = typeof _domainSummarySchema; 38 38 + type main$schematype = typeof _mainSchema; 39 39 + 40 40 + export interface domainSummarySchema extends domainSummary$schematype {} 41 41 + export interface mainSchema extends main$schematype {} 42 42 + 43 43 + export const domainSummarySchema = _domainSummarySchema as domainSummarySchema; 44 44 + export const mainSchema = _mainSchema as mainSchema; 45 45 + 46 46 + export interface DomainSummary extends v.InferInput< 47 47 + typeof domainSummarySchema 48 48 + > {} 49 49 + 50 50 + export interface $params {} 51 51 + export interface $output extends v.InferXRPCBodyInput<mainSchema["output"]> {} 52 52 + 53 53 + declare module "@atcute/lexicons/ambient" { 54 54 + interface XRPCQueries { 55 55 + "place.wisp.v2.domain.getList": mainSchema; 56 56 + } 57 57 + }

+39

packages/@wispplace/lexicons/src/index.ts

··· 10 10 createServer as createXrpcServer, 11 11 } from '@atproto/xrpc-server' 12 12 import { schemas } from './lexicons.js' 13 13 + import * as PlaceWispV2DomainClaimSubdomain from './types/place/wisp/v2/domain/claimSubdomain.js' 13 14 import * as PlaceWispV2DomainClaim from './types/place/wisp/v2/domain/claim.js' 15 15 + import * as PlaceWispV2DomainDelete from './types/place/wisp/v2/domain/delete.js' 16 16 + import * as PlaceWispV2DomainGetList from './types/place/wisp/v2/domain/getList.js' 14 17 import * as PlaceWispV2DomainGetStatus from './types/place/wisp/v2/domain/getStatus.js' 15 18 16 19 export function createServer(options?: XrpcOptions): Server { ··· 64 67 this._server = server 65 68 } 66 69 70 70 + claimSubdomain<A extends Auth = void>( 71 71 + cfg: MethodConfigOrHandler< 72 72 + A, 73 73 + PlaceWispV2DomainClaimSubdomain.QueryParams, 74 74 + PlaceWispV2DomainClaimSubdomain.HandlerInput, 75 75 + PlaceWispV2DomainClaimSubdomain.HandlerOutput 76 76 + >, 77 77 + ) { 78 78 + const nsid = 'place.wisp.v2.domain.claimSubdomain' // @ts-ignore 79 79 + return this._server.xrpc.method(nsid, cfg) 80 80 + } 81 81 + 67 82 claim<A extends Auth = void>( 68 83 cfg: MethodConfigOrHandler< 69 84 A, ··· 73 88 >, 74 89 ) { 75 90 const nsid = 'place.wisp.v2.domain.claim' // @ts-ignore 91 91 + return this._server.xrpc.method(nsid, cfg) 92 92 + } 93 93 + 94 94 + delete<A extends Auth = void>( 95 95 + cfg: MethodConfigOrHandler< 96 96 + A, 97 97 + PlaceWispV2DomainDelete.QueryParams, 98 98 + PlaceWispV2DomainDelete.HandlerInput, 99 99 + PlaceWispV2DomainDelete.HandlerOutput 100 100 + >, 101 101 + ) { 102 102 + const nsid = 'place.wisp.v2.domain.delete' // @ts-ignore 103 103 + return this._server.xrpc.method(nsid, cfg) 104 104 + } 105 105 + 106 106 + getList<A extends Auth = void>( 107 107 + cfg: MethodConfigOrHandler< 108 108 + A, 109 109 + PlaceWispV2DomainGetList.QueryParams, 110 110 + PlaceWispV2DomainGetList.HandlerInput, 111 111 + PlaceWispV2DomainGetList.HandlerOutput 112 112 + >, 113 113 + ) { 114 114 + const nsid = 'place.wisp.v2.domain.getList' // @ts-ignore 76 115 return this._server.xrpc.method(nsid, cfg) 77 116 } 78 117

+196 -3

packages/@wispplace/lexicons/src/lexicons.ts

··· 10 10 import { type $Typed, is$typed, maybe$typed } from './util.js' 11 11 12 12 export const schemaDict = { 13 13 + PlaceWispV2DomainClaimSubdomain: { 14 14 + lexicon: 1, 15 15 + id: 'place.wisp.v2.domain.claimSubdomain', 16 16 + defs: { 17 17 + main: { 18 18 + type: 'procedure', 19 19 + description: 20 20 + 'Claim a wisp.place subdomain handle for the authenticated DID.', 21 21 + input: { 22 22 + encoding: 'application/json', 23 23 + schema: { 24 24 + type: 'object', 25 25 + required: ['handle'], 26 26 + properties: { 27 27 + handle: { 28 28 + type: 'string', 29 29 + description: 'Subdomain label only (for example, alice).', 30 30 + minLength: 3, 31 31 + maxLength: 63, 32 32 + }, 33 33 + siteRkey: { 34 34 + type: 'string', 35 35 + format: 'record-key', 36 36 + description: 37 37 + 'Optional place.wisp.fs rkey to map immediately after claim.', 38 38 + }, 39 39 + }, 40 40 + }, 41 41 + }, 42 42 + output: { 43 43 + encoding: 'application/json', 44 44 + schema: { 45 45 + type: 'object', 46 46 + required: ['domain', 'kind', 'status'], 47 47 + properties: { 48 48 + domain: { 49 49 + type: 'string', 50 50 + }, 51 51 + kind: { 52 52 + type: 'string', 53 53 + enum: ['wisp'], 54 54 + }, 55 55 + status: { 56 56 + type: 'string', 57 57 + enum: ['verified', 'alreadyClaimed'], 58 58 + }, 59 59 + siteRkey: { 60 60 + type: 'string', 61 61 + format: 'record-key', 62 62 + }, 63 63 + }, 64 64 + }, 65 65 + }, 66 66 + errors: [ 67 67 + { 68 68 + name: 'AuthenticationRequired', 69 69 + }, 70 70 + { 71 71 + name: 'InvalidDomain', 72 72 + }, 73 73 + { 74 74 + name: 'AlreadyClaimed', 75 75 + }, 76 76 + { 77 77 + name: 'DomainLimitReached', 78 78 + }, 79 79 + { 80 80 + name: 'RateLimitExceeded', 81 81 + }, 82 82 + ], 83 83 + }, 84 84 + }, 85 85 + }, 13 86 PlaceWispV2DomainClaim: { 14 87 lexicon: 1, 15 88 id: 'place.wisp.v2.domain.claim', ··· 17 90 main: { 18 91 type: 'procedure', 19 92 description: 20 20 - 'Claim a domain for the authenticated DID. Returns DNS setup instructions for custom domains.', 93 93 + 'Claim a custom domain for the authenticated DID. Returns DNS setup instructions.', 21 94 input: { 22 95 encoding: 'application/json', 23 96 schema: { ··· 27 100 domain: { 28 101 type: 'string', 29 102 description: 30 30 - 'Domain to claim (wisp subdomain FQDN or custom domain FQDN).', 103 103 + 'Custom domain FQDN to claim (for example, example.com).', 31 104 minLength: 3, 32 105 maxLength: 253, 33 106 }, ··· 51 124 }, 52 125 kind: { 53 126 type: 'string', 54 54 - enum: ['wisp', 'custom'], 127 127 + enum: ['custom'], 55 128 }, 56 129 status: { 57 130 type: 'string', ··· 107 180 name: 'RateLimitExceeded', 108 181 }, 109 182 ], 183 183 + }, 184 184 + }, 185 185 + }, 186 186 + PlaceWispV2DomainDelete: { 187 187 + lexicon: 1, 188 188 + id: 'place.wisp.v2.domain.delete', 189 189 + defs: { 190 190 + main: { 191 191 + type: 'procedure', 192 192 + description: 'Delete a claimed domain owned by the authenticated DID.', 193 193 + parameters: { 194 194 + type: 'params', 195 195 + required: ['domain'], 196 196 + properties: { 197 197 + domain: { 198 198 + type: 'string', 199 199 + description: 200 200 + 'Fully-qualified domain to delete (wisp subdomain or custom domain).', 201 201 + minLength: 3, 202 202 + maxLength: 253, 203 203 + }, 204 204 + }, 205 205 + }, 206 206 + output: { 207 207 + encoding: 'application/json', 208 208 + schema: { 209 209 + type: 'object', 210 210 + required: ['domain', 'deleted'], 211 211 + properties: { 212 212 + domain: { 213 213 + type: 'string', 214 214 + }, 215 215 + deleted: { 216 216 + type: 'boolean', 217 217 + const: true, 218 218 + }, 219 219 + }, 220 220 + }, 221 221 + }, 222 222 + errors: [ 223 223 + { 224 224 + name: 'AuthenticationRequired', 225 225 + }, 226 226 + { 227 227 + name: 'InvalidDomain', 228 228 + }, 229 229 + { 230 230 + name: 'NotFound', 231 231 + }, 232 232 + ], 233 233 + }, 234 234 + }, 235 235 + }, 236 236 + PlaceWispV2DomainGetList: { 237 237 + lexicon: 1, 238 238 + id: 'place.wisp.v2.domain.getList', 239 239 + defs: { 240 240 + main: { 241 241 + type: 'query', 242 242 + description: 243 243 + 'List domains for the authenticated DID (wisp subdomains + custom).', 244 244 + output: { 245 245 + encoding: 'application/json', 246 246 + schema: { 247 247 + type: 'object', 248 248 + required: ['domains'], 249 249 + properties: { 250 250 + domains: { 251 251 + type: 'array', 252 252 + description: 'Domains owned by the caller DID.', 253 253 + items: { 254 254 + type: 'ref', 255 255 + ref: 'lex:place.wisp.v2.domain.getList#domainSummary', 256 256 + }, 257 257 + }, 258 258 + }, 259 259 + }, 260 260 + }, 261 261 + errors: [ 262 262 + { 263 263 + name: 'AuthenticationRequired', 264 264 + }, 265 265 + { 266 266 + name: 'InvalidRequest', 267 267 + }, 268 268 + ], 269 269 + }, 270 270 + domainSummary: { 271 271 + type: 'object', 272 272 + description: 'Summary of a claimed domain for list views.', 273 273 + required: ['domain', 'kind', 'status', 'verified'], 274 274 + properties: { 275 275 + domain: { 276 276 + type: 'string', 277 277 + minLength: 3, 278 278 + maxLength: 253, 279 279 + }, 280 280 + kind: { 281 281 + type: 'string', 282 282 + enum: ['wisp', 'custom'], 283 283 + }, 284 284 + status: { 285 285 + type: 'string', 286 286 + enum: ['pendingVerification', 'verified'], 287 287 + }, 288 288 + verified: { 289 289 + type: 'boolean', 290 290 + }, 291 291 + siteRkey: { 292 292 + type: 'string', 293 293 + format: 'record-key', 294 294 + }, 295 295 + lastCheckedAt: { 296 296 + type: 'string', 297 297 + format: 'datetime', 298 298 + }, 299 299 + }, 110 300 }, 111 301 }, 112 302 }, ··· 633 823 } 634 824 635 825 export const ids = { 826 826 + PlaceWispV2DomainClaimSubdomain: 'place.wisp.v2.domain.claimSubdomain', 636 827 PlaceWispV2DomainClaim: 'place.wisp.v2.domain.claim', 828 828 + PlaceWispV2DomainDelete: 'place.wisp.v2.domain.delete', 829 829 + PlaceWispV2DomainGetList: 'place.wisp.v2.domain.getList', 637 830 PlaceWispV2DomainGetStatus: 'place.wisp.v2.domain.getStatus', 638 831 PlaceWispV2Domains: 'place.wisp.v2.domains', 639 832 PlaceWispFs: 'place.wisp.fs',

+2 -2

packages/@wispplace/lexicons/src/types/place/wisp/v2/domain/claim.ts

··· 17 17 export type QueryParams = {} 18 18 19 19 export interface InputSchema { 20 20 - /** Domain to claim (wisp subdomain FQDN or custom domain FQDN). */ 20 20 + /** Custom domain FQDN to claim (for example, example.com). */ 21 21 domain: string 22 22 /** Optional place.wisp.fs rkey to map immediately after claim. */ 23 23 siteRkey?: string ··· 25 25 26 26 export interface OutputSchema { 27 27 domain: string 28 28 - kind?: 'wisp' | 'custom' 28 28 + kind?: 'custom' 29 29 status: 'alreadyClaimed' | 'pendingVerification' | 'verified' 30 30 /** Identifier used to construct DNS challenge targets for custom domains. */ 31 31 challengeId?: string

+55

packages/@wispplace/lexicons/src/types/place/wisp/v2/domain/claimSubdomain.ts

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 + import { CID } from 'multiformats/cid' 6 6 + import { validate as _validate } from '../../../../../lexicons' 7 7 + import { 8 8 + type $Typed, 9 9 + is$typed as _is$typed, 10 10 + type OmitKey, 11 11 + } from '../../../../../util' 12 12 + 13 13 + const is$typed = _is$typed, 14 14 + validate = _validate 15 15 + const id = 'place.wisp.v2.domain.claimSubdomain' 16 16 + 17 17 + export type QueryParams = {} 18 18 + 19 19 + export interface InputSchema { 20 20 + /** Subdomain label only (for example, alice). */ 21 21 + handle: string 22 22 + /** Optional place.wisp.fs rkey to map immediately after claim. */ 23 23 + siteRkey?: string 24 24 + } 25 25 + 26 26 + export interface OutputSchema { 27 27 + domain: string 28 28 + kind: 'wisp' 29 29 + status: 'verified' | 'alreadyClaimed' 30 30 + siteRkey?: string 31 31 + } 32 32 + 33 33 + export interface HandlerInput { 34 34 + encoding: 'application/json' 35 35 + body: InputSchema 36 36 + } 37 37 + 38 38 + export interface HandlerSuccess { 39 39 + encoding: 'application/json' 40 40 + body: OutputSchema 41 41 + headers?: { [key: string]: string } 42 42 + } 43 43 + 44 44 + export interface HandlerError { 45 45 + status: number 46 46 + message?: string 47 47 + error?: 48 48 + | 'AuthenticationRequired' 49 49 + | 'InvalidDomain' 50 50 + | 'AlreadyClaimed' 51 51 + | 'DomainLimitReached' 52 52 + | 'RateLimitExceeded' 53 53 + } 54 54 + 55 55 + export type HandlerOutput = HandlerError | HandlerSuccess

+42

packages/@wispplace/lexicons/src/types/place/wisp/v2/domain/delete.ts

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 + import { CID } from 'multiformats/cid' 6 6 + import { validate as _validate } from '../../../../../lexicons' 7 7 + import { 8 8 + type $Typed, 9 9 + is$typed as _is$typed, 10 10 + type OmitKey, 11 11 + } from '../../../../../util' 12 12 + 13 13 + const is$typed = _is$typed, 14 14 + validate = _validate 15 15 + const id = 'place.wisp.v2.domain.delete' 16 16 + 17 17 + export type QueryParams = { 18 18 + /** Fully-qualified domain to delete (wisp subdomain or custom domain). */ 19 19 + domain: string 20 20 + } 21 21 + export type InputSchema = undefined 22 22 + 23 23 + export interface OutputSchema { 24 24 + domain: string 25 25 + deleted: true 26 26 + } 27 27 + 28 28 + export type HandlerInput = void 29 29 + 30 30 + export interface HandlerSuccess { 31 31 + encoding: 'application/json' 32 32 + body: OutputSchema 33 33 + headers?: { [key: string]: string } 34 34 + } 35 35 + 36 36 + export interface HandlerError { 37 37 + status: number 38 38 + message?: string 39 39 + error?: 'AuthenticationRequired' | 'InvalidDomain' | 'NotFound' 40 40 + } 41 41 + 42 42 + export type HandlerOutput = HandlerError | HandlerSuccess

+60

packages/@wispplace/lexicons/src/types/place/wisp/v2/domain/getList.ts

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { type ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 + import { CID } from 'multiformats/cid' 6 6 + import { validate as _validate } from '../../../../../lexicons' 7 7 + import { 8 8 + type $Typed, 9 9 + is$typed as _is$typed, 10 10 + type OmitKey, 11 11 + } from '../../../../../util' 12 12 + 13 13 + const is$typed = _is$typed, 14 14 + validate = _validate 15 15 + const id = 'place.wisp.v2.domain.getList' 16 16 + 17 17 + export type QueryParams = {} 18 18 + export type InputSchema = undefined 19 19 + 20 20 + export interface OutputSchema { 21 21 + /** Domains owned by the caller DID. */ 22 22 + domains: DomainSummary[] 23 23 + } 24 24 + 25 25 + export type HandlerInput = void 26 26 + 27 27 + export interface HandlerSuccess { 28 28 + encoding: 'application/json' 29 29 + body: OutputSchema 30 30 + headers?: { [key: string]: string } 31 31 + } 32 32 + 33 33 + export interface HandlerError { 34 34 + status: number 35 35 + message?: string 36 36 + error?: 'AuthenticationRequired' | 'InvalidRequest' 37 37 + } 38 38 + 39 39 + export type HandlerOutput = HandlerError | HandlerSuccess 40 40 + 41 41 + /** Summary of a claimed domain for list views. */ 42 42 + export interface DomainSummary { 43 43 + $type?: 'place.wisp.v2.domain.getList#domainSummary' 44 44 + domain: string 45 45 + kind: 'wisp' | 'custom' 46 46 + status: 'pendingVerification' | 'verified' 47 47 + verified: boolean 48 48 + siteRkey?: string 49 49 + lastCheckedAt?: string 50 50 + } 51 51 + 52 52 + const hashDomainSummary = 'domainSummary' 53 53 + 54 54 + export function isDomainSummary<V>(v: V) { 55 55 + return is$typed(v, id, hashDomainSummary) 56 56 + } 57 57 + 58 58 + export function validateDomainSummary<V>(v: V) { 59 59 + return validate<DomainSummary & V>(v, id, hashDomainSummary) 60 60 + }