+5 -1

.gitignore

··· 1 1 # See https://help.github.com/articles/ignoring-files/ for more about ignoring files. 2 2 .env 3 3 # dependencies 4 4 - /node_modules 4 4 + node_modules 5 5 + **/node_modules 5 6 /.pnp 6 7 .pnp.js 7 8 ··· 17 18 # production 18 19 /build 19 20 /result 21 21 + dist 22 22 + **/dist 23 23 + *.tsbuildinfo 20 24 21 25 # misc 22 26 .DS_Store

+839

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

··· 1 1 + /** 2 2 + * Core file serving logic for the hosting service 3 3 + * Handles file retrieval, caching, redirects, and HTML rewriting 4 4 + */ 5 5 + 6 6 + import { readFile } from 'fs/promises'; 7 7 + import { lookup } from 'mime-types'; 8 8 + import type { Record as WispSettings } from '@wisp/lexicons/types/place/wisp/settings'; 9 9 + import { shouldCompressMimeType } from '@wisp/atproto-utils/compression'; 10 10 + import { fileCache, metadataCache, rewrittenHtmlCache, getCacheKey, isSiteBeingCached } from './cache'; 11 11 + import { getCachedFilePath, getCachedSettings } from './utils'; 12 12 + import { loadRedirectRules, matchRedirectRule, parseCookies, parseQueryString } from './redirects'; 13 13 + import { rewriteHtmlPaths, isHtmlContent } from './html-rewriter'; 14 14 + import { generate404Page, generateDirectoryListing, siteUpdatingResponse } from './page-generators'; 15 15 + import { getIndexFiles, applyCustomHeaders, fileExists } from './request-utils'; 16 16 + import { getRedirectRulesFromCache, setRedirectRulesInCache } from './site-cache'; 17 17 + 18 18 + /** 19 19 + * Helper to serve files from cache (for custom domains and subdomains) 20 20 + */ 21 21 + export async function serveFromCache( 22 22 + did: string, 23 23 + rkey: string, 24 24 + filePath: string, 25 25 + fullUrl?: string, 26 26 + headers?: Record<string, string> 27 27 + ): Promise<Response> { 28 28 + // Load settings for this site 29 29 + const settings = await getCachedSettings(did, rkey); 30 30 + const indexFiles = getIndexFiles(settings); 31 31 + 32 32 + // Check for redirect rules first (_redirects wins over settings) 33 33 + let redirectRules = getRedirectRulesFromCache(did, rkey); 34 34 + 35 35 + if (redirectRules === undefined) { 36 36 + // Load rules for the first time 37 37 + redirectRules = await loadRedirectRules(did, rkey); 38 38 + setRedirectRulesInCache(did, rkey, redirectRules); 39 39 + } 40 40 + 41 41 + // Apply redirect rules if any exist 42 42 + if (redirectRules.length > 0) { 43 43 + const requestPath = '/' + (filePath || ''); 44 44 + const queryParams = fullUrl ? parseQueryString(fullUrl) : {}; 45 45 + const cookies = parseCookies(headers?.['cookie']); 46 46 + 47 47 + const redirectMatch = matchRedirectRule(requestPath, redirectRules, { 48 48 + queryParams, 49 49 + headers, 50 50 + cookies, 51 51 + }); 52 52 + 53 53 + if (redirectMatch) { 54 54 + const { rule, targetPath, status } = redirectMatch; 55 55 + 56 56 + // If not forced, check if the requested file exists before redirecting 57 57 + if (!rule.force) { 58 58 + // Build the expected file path 59 59 + let checkPath: string = filePath || indexFiles[0] || 'index.html'; 60 60 + if (checkPath.endsWith('/')) { 61 61 + checkPath += indexFiles[0] || 'index.html'; 62 62 + } 63 63 + 64 64 + const cachedFile = getCachedFilePath(did, rkey, checkPath); 65 65 + const fileExistsOnDisk = await fileExists(cachedFile); 66 66 + 67 67 + // If file exists and redirect is not forced, serve the file normally 68 68 + if (fileExistsOnDisk) { 69 69 + return serveFileInternal(did, rkey, filePath, settings); 70 70 + } 71 71 + } 72 72 + 73 73 + // Handle different status codes 74 74 + if (status === 200) { 75 75 + // Rewrite: serve different content but keep URL the same 76 76 + // Remove leading slash for internal path resolution 77 77 + const rewritePath = targetPath.startsWith('/') ? targetPath.slice(1) : targetPath; 78 78 + return serveFileInternal(did, rkey, rewritePath, settings); 79 79 + } else if (status === 301 || status === 302) { 80 80 + // External redirect: change the URL 81 81 + return new Response(null, { 82 82 + status, 83 83 + headers: { 84 84 + 'Location': targetPath, 85 85 + 'Cache-Control': status === 301 ? 'public, max-age=31536000' : 'public, max-age=0', 86 86 + }, 87 87 + }); 88 88 + } else if (status === 404) { 89 89 + // Custom 404 page from _redirects (wins over settings.custom404) 90 90 + const custom404Path = targetPath.startsWith('/') ? targetPath.slice(1) : targetPath; 91 91 + const response = await serveFileInternal(did, rkey, custom404Path, settings); 92 92 + // Override status to 404 93 93 + return new Response(response.body, { 94 94 + status: 404, 95 95 + headers: response.headers, 96 96 + }); 97 97 + } 98 98 + } 99 99 + } 100 100 + 101 101 + // No redirect matched, serve normally with settings 102 102 + return serveFileInternal(did, rkey, filePath, settings); 103 103 + } 104 104 + 105 105 + /** 106 106 + * Internal function to serve a file (used by both normal serving and rewrites) 107 107 + */ 108 108 + export async function serveFileInternal( 109 109 + did: string, 110 110 + rkey: string, 111 111 + filePath: string, 112 112 + settings: WispSettings | null = null 113 113 + ): Promise<Response> { 114 114 + // Check if site is currently being cached - if so, return updating response 115 115 + if (isSiteBeingCached(did, rkey)) { 116 116 + return siteUpdatingResponse(); 117 117 + } 118 118 + 119 119 + const indexFiles = getIndexFiles(settings); 120 120 + 121 121 + // Normalize the request path (keep empty for root, remove trailing slash for others) 122 122 + let requestPath = filePath || ''; 123 123 + if (requestPath.endsWith('/') && requestPath.length > 1) { 124 124 + requestPath = requestPath.slice(0, -1); 125 125 + } 126 126 + 127 127 + // Check if this path is a directory first 128 128 + const directoryPath = getCachedFilePath(did, rkey, requestPath); 129 129 + if (await fileExists(directoryPath)) { 130 130 + const { stat, readdir } = await import('fs/promises'); 131 131 + try { 132 132 + const stats = await stat(directoryPath); 133 133 + if (stats.isDirectory()) { 134 134 + // It's a directory, try each index file in order 135 135 + for (const indexFile of indexFiles) { 136 136 + const indexPath = requestPath ? `${requestPath}/${indexFile}` : indexFile; 137 137 + const indexFilePath = getCachedFilePath(did, rkey, indexPath); 138 138 + if (await fileExists(indexFilePath)) { 139 139 + return serveFileInternal(did, rkey, indexPath, settings); 140 140 + } 141 141 + } 142 142 + // No index file found - check if directory listing is enabled 143 143 + if (settings?.directoryListing) { 144 144 + const { stat } = await import('fs/promises'); 145 145 + const entries = await readdir(directoryPath); 146 146 + // Filter out .meta files and other hidden files 147 147 + const visibleEntries = entries.filter(entry => !entry.endsWith('.meta') && entry !== '.metadata.json'); 148 148 + 149 149 + // Check which entries are directories 150 150 + const entriesWithType = await Promise.all( 151 151 + visibleEntries.map(async (name) => { 152 152 + try { 153 153 + const entryPath = `${directoryPath}/${name}`; 154 154 + const stats = await stat(entryPath); 155 155 + return { name, isDirectory: stats.isDirectory() }; 156 156 + } catch { 157 157 + return { name, isDirectory: false }; 158 158 + } 159 159 + }) 160 160 + ); 161 161 + 162 162 + const html = generateDirectoryListing(requestPath, entriesWithType); 163 163 + return new Response(html, { 164 164 + headers: { 165 165 + 'Content-Type': 'text/html; charset=utf-8', 166 166 + 'Cache-Control': 'public, max-age=300', 167 167 + }, 168 168 + }); 169 169 + } 170 170 + // Fall through to 404/SPA handling 171 171 + } 172 172 + } catch (err) { 173 173 + // If stat fails, continue with normal flow 174 174 + } 175 175 + } 176 176 + 177 177 + // Not a directory, try to serve as a file 178 178 + const fileRequestPath: string = requestPath || indexFiles[0] || 'index.html'; 179 179 + const cacheKey = getCacheKey(did, rkey, fileRequestPath); 180 180 + const cachedFile = getCachedFilePath(did, rkey, fileRequestPath); 181 181 + 182 182 + // Check in-memory cache first 183 183 + let content = fileCache.get(cacheKey); 184 184 + let meta = metadataCache.get(cacheKey); 185 185 + 186 186 + if (!content && await fileExists(cachedFile)) { 187 187 + // Read from disk and cache 188 188 + content = await readFile(cachedFile); 189 189 + fileCache.set(cacheKey, content, content.length); 190 190 + 191 191 + const metaFile = `${cachedFile}.meta`; 192 192 + if (await fileExists(metaFile)) { 193 193 + const metaJson = await readFile(metaFile, 'utf-8'); 194 194 + meta = JSON.parse(metaJson); 195 195 + metadataCache.set(cacheKey, meta!, JSON.stringify(meta).length); 196 196 + } 197 197 + } 198 198 + 199 199 + if (content) { 200 200 + // Build headers with caching 201 201 + const headers: Record<string, string> = {}; 202 202 + 203 203 + if (meta && meta.encoding === 'gzip' && meta.mimeType) { 204 204 + const shouldServeCompressed = shouldCompressMimeType(meta.mimeType); 205 205 + 206 206 + if (!shouldServeCompressed) { 207 207 + // Verify content is actually gzipped before attempting decompression 208 208 + const isGzipped = content.length >= 2 && content[0] === 0x1f && content[1] === 0x8b; 209 209 + if (isGzipped) { 210 210 + const { gunzipSync } = await import('zlib'); 211 211 + const decompressed = gunzipSync(content); 212 212 + headers['Content-Type'] = meta.mimeType; 213 213 + headers['Cache-Control'] = 'public, max-age=31536000, immutable'; 214 214 + applyCustomHeaders(headers, fileRequestPath, settings); 215 215 + return new Response(decompressed, { headers }); 216 216 + } else { 217 217 + // Meta says gzipped but content isn't - serve as-is 218 218 + console.warn(`File ${filePath} has gzip encoding in meta but content lacks gzip magic bytes`); 219 219 + headers['Content-Type'] = meta.mimeType; 220 220 + headers['Cache-Control'] = 'public, max-age=31536000, immutable'; 221 221 + applyCustomHeaders(headers, fileRequestPath, settings); 222 222 + return new Response(content, { headers }); 223 223 + } 224 224 + } 225 225 + 226 226 + headers['Content-Type'] = meta.mimeType; 227 227 + headers['Content-Encoding'] = 'gzip'; 228 228 + headers['Cache-Control'] = meta.mimeType.startsWith('text/html') 229 229 + ? 'public, max-age=300' 230 230 + : 'public, max-age=31536000, immutable'; 231 231 + applyCustomHeaders(headers, fileRequestPath, settings); 232 232 + return new Response(content, { headers }); 233 233 + } 234 234 + 235 235 + // Non-compressed files 236 236 + const mimeType = lookup(cachedFile) || 'application/octet-stream'; 237 237 + headers['Content-Type'] = mimeType; 238 238 + headers['Cache-Control'] = mimeType.startsWith('text/html') 239 239 + ? 'public, max-age=300' 240 240 + : 'public, max-age=31536000, immutable'; 241 241 + applyCustomHeaders(headers, fileRequestPath, settings); 242 242 + return new Response(content, { headers }); 243 243 + } 244 244 + 245 245 + // Try index files for directory-like paths 246 246 + if (!fileRequestPath.includes('.')) { 247 247 + for (const indexFileName of indexFiles) { 248 248 + const indexPath = fileRequestPath ? `${fileRequestPath}/${indexFileName}` : indexFileName; 249 249 + const indexCacheKey = getCacheKey(did, rkey, indexPath); 250 250 + const indexFile = getCachedFilePath(did, rkey, indexPath); 251 251 + 252 252 + let indexContent = fileCache.get(indexCacheKey); 253 253 + let indexMeta = metadataCache.get(indexCacheKey); 254 254 + 255 255 + if (!indexContent && await fileExists(indexFile)) { 256 256 + indexContent = await readFile(indexFile); 257 257 + fileCache.set(indexCacheKey, indexContent, indexContent.length); 258 258 + 259 259 + const indexMetaFile = `${indexFile}.meta`; 260 260 + if (await fileExists(indexMetaFile)) { 261 261 + const metaJson = await readFile(indexMetaFile, 'utf-8'); 262 262 + indexMeta = JSON.parse(metaJson); 263 263 + metadataCache.set(indexCacheKey, indexMeta!, JSON.stringify(indexMeta).length); 264 264 + } 265 265 + } 266 266 + 267 267 + if (indexContent) { 268 268 + const headers: Record<string, string> = { 269 269 + 'Content-Type': 'text/html; charset=utf-8', 270 270 + 'Cache-Control': 'public, max-age=300', 271 271 + }; 272 272 + 273 273 + if (indexMeta && indexMeta.encoding === 'gzip') { 274 274 + headers['Content-Encoding'] = 'gzip'; 275 275 + } 276 276 + 277 277 + applyCustomHeaders(headers, indexPath, settings); 278 278 + return new Response(indexContent, { headers }); 279 279 + } 280 280 + } 281 281 + } 282 282 + 283 283 + // Try clean URLs: /about -> /about.html 284 284 + if (settings?.cleanUrls && !fileRequestPath.includes('.')) { 285 285 + const htmlPath = `${fileRequestPath}.html`; 286 286 + const htmlFile = getCachedFilePath(did, rkey, htmlPath); 287 287 + if (await fileExists(htmlFile)) { 288 288 + return serveFileInternal(did, rkey, htmlPath, settings); 289 289 + } 290 290 + 291 291 + // Also try /about/index.html 292 292 + for (const indexFileName of indexFiles) { 293 293 + const indexPath = fileRequestPath ? `${fileRequestPath}/${indexFileName}` : indexFileName; 294 294 + const indexFile = getCachedFilePath(did, rkey, indexPath); 295 295 + if (await fileExists(indexFile)) { 296 296 + return serveFileInternal(did, rkey, indexPath, settings); 297 297 + } 298 298 + } 299 299 + } 300 300 + 301 301 + // SPA mode: serve SPA file for all non-existing routes (wins over custom404 but loses to _redirects) 302 302 + if (settings?.spaMode) { 303 303 + const spaFile = settings.spaMode; 304 304 + const spaFilePath = getCachedFilePath(did, rkey, spaFile); 305 305 + if (await fileExists(spaFilePath)) { 306 306 + return serveFileInternal(did, rkey, spaFile, settings); 307 307 + } 308 308 + } 309 309 + 310 310 + // Custom 404: serve custom 404 file if configured (wins conflict battle) 311 311 + if (settings?.custom404) { 312 312 + const custom404File = settings.custom404; 313 313 + const custom404Path = getCachedFilePath(did, rkey, custom404File); 314 314 + if (await fileExists(custom404Path)) { 315 315 + const response: Response = await serveFileInternal(did, rkey, custom404File, settings); 316 316 + // Override status to 404 317 317 + return new Response(response.body, { 318 318 + status: 404, 319 319 + headers: response.headers, 320 320 + }); 321 321 + } 322 322 + } 323 323 + 324 324 + // Autodetect 404 pages (GitHub Pages: 404.html, Neocities/Nekoweb: not_found.html) 325 325 + const auto404Pages = ['404.html', 'not_found.html']; 326 326 + for (const auto404Page of auto404Pages) { 327 327 + const auto404Path = getCachedFilePath(did, rkey, auto404Page); 328 328 + if (await fileExists(auto404Path)) { 329 329 + const response: Response = await serveFileInternal(did, rkey, auto404Page, settings); 330 330 + // Override status to 404 331 331 + return new Response(response.body, { 332 332 + status: 404, 333 333 + headers: response.headers, 334 334 + }); 335 335 + } 336 336 + } 337 337 + 338 338 + // Directory listing fallback: if enabled, show root directory listing on 404 339 339 + if (settings?.directoryListing) { 340 340 + const rootPath = getCachedFilePath(did, rkey, ''); 341 341 + if (await fileExists(rootPath)) { 342 342 + const { stat, readdir } = await import('fs/promises'); 343 343 + try { 344 344 + const stats = await stat(rootPath); 345 345 + if (stats.isDirectory()) { 346 346 + const entries = await readdir(rootPath); 347 347 + // Filter out .meta files and metadata 348 348 + const visibleEntries = entries.filter(entry => 349 349 + !entry.endsWith('.meta') && entry !== '.metadata.json' 350 350 + ); 351 351 + 352 352 + // Check which entries are directories 353 353 + const entriesWithType = await Promise.all( 354 354 + visibleEntries.map(async (name) => { 355 355 + try { 356 356 + const entryPath = `${rootPath}/${name}`; 357 357 + const entryStats = await stat(entryPath); 358 358 + return { name, isDirectory: entryStats.isDirectory() }; 359 359 + } catch { 360 360 + return { name, isDirectory: false }; 361 361 + } 362 362 + }) 363 363 + ); 364 364 + 365 365 + const html = generateDirectoryListing('', entriesWithType); 366 366 + return new Response(html, { 367 367 + status: 404, 368 368 + headers: { 369 369 + 'Content-Type': 'text/html; charset=utf-8', 370 370 + 'Cache-Control': 'public, max-age=300', 371 371 + }, 372 372 + }); 373 373 + } 374 374 + } catch (err) { 375 375 + // If directory listing fails, fall through to 404 376 376 + } 377 377 + } 378 378 + } 379 379 + 380 380 + // Default styled 404 page 381 381 + const html = generate404Page(); 382 382 + return new Response(html, { 383 383 + status: 404, 384 384 + headers: { 385 385 + 'Content-Type': 'text/html; charset=utf-8', 386 386 + 'Cache-Control': 'public, max-age=300', 387 387 + }, 388 388 + }); 389 389 + } 390 390 + 391 391 + /** 392 392 + * Helper to serve files from cache with HTML path rewriting for sites.wisp.place routes 393 393 + */ 394 394 + export async function serveFromCacheWithRewrite( 395 395 + did: string, 396 396 + rkey: string, 397 397 + filePath: string, 398 398 + basePath: string, 399 399 + fullUrl?: string, 400 400 + headers?: Record<string, string> 401 401 + ): Promise<Response> { 402 402 + // Load settings for this site 403 403 + const settings = await getCachedSettings(did, rkey); 404 404 + const indexFiles = getIndexFiles(settings); 405 405 + 406 406 + // Check for redirect rules first (_redirects wins over settings) 407 407 + let redirectRules = getRedirectRulesFromCache(did, rkey); 408 408 + 409 409 + if (redirectRules === undefined) { 410 410 + // Load rules for the first time 411 411 + redirectRules = await loadRedirectRules(did, rkey); 412 412 + setRedirectRulesInCache(did, rkey, redirectRules); 413 413 + } 414 414 + 415 415 + // Apply redirect rules if any exist 416 416 + if (redirectRules.length > 0) { 417 417 + const requestPath = '/' + (filePath || ''); 418 418 + const queryParams = fullUrl ? parseQueryString(fullUrl) : {}; 419 419 + const cookies = parseCookies(headers?.['cookie']); 420 420 + 421 421 + const redirectMatch = matchRedirectRule(requestPath, redirectRules, { 422 422 + queryParams, 423 423 + headers, 424 424 + cookies, 425 425 + }); 426 426 + 427 427 + if (redirectMatch) { 428 428 + const { rule, targetPath, status } = redirectMatch; 429 429 + 430 430 + // If not forced, check if the requested file exists before redirecting 431 431 + if (!rule.force) { 432 432 + // Build the expected file path 433 433 + let checkPath: string = filePath || indexFiles[0] || 'index.html'; 434 434 + if (checkPath.endsWith('/')) { 435 435 + checkPath += indexFiles[0] || 'index.html'; 436 436 + } 437 437 + 438 438 + const cachedFile = getCachedFilePath(did, rkey, checkPath); 439 439 + const fileExistsOnDisk = await fileExists(cachedFile); 440 440 + 441 441 + // If file exists and redirect is not forced, serve the file normally 442 442 + if (fileExistsOnDisk) { 443 443 + return serveFileInternalWithRewrite(did, rkey, filePath, basePath, settings); 444 444 + } 445 445 + } 446 446 + 447 447 + // Handle different status codes 448 448 + if (status === 200) { 449 449 + // Rewrite: serve different content but keep URL the same 450 450 + const rewritePath = targetPath.startsWith('/') ? targetPath.slice(1) : targetPath; 451 451 + return serveFileInternalWithRewrite(did, rkey, rewritePath, basePath, settings); 452 452 + } else if (status === 301 || status === 302) { 453 453 + // External redirect: change the URL 454 454 + // For sites.wisp.place, we need to adjust the target path to include the base path 455 455 + // unless it's an absolute URL 456 456 + let redirectTarget = targetPath; 457 457 + if (!targetPath.startsWith('http://') && !targetPath.startsWith('https://')) { 458 458 + redirectTarget = basePath + (targetPath.startsWith('/') ? targetPath.slice(1) : targetPath); 459 459 + } 460 460 + return new Response(null, { 461 461 + status, 462 462 + headers: { 463 463 + 'Location': redirectTarget, 464 464 + 'Cache-Control': status === 301 ? 'public, max-age=31536000' : 'public, max-age=0', 465 465 + }, 466 466 + }); 467 467 + } else if (status === 404) { 468 468 + // Custom 404 page from _redirects (wins over settings.custom404) 469 469 + const custom404Path = targetPath.startsWith('/') ? targetPath.slice(1) : targetPath; 470 470 + const response = await serveFileInternalWithRewrite(did, rkey, custom404Path, basePath, settings); 471 471 + // Override status to 404 472 472 + return new Response(response.body, { 473 473 + status: 404, 474 474 + headers: response.headers, 475 475 + }); 476 476 + } 477 477 + } 478 478 + } 479 479 + 480 480 + // No redirect matched, serve normally with settings 481 481 + return serveFileInternalWithRewrite(did, rkey, filePath, basePath, settings); 482 482 + } 483 483 + 484 484 + /** 485 485 + * Internal function to serve a file with rewriting 486 486 + */ 487 487 + export async function serveFileInternalWithRewrite( 488 488 + did: string, 489 489 + rkey: string, 490 490 + filePath: string, 491 491 + basePath: string, 492 492 + settings: WispSettings | null = null 493 493 + ): Promise<Response> { 494 494 + // Check if site is currently being cached - if so, return updating response 495 495 + if (isSiteBeingCached(did, rkey)) { 496 496 + return siteUpdatingResponse(); 497 497 + } 498 498 + 499 499 + const indexFiles = getIndexFiles(settings); 500 500 + 501 501 + // Normalize the request path (keep empty for root, remove trailing slash for others) 502 502 + let requestPath = filePath || ''; 503 503 + if (requestPath.endsWith('/') && requestPath.length > 1) { 504 504 + requestPath = requestPath.slice(0, -1); 505 505 + } 506 506 + 507 507 + // Check if this path is a directory first 508 508 + const directoryPath = getCachedFilePath(did, rkey, requestPath); 509 509 + if (await fileExists(directoryPath)) { 510 510 + const { stat, readdir } = await import('fs/promises'); 511 511 + try { 512 512 + const stats = await stat(directoryPath); 513 513 + if (stats.isDirectory()) { 514 514 + // It's a directory, try each index file in order 515 515 + for (const indexFile of indexFiles) { 516 516 + const indexPath = requestPath ? `${requestPath}/${indexFile}` : indexFile; 517 517 + const indexFilePath = getCachedFilePath(did, rkey, indexPath); 518 518 + if (await fileExists(indexFilePath)) { 519 519 + return serveFileInternalWithRewrite(did, rkey, indexPath, basePath, settings); 520 520 + } 521 521 + } 522 522 + // No index file found - check if directory listing is enabled 523 523 + if (settings?.directoryListing) { 524 524 + const { stat } = await import('fs/promises'); 525 525 + const entries = await readdir(directoryPath); 526 526 + // Filter out .meta files and other hidden files 527 527 + const visibleEntries = entries.filter(entry => !entry.endsWith('.meta') && entry !== '.metadata.json'); 528 528 + 529 529 + // Check which entries are directories 530 530 + const entriesWithType = await Promise.all( 531 531 + visibleEntries.map(async (name) => { 532 532 + try { 533 533 + const entryPath = `${directoryPath}/${name}`; 534 534 + const stats = await stat(entryPath); 535 535 + return { name, isDirectory: stats.isDirectory() }; 536 536 + } catch { 537 537 + return { name, isDirectory: false }; 538 538 + } 539 539 + }) 540 540 + ); 541 541 + 542 542 + const html = generateDirectoryListing(requestPath, entriesWithType); 543 543 + return new Response(html, { 544 544 + headers: { 545 545 + 'Content-Type': 'text/html; charset=utf-8', 546 546 + 'Cache-Control': 'public, max-age=300', 547 547 + }, 548 548 + }); 549 549 + } 550 550 + // Fall through to 404/SPA handling 551 551 + } 552 552 + } catch (err) { 553 553 + // If stat fails, continue with normal flow 554 554 + } 555 555 + } 556 556 + 557 557 + // Not a directory, try to serve as a file 558 558 + const fileRequestPath: string = requestPath || indexFiles[0] || 'index.html'; 559 559 + const cacheKey = getCacheKey(did, rkey, fileRequestPath); 560 560 + const cachedFile = getCachedFilePath(did, rkey, fileRequestPath); 561 561 + 562 562 + // Check for rewritten HTML in cache first (if it's HTML) 563 563 + const mimeTypeGuess = lookup(fileRequestPath) || 'application/octet-stream'; 564 564 + if (isHtmlContent(fileRequestPath, mimeTypeGuess)) { 565 565 + const rewrittenKey = getCacheKey(did, rkey, fileRequestPath, `rewritten:${basePath}`); 566 566 + const rewrittenContent = rewrittenHtmlCache.get(rewrittenKey); 567 567 + if (rewrittenContent) { 568 568 + const headers: Record<string, string> = { 569 569 + 'Content-Type': 'text/html; charset=utf-8', 570 570 + 'Content-Encoding': 'gzip', 571 571 + 'Cache-Control': 'public, max-age=300', 572 572 + }; 573 573 + applyCustomHeaders(headers, fileRequestPath, settings); 574 574 + return new Response(rewrittenContent, { headers }); 575 575 + } 576 576 + } 577 577 + 578 578 + // Check in-memory file cache 579 579 + let content = fileCache.get(cacheKey); 580 580 + let meta = metadataCache.get(cacheKey); 581 581 + 582 582 + if (!content && await fileExists(cachedFile)) { 583 583 + // Read from disk and cache 584 584 + content = await readFile(cachedFile); 585 585 + fileCache.set(cacheKey, content, content.length); 586 586 + 587 587 + const metaFile = `${cachedFile}.meta`; 588 588 + if (await fileExists(metaFile)) { 589 589 + const metaJson = await readFile(metaFile, 'utf-8'); 590 590 + meta = JSON.parse(metaJson); 591 591 + metadataCache.set(cacheKey, meta!, JSON.stringify(meta).length); 592 592 + } 593 593 + } 594 594 + 595 595 + if (content) { 596 596 + const mimeType = meta?.mimeType || lookup(cachedFile) || 'application/octet-stream'; 597 597 + const isGzipped = meta?.encoding === 'gzip'; 598 598 + 599 599 + // Check if this is HTML content that needs rewriting 600 600 + if (isHtmlContent(fileRequestPath, mimeType)) { 601 601 + let htmlContent: string; 602 602 + if (isGzipped) { 603 603 + // Verify content is actually gzipped 604 604 + const hasGzipMagic = content.length >= 2 && content[0] === 0x1f && content[1] === 0x8b; 605 605 + if (hasGzipMagic) { 606 606 + const { gunzipSync } = await import('zlib'); 607 607 + htmlContent = gunzipSync(content).toString('utf-8'); 608 608 + } else { 609 609 + console.warn(`File ${fileRequestPath} marked as gzipped but lacks magic bytes, serving as-is`); 610 610 + htmlContent = content.toString('utf-8'); 611 611 + } 612 612 + } else { 613 613 + htmlContent = content.toString('utf-8'); 614 614 + } 615 615 + const rewritten = rewriteHtmlPaths(htmlContent, basePath, fileRequestPath); 616 616 + 617 617 + // Recompress and cache the rewritten HTML 618 618 + const { gzipSync } = await import('zlib'); 619 619 + const recompressed = gzipSync(Buffer.from(rewritten, 'utf-8')); 620 620 + 621 621 + const rewrittenKey = getCacheKey(did, rkey, fileRequestPath, `rewritten:${basePath}`); 622 622 + rewrittenHtmlCache.set(rewrittenKey, recompressed, recompressed.length); 623 623 + 624 624 + const htmlHeaders: Record<string, string> = { 625 625 + 'Content-Type': 'text/html; charset=utf-8', 626 626 + 'Content-Encoding': 'gzip', 627 627 + 'Cache-Control': 'public, max-age=300', 628 628 + }; 629 629 + applyCustomHeaders(htmlHeaders, fileRequestPath, settings); 630 630 + return new Response(recompressed, { headers: htmlHeaders }); 631 631 + } 632 632 + 633 633 + // Non-HTML files: serve as-is 634 634 + const headers: Record<string, string> = { 635 635 + 'Content-Type': mimeType, 636 636 + 'Cache-Control': 'public, max-age=31536000, immutable', 637 637 + }; 638 638 + 639 639 + if (isGzipped) { 640 640 + const shouldServeCompressed = shouldCompressMimeType(mimeType); 641 641 + if (!shouldServeCompressed) { 642 642 + // Verify content is actually gzipped 643 643 + const hasGzipMagic = content.length >= 2 && content[0] === 0x1f && content[1] === 0x8b; 644 644 + if (hasGzipMagic) { 645 645 + const { gunzipSync } = await import('zlib'); 646 646 + const decompressed = gunzipSync(content); 647 647 + applyCustomHeaders(headers, fileRequestPath, settings); 648 648 + return new Response(decompressed, { headers }); 649 649 + } else { 650 650 + console.warn(`File ${fileRequestPath} marked as gzipped but lacks magic bytes, serving as-is`); 651 651 + applyCustomHeaders(headers, fileRequestPath, settings); 652 652 + return new Response(content, { headers }); 653 653 + } 654 654 + } 655 655 + headers['Content-Encoding'] = 'gzip'; 656 656 + } 657 657 + 658 658 + applyCustomHeaders(headers, fileRequestPath, settings); 659 659 + return new Response(content, { headers }); 660 660 + } 661 661 + 662 662 + // Try index files for directory-like paths 663 663 + if (!fileRequestPath.includes('.')) { 664 664 + for (const indexFileName of indexFiles) { 665 665 + const indexPath = fileRequestPath ? `${fileRequestPath}/${indexFileName}` : indexFileName; 666 666 + const indexCacheKey = getCacheKey(did, rkey, indexPath); 667 667 + const indexFile = getCachedFilePath(did, rkey, indexPath); 668 668 + 669 669 + // Check for rewritten index file in cache 670 670 + const rewrittenKey = getCacheKey(did, rkey, indexPath, `rewritten:${basePath}`); 671 671 + const rewrittenContent = rewrittenHtmlCache.get(rewrittenKey); 672 672 + if (rewrittenContent) { 673 673 + const headers: Record<string, string> = { 674 674 + 'Content-Type': 'text/html; charset=utf-8', 675 675 + 'Content-Encoding': 'gzip', 676 676 + 'Cache-Control': 'public, max-age=300', 677 677 + }; 678 678 + applyCustomHeaders(headers, indexPath, settings); 679 679 + return new Response(rewrittenContent, { headers }); 680 680 + } 681 681 + 682 682 + let indexContent = fileCache.get(indexCacheKey); 683 683 + let indexMeta = metadataCache.get(indexCacheKey); 684 684 + 685 685 + if (!indexContent && await fileExists(indexFile)) { 686 686 + indexContent = await readFile(indexFile); 687 687 + fileCache.set(indexCacheKey, indexContent, indexContent.length); 688 688 + 689 689 + const indexMetaFile = `${indexFile}.meta`; 690 690 + if (await fileExists(indexMetaFile)) { 691 691 + const metaJson = await readFile(indexMetaFile, 'utf-8'); 692 692 + indexMeta = JSON.parse(metaJson); 693 693 + metadataCache.set(indexCacheKey, indexMeta!, JSON.stringify(indexMeta).length); 694 694 + } 695 695 + } 696 696 + 697 697 + if (indexContent) { 698 698 + const isGzipped = indexMeta?.encoding === 'gzip'; 699 699 + 700 700 + let htmlContent: string; 701 701 + if (isGzipped) { 702 702 + // Verify content is actually gzipped 703 703 + const hasGzipMagic = indexContent.length >= 2 && indexContent[0] === 0x1f && indexContent[1] === 0x8b; 704 704 + if (hasGzipMagic) { 705 705 + const { gunzipSync } = await import('zlib'); 706 706 + htmlContent = gunzipSync(indexContent).toString('utf-8'); 707 707 + } else { 708 708 + console.warn(`Index file marked as gzipped but lacks magic bytes, serving as-is`); 709 709 + htmlContent = indexContent.toString('utf-8'); 710 710 + } 711 711 + } else { 712 712 + htmlContent = indexContent.toString('utf-8'); 713 713 + } 714 714 + const rewritten = rewriteHtmlPaths(htmlContent, basePath, indexPath); 715 715 + 716 716 + const { gzipSync } = await import('zlib'); 717 717 + const recompressed = gzipSync(Buffer.from(rewritten, 'utf-8')); 718 718 + 719 719 + rewrittenHtmlCache.set(rewrittenKey, recompressed, recompressed.length); 720 720 + 721 721 + const headers: Record<string, string> = { 722 722 + 'Content-Type': 'text/html; charset=utf-8', 723 723 + 'Content-Encoding': 'gzip', 724 724 + 'Cache-Control': 'public, max-age=300', 725 725 + }; 726 726 + applyCustomHeaders(headers, indexPath, settings); 727 727 + return new Response(recompressed, { headers }); 728 728 + } 729 729 + } 730 730 + } 731 731 + 732 732 + // Try clean URLs: /about -> /about.html 733 733 + if (settings?.cleanUrls && !fileRequestPath.includes('.')) { 734 734 + const htmlPath = `${fileRequestPath}.html`; 735 735 + const htmlFile = getCachedFilePath(did, rkey, htmlPath); 736 736 + if (await fileExists(htmlFile)) { 737 737 + return serveFileInternalWithRewrite(did, rkey, htmlPath, basePath, settings); 738 738 + } 739 739 + 740 740 + // Also try /about/index.html 741 741 + for (const indexFileName of indexFiles) { 742 742 + const indexPath = fileRequestPath ? `${fileRequestPath}/${indexFileName}` : indexFileName; 743 743 + const indexFile = getCachedFilePath(did, rkey, indexPath); 744 744 + if (await fileExists(indexFile)) { 745 745 + return serveFileInternalWithRewrite(did, rkey, indexPath, basePath, settings); 746 746 + } 747 747 + } 748 748 + } 749 749 + 750 750 + // SPA mode: serve SPA file for all non-existing routes 751 751 + if (settings?.spaMode) { 752 752 + const spaFile = settings.spaMode; 753 753 + const spaFilePath = getCachedFilePath(did, rkey, spaFile); 754 754 + if (await fileExists(spaFilePath)) { 755 755 + return serveFileInternalWithRewrite(did, rkey, spaFile, basePath, settings); 756 756 + } 757 757 + } 758 758 + 759 759 + // Custom 404: serve custom 404 file if configured (wins conflict battle) 760 760 + if (settings?.custom404) { 761 761 + const custom404File = settings.custom404; 762 762 + const custom404Path = getCachedFilePath(did, rkey, custom404File); 763 763 + if (await fileExists(custom404Path)) { 764 764 + const response: Response = await serveFileInternalWithRewrite(did, rkey, custom404File, basePath, settings); 765 765 + // Override status to 404 766 766 + return new Response(response.body, { 767 767 + status: 404, 768 768 + headers: response.headers, 769 769 + }); 770 770 + } 771 771 + } 772 772 + 773 773 + // Autodetect 404 pages (GitHub Pages: 404.html, Neocities/Nekoweb: not_found.html) 774 774 + const auto404Pages = ['404.html', 'not_found.html']; 775 775 + for (const auto404Page of auto404Pages) { 776 776 + const auto404Path = getCachedFilePath(did, rkey, auto404Page); 777 777 + if (await fileExists(auto404Path)) { 778 778 + const response: Response = await serveFileInternalWithRewrite(did, rkey, auto404Page, basePath, settings); 779 779 + // Override status to 404 780 780 + return new Response(response.body, { 781 781 + status: 404, 782 782 + headers: response.headers, 783 783 + }); 784 784 + } 785 785 + } 786 786 + 787 787 + // Directory listing fallback: if enabled, show root directory listing on 404 788 788 + if (settings?.directoryListing) { 789 789 + const rootPath = getCachedFilePath(did, rkey, ''); 790 790 + if (await fileExists(rootPath)) { 791 791 + const { stat, readdir } = await import('fs/promises'); 792 792 + try { 793 793 + const stats = await stat(rootPath); 794 794 + if (stats.isDirectory()) { 795 795 + const entries = await readdir(rootPath); 796 796 + // Filter out .meta files and metadata 797 797 + const visibleEntries = entries.filter(entry => 798 798 + !entry.endsWith('.meta') && entry !== '.metadata.json' 799 799 + ); 800 800 + 801 801 + // Check which entries are directories 802 802 + const entriesWithType = await Promise.all( 803 803 + visibleEntries.map(async (name) => { 804 804 + try { 805 805 + const entryPath = `${rootPath}/${name}`; 806 806 + const entryStats = await stat(entryPath); 807 807 + return { name, isDirectory: entryStats.isDirectory() }; 808 808 + } catch { 809 809 + return { name, isDirectory: false }; 810 810 + } 811 811 + }) 812 812 + ); 813 813 + 814 814 + const html = generateDirectoryListing('', entriesWithType); 815 815 + return new Response(html, { 816 816 + status: 404, 817 817 + headers: { 818 818 + 'Content-Type': 'text/html; charset=utf-8', 819 819 + 'Cache-Control': 'public, max-age=300', 820 820 + }, 821 821 + }); 822 822 + } 823 823 + } catch (err) { 824 824 + // If directory listing fails, fall through to 404 825 825 + } 826 826 + } 827 827 + } 828 828 + 829 829 + // Default styled 404 page 830 830 + const html = generate404Page(); 831 831 + return new Response(html, { 832 832 + status: 404, 833 833 + headers: { 834 834 + 'Content-Type': 'text/html; charset=utf-8', 835 835 + 'Cache-Control': 'public, max-age=300', 836 836 + }, 837 837 + }); 838 838 + } 839 839 +

+362

apps/hosting-service/src/lib/page-generators.ts

··· 1 1 + /** 2 2 + * HTML page generation utilities for hosting service 3 3 + * Generates 404 pages, directory listings, and updating pages 4 4 + */ 5 5 + 6 6 + /** 7 7 + * Generate 404 page HTML 8 8 + */ 9 9 + export function generate404Page(): string { 10 10 + const html = `<!DOCTYPE html> 11 11 + <html> 12 12 + <head> 13 13 + <meta charset="utf-8"> 14 14 + <meta name="viewport" content="width=device-width, initial-scale=1"> 15 15 + <title>404 - Not Found</title> 16 16 + <style> 17 17 + @media (prefers-color-scheme: light) { 18 18 + :root { 19 19 + /* Warm beige background */ 20 20 + --background: oklch(0.90 0.012 35); 21 21 + /* Very dark brown text */ 22 22 + --foreground: oklch(0.18 0.01 30); 23 23 + --border: oklch(0.75 0.015 30); 24 24 + /* Bright pink accent for links */ 25 25 + --accent: oklch(0.78 0.15 345); 26 26 + } 27 27 + } 28 28 + @media (prefers-color-scheme: dark) { 29 29 + :root { 30 30 + /* Slate violet background */ 31 31 + --background: oklch(0.23 0.015 285); 32 32 + /* Light gray text */ 33 33 + --foreground: oklch(0.90 0.005 285); 34 34 + /* Subtle borders */ 35 35 + --border: oklch(0.38 0.02 285); 36 36 + /* Soft pink accent */ 37 37 + --accent: oklch(0.85 0.08 5); 38 38 + } 39 39 + } 40 40 + body { 41 41 + font-family: 'SF Mono', Monaco, 'Cascadia Code', 'Roboto Mono', Consolas, 'Courier New', monospace; 42 42 + background: var(--background); 43 43 + color: var(--foreground); 44 44 + padding: 2rem; 45 45 + max-width: 800px; 46 46 + margin: 0 auto; 47 47 + display: flex; 48 48 + flex-direction: column; 49 49 + min-height: 100vh; 50 50 + justify-content: center; 51 51 + align-items: center; 52 52 + text-align: center; 53 53 + } 54 54 + h1 { 55 55 + font-size: 6rem; 56 56 + margin: 0; 57 57 + font-weight: 700; 58 58 + line-height: 1; 59 59 + } 60 60 + h2 { 61 61 + font-size: 1.5rem; 62 62 + margin: 1rem 0 2rem; 63 63 + font-weight: 400; 64 64 + opacity: 0.8; 65 65 + } 66 66 + p { 67 67 + font-size: 1rem; 68 68 + opacity: 0.7; 69 69 + margin-bottom: 2rem; 70 70 + } 71 71 + a { 72 72 + color: var(--accent); 73 73 + text-decoration: none; 74 74 + font-size: 1rem; 75 75 + } 76 76 + a:hover { 77 77 + text-decoration: underline; 78 78 + } 79 79 + footer { 80 80 + margin-top: 2rem; 81 81 + padding-top: 1.5rem; 82 82 + border-top: 1px solid var(--border); 83 83 + text-align: center; 84 84 + font-size: 0.875rem; 85 85 + opacity: 0.7; 86 86 + color: var(--foreground); 87 87 + } 88 88 + footer a { 89 89 + color: var(--accent); 90 90 + text-decoration: none; 91 91 + display: inline; 92 92 + } 93 93 + footer a:hover { 94 94 + text-decoration: underline; 95 95 + } 96 96 + </style> 97 97 + </head> 98 98 + <body> 99 99 + <div> 100 100 + <h1>404</h1> 101 101 + <h2>Page not found</h2> 102 102 + <p>The page you're looking for doesn't exist.</p> 103 103 + <a href="/">← Back to home</a> 104 104 + </div> 105 105 + <footer> 106 106 + Hosted on <a href="https://wisp.place" target="_blank" rel="noopener">wisp.place</a> - Made by <a href="https://bsky.app/profile/nekomimi.pet" target="_blank" rel="noopener">@nekomimi.pet</a> 107 107 + </footer> 108 108 + </body> 109 109 + </html>`; 110 110 + return html; 111 111 + } 112 112 + 113 113 + /** 114 114 + * Generate directory listing HTML 115 115 + */ 116 116 + export function generateDirectoryListing(path: string, entries: Array<{name: string, isDirectory: boolean}>): string { 117 117 + const title = path || 'Index'; 118 118 + 119 119 + // Sort: directories first, then files, alphabetically within each group 120 120 + const sortedEntries = [...entries].sort((a, b) => { 121 121 + if (a.isDirectory && !b.isDirectory) return -1; 122 122 + if (!a.isDirectory && b.isDirectory) return 1; 123 123 + return a.name.localeCompare(b.name); 124 124 + }); 125 125 + 126 126 + const html = `<!DOCTYPE html> 127 127 + <html> 128 128 + <head> 129 129 + <meta charset="utf-8"> 130 130 + <meta name="viewport" content="width=device-width, initial-scale=1"> 131 131 + <title>Index of /${path}</title> 132 132 + <style> 133 133 + @media (prefers-color-scheme: light) { 134 134 + :root { 135 135 + /* Warm beige background */ 136 136 + --background: oklch(0.90 0.012 35); 137 137 + /* Very dark brown text */ 138 138 + --foreground: oklch(0.18 0.01 30); 139 139 + --border: oklch(0.75 0.015 30); 140 140 + /* Bright pink accent for links */ 141 141 + --accent: oklch(0.78 0.15 345); 142 142 + /* Lavender for folders */ 143 143 + --folder: oklch(0.60 0.12 295); 144 144 + --icon: oklch(0.28 0.01 30); 145 145 + } 146 146 + } 147 147 + @media (prefers-color-scheme: dark) { 148 148 + :root { 149 149 + /* Slate violet background */ 150 150 + --background: oklch(0.23 0.015 285); 151 151 + /* Light gray text */ 152 152 + --foreground: oklch(0.90 0.005 285); 153 153 + /* Subtle borders */ 154 154 + --border: oklch(0.38 0.02 285); 155 155 + /* Soft pink accent */ 156 156 + --accent: oklch(0.85 0.08 5); 157 157 + /* Lavender for folders */ 158 158 + --folder: oklch(0.70 0.10 295); 159 159 + --icon: oklch(0.85 0.005 285); 160 160 + } 161 161 + } 162 162 + body { 163 163 + font-family: 'SF Mono', Monaco, 'Cascadia Code', 'Roboto Mono', Consolas, 'Courier New', monospace; 164 164 + background: var(--background); 165 165 + color: var(--foreground); 166 166 + padding: 2rem; 167 167 + max-width: 800px; 168 168 + margin: 0 auto; 169 169 + } 170 170 + h1 { 171 171 + font-size: 1.5rem; 172 172 + margin-bottom: 2rem; 173 173 + padding-bottom: 0.5rem; 174 174 + border-bottom: 1px solid var(--border); 175 175 + } 176 176 + ul { 177 177 + list-style: none; 178 178 + padding: 0; 179 179 + } 180 180 + li { 181 181 + padding: 0.5rem 0; 182 182 + border-bottom: 1px solid var(--border); 183 183 + } 184 184 + li:last-child { 185 185 + border-bottom: none; 186 186 + } 187 187 + li a { 188 188 + color: var(--accent); 189 189 + text-decoration: none; 190 190 + display: flex; 191 191 + align-items: center; 192 192 + gap: 0.75rem; 193 193 + } 194 194 + li a:hover { 195 195 + text-decoration: underline; 196 196 + } 197 197 + .folder { 198 198 + color: var(--folder); 199 199 + font-weight: 600; 200 200 + } 201 201 + .file { 202 202 + color: var(--accent); 203 203 + } 204 204 + .folder::before, 205 205 + .file::before, 206 206 + .parent::before { 207 207 + content: ""; 208 208 + display: inline-block; 209 209 + width: 1.25em; 210 210 + height: 1.25em; 211 211 + background-color: var(--icon); 212 212 + flex-shrink: 0; 213 213 + -webkit-mask-size: contain; 214 214 + mask-size: contain; 215 215 + -webkit-mask-repeat: no-repeat; 216 216 + mask-repeat: no-repeat; 217 217 + -webkit-mask-position: center; 218 218 + mask-position: center; 219 219 + } 220 220 + .folder::before { 221 221 + -webkit-mask-image: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><path d="M64 15v37a5.006 5.006 0 0 1-5 5H5a5.006 5.006 0 0 1-5-5V12a5.006 5.006 0 0 1 5-5h14.116a6.966 6.966 0 0 1 5.466 2.627l5 6.247A2.983 2.983 0 0 0 31.922 17H59a1 1 0 0 1 0 2H31.922a4.979 4.979 0 0 1-3.9-1.876l-5-6.247A4.976 4.976 0 0 0 19.116 9H5a3 3 0 0 0-3 3v40a3 3 0 0 0 3 3h54a3 3 0 0 0 3-3V15a3 3 0 0 0-3-3H30a1 1 0 0 1 0-2h29a5.006 5.006 0 0 1 5 5z"/></svg>'); 222 222 + mask-image: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><path d="M64 15v37a5.006 5.006 0 0 1-5 5H5a5.006 5.006 0 0 1-5-5V12a5.006 5.006 0 0 1 5-5h14.116a6.966 6.966 0 0 1 5.466 2.627l5 6.247A2.983 2.983 0 0 0 31.922 17H59a1 1 0 0 1 0 2H31.922a4.979 4.979 0 0 1-3.9-1.876l-5-6.247A4.976 4.976 0 0 0 19.116 9H5a3 3 0 0 0-3 3v40a3 3 0 0 0 3 3h54a3 3 0 0 0 3-3V15a3 3 0 0 0-3-3H30a1 1 0 0 1 0-2h29a5.006 5.006 0 0 1 5 5z"/></svg>'); 223 223 + } 224 224 + .file::before { 225 225 + -webkit-mask-image: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 25 25"><g><path d="M18 8.28a.59.59 0 0 0-.13-.18l-4-3.9h-.05a.41.41 0 0 0-.15-.2.41.41 0 0 0-.19 0h-9a.5.5 0 0 0-.5.5v19a.5.5 0 0 0 .5.5h13a.5.5 0 0 0 .5-.5V8.43a.58.58 0 0 0 .02-.15zM16.3 8H14V5.69zM5 23V5h8v3.5a.49.49 0 0 0 .15.36.5.5 0 0 0 .35.14l3.5-.06V23z"/><path d="M20.5 1h-13a.5.5 0 0 0-.5.5V3a.5.5 0 0 0 1 0V2h12v18h-1a.5.5 0 0 0 0 1h1.5a.5.5 0 0 0 .5-.5v-19a.5.5 0 0 0-.5-.5z"/><path d="M7.5 8h3a.5.5 0 0 0 0-1h-3a.5.5 0 0 0 0 1zM7.5 11h4a.5.5 0 0 0 0-1h-4a.5.5 0 0 0 0 1zM13.5 13h-6a.5.5 0 0 0 0 1h6a.5.5 0 0 0 0-1zM13.5 16h-6a.5.5 0 0 0 0 1h6a.5.5 0 0 0 0-1zM13.5 19h-6a.5.5 0 0 0 0 1h6a.5.5 0 0 0 0-1z"/></g></svg>'); 226 226 + mask-image: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 25 25"><g><path d="M18 8.28a.59.59 0 0 0-.13-.18l-4-3.9h-.05a.41.41 0 0 0-.15-.2.41.41 0 0 0-.19 0h-9a.5.5 0 0 0-.5.5v19a.5.5 0 0 0 .5.5h13a.5.5 0 0 0 .5-.5V8.43a.58.58 0 0 0 .02-.15zM16.3 8H14V5.69zM5 23V5h8v3.5a.49.49 0 0 0 .15.36.5.5 0 0 0 .35.14l3.5-.06V23z"/><path d="M20.5 1h-13a.5.5 0 0 0-.5.5V3a.5.5 0 0 0 1 0V2h12v18h-1a.5.5 0 0 0 0 1h1.5a.5.5 0 0 0 .5-.5v-19a.5.5 0 0 0-.5-.5z"/><path d="M7.5 8h3a.5.5 0 0 0 0-1h-3a.5.5 0 0 0 0 1zM7.5 11h4a.5.5 0 0 0 0-1h-4a.5.5 0 0 0 0 1zM13.5 13h-6a.5.5 0 0 0 0 1h6a.5.5 0 0 0 0-1zM13.5 16h-6a.5.5 0 0 0 0 1h6a.5.5 0 0 0 0-1zM13.5 19h-6a.5.5 0 0 0 0 1h6a.5.5 0 0 0 0-1z"/></g></svg>'); 227 227 + } 228 228 + .parent::before { 229 229 + -webkit-mask-image: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M7.41 15.41L12 10.83l4.59 4.58L18 14l-6-6-6 6z"/></svg>'); 230 230 + mask-image: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M7.41 15.41L12 10.83l4.59 4.58L18 14l-6-6-6 6z"/></svg>'); 231 231 + } 232 232 + footer { 233 233 + margin-top: 2rem; 234 234 + padding-top: 1.5rem; 235 235 + border-top: 1px solid var(--border); 236 236 + text-align: center; 237 237 + font-size: 0.875rem; 238 238 + opacity: 0.7; 239 239 + color: var(--foreground); 240 240 + } 241 241 + footer a { 242 242 + color: var(--accent); 243 243 + text-decoration: none; 244 244 + display: inline; 245 245 + } 246 246 + footer a:hover { 247 247 + text-decoration: underline; 248 248 + } 249 249 + </style> 250 250 + </head> 251 251 + <body> 252 252 + <h1>Index of /${path}</h1> 253 253 + <ul> 254 254 + ${path ? '<li><a href="../" class="parent">../</a></li>' : ''} 255 255 + ${sortedEntries.map(e => 256 256 + `<li><a href="${e.name}${e.isDirectory ? '/' : ''}" class="${e.isDirectory ? 'folder' : 'file'}">${e.name}${e.isDirectory ? '/' : ''}</a></li>` 257 257 + ).join('\n ')} 258 258 + </ul> 259 259 + <footer> 260 260 + Hosted on <a href="https://wisp.place" target="_blank" rel="noopener">wisp.place</a> - Made by <a href="https://bsky.app/profile/nekomimi.pet" target="_blank" rel="noopener">@nekomimi.pet</a> 261 261 + </footer> 262 262 + </body> 263 263 + </html>`; 264 264 + return html; 265 265 + } 266 266 + 267 267 + /** 268 268 + * Return a response indicating the site is being updated 269 269 + */ 270 270 + export function generateSiteUpdatingPage(): string { 271 271 + const html = `<!DOCTYPE html> 272 272 + <html> 273 273 + <head> 274 274 + <meta charset="utf-8"> 275 275 + <meta name="viewport" content="width=device-width, initial-scale=1"> 276 276 + <title>Site Updating</title> 277 277 + <style> 278 278 + @media (prefers-color-scheme: light) { 279 279 + :root { 280 280 + --background: oklch(0.90 0.012 35); 281 281 + --foreground: oklch(0.18 0.01 30); 282 282 + --primary: oklch(0.35 0.02 35); 283 283 + --accent: oklch(0.78 0.15 345); 284 284 + } 285 285 + } 286 286 + @media (prefers-color-scheme: dark) { 287 287 + :root { 288 288 + --background: oklch(0.23 0.015 285); 289 289 + --foreground: oklch(0.90 0.005 285); 290 290 + --primary: oklch(0.70 0.10 295); 291 291 + --accent: oklch(0.85 0.08 5); 292 292 + } 293 293 + } 294 294 + body { 295 295 + font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; 296 296 + display: flex; 297 297 + align-items: center; 298 298 + justify-content: center; 299 299 + min-height: 100vh; 300 300 + margin: 0; 301 301 + background: var(--background); 302 302 + color: var(--foreground); 303 303 + } 304 304 + .container { 305 305 + text-align: center; 306 306 + padding: 2rem; 307 307 + max-width: 500px; 308 308 + } 309 309 + h1 { 310 310 + font-size: 2.5rem; 311 311 + margin-bottom: 1rem; 312 312 + font-weight: 600; 313 313 + color: var(--primary); 314 314 + } 315 315 + p { 316 316 + font-size: 1.25rem; 317 317 + opacity: 0.8; 318 318 + margin-bottom: 2rem; 319 319 + color: var(--foreground); 320 320 + } 321 321 + .spinner { 322 322 + border: 4px solid var(--accent); 323 323 + border-radius: 50%; 324 324 + border-top: 4px solid var(--primary); 325 325 + width: 40px; 326 326 + height: 40px; 327 327 + animation: spin 1s linear infinite; 328 328 + margin: 0 auto; 329 329 + } 330 330 + @keyframes spin { 331 331 + 0% { transform: rotate(0deg); } 332 332 + 100% { transform: rotate(360deg); } 333 333 + } 334 334 + </style> 335 335 + <meta http-equiv="refresh" content="3"> 336 336 + </head> 337 337 + <body> 338 338 + <div class="container"> 339 339 + <h1>Site Updating</h1> 340 340 + <p>This site is undergoing an update right now. Check back in a moment...</p> 341 341 + <div class="spinner"></div> 342 342 + </div> 343 343 + </body> 344 344 + </html>`; 345 345 + 346 346 + return html; 347 347 + } 348 348 + 349 349 + /** 350 350 + * Create a Response for site updating 351 351 + */ 352 352 + export function siteUpdatingResponse(): Response { 353 353 + return new Response(generateSiteUpdatingPage(), { 354 354 + status: 503, 355 355 + headers: { 356 356 + 'Content-Type': 'text/html; charset=utf-8', 357 357 + 'Cache-Control': 'no-store, no-cache, must-revalidate', 358 358 + 'Retry-After': '3', 359 359 + }, 360 360 + }); 361 361 + } 362 362 +

+96

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

··· 1 1 + /** 2 2 + * Request utilities for validation and helper functions 3 3 + */ 4 4 + 5 5 + import type { Record as WispSettings } from '@wisp/lexicons/types/place/wisp/settings'; 6 6 + import { access } from 'fs/promises'; 7 7 + 8 8 + /** 9 9 + * Default index file names to check for directory requests 10 10 + * Will be checked in order until one is found 11 11 + */ 12 12 + export const DEFAULT_INDEX_FILES = ['index.html', 'index.htm']; 13 13 + 14 14 + /** 15 15 + * Get index files list from settings or use defaults 16 16 + */ 17 17 + export function getIndexFiles(settings: WispSettings | null): string[] { 18 18 + if (settings?.indexFiles && settings.indexFiles.length > 0) { 19 19 + return settings.indexFiles; 20 20 + } 21 21 + return DEFAULT_INDEX_FILES; 22 22 + } 23 23 + 24 24 + /** 25 25 + * Match a file path against a glob pattern 26 26 + * Supports * wildcard and basic path matching 27 27 + */ 28 28 + export function matchGlob(path: string, pattern: string): boolean { 29 29 + // Normalize paths 30 30 + const normalizedPath = path.startsWith('/') ? path : '/' + path; 31 31 + const normalizedPattern = pattern.startsWith('/') ? pattern : '/' + pattern; 32 32 + 33 33 + // Convert glob pattern to regex 34 34 + const regexPattern = normalizedPattern 35 35 + .replace(/\./g, '\\.') 36 36 + .replace(/\*/g, '.*') 37 37 + .replace(/\?/g, '.'); 38 38 + 39 39 + const regex = new RegExp('^' + regexPattern + '$'); 40 40 + return regex.test(normalizedPath); 41 41 + } 42 42 + 43 43 + /** 44 44 + * Apply custom headers from settings to response headers 45 45 + */ 46 46 + export function applyCustomHeaders(headers: Record<string, string>, filePath: string, settings: WispSettings | null) { 47 47 + if (!settings?.headers || settings.headers.length === 0) return; 48 48 + 49 49 + for (const customHeader of settings.headers) { 50 50 + // If path glob is specified, check if it matches 51 51 + if (customHeader.path) { 52 52 + if (!matchGlob(filePath, customHeader.path)) { 53 53 + continue; 54 54 + } 55 55 + } 56 56 + // Apply the header 57 57 + headers[customHeader.name] = customHeader.value; 58 58 + } 59 59 + } 60 60 + 61 61 + /** 62 62 + * Validate site name (rkey) to prevent injection attacks 63 63 + * Must match AT Protocol rkey format 64 64 + */ 65 65 + export function isValidRkey(rkey: string): boolean { 66 66 + if (!rkey || typeof rkey !== 'string') return false; 67 67 + if (rkey.length < 1 || rkey.length > 512) return false; 68 68 + if (rkey === '.' || rkey === '..') return false; 69 69 + if (rkey.includes('/') || rkey.includes('\\') || rkey.includes('\0')) return false; 70 70 + const validRkeyPattern = /^[a-zA-Z0-9._~:-]+$/; 71 71 + return validRkeyPattern.test(rkey); 72 72 + } 73 73 + 74 74 + /** 75 75 + * Async file existence check 76 76 + */ 77 77 + export async function fileExists(path: string): Promise<boolean> { 78 78 + try { 79 79 + await access(path); 80 80 + return true; 81 81 + } catch { 82 82 + return false; 83 83 + } 84 84 + } 85 85 + 86 86 + /** 87 87 + * Extract and normalize headers from request 88 88 + */ 89 89 + export function extractHeaders(rawHeaders: Headers): Record<string, string> { 90 90 + const headers: Record<string, string> = {}; 91 91 + rawHeaders.forEach((value, key) => { 92 92 + headers[key.toLowerCase()] = value; 93 93 + }); 94 94 + return headers; 95 95 + } 96 96 +

+79

apps/hosting-service/src/lib/site-cache.ts

··· 1 1 + /** 2 2 + * Site caching management utilities 3 3 + */ 4 4 + 5 5 + import { createLogger } from '@wisp/observability'; 6 6 + import { fetchSiteRecord, getPdsForDid, downloadAndCacheSite, isCached } from './utils'; 7 7 + import { markSiteAsBeingCached, unmarkSiteAsBeingCached } from './cache'; 8 8 + import type { RedirectRule } from './redirects'; 9 9 + 10 10 + const logger = createLogger('hosting-service'); 11 11 + 12 12 + // Cache for redirect rules (per site) 13 13 + const redirectRulesCache = new Map<string, RedirectRule[]>(); 14 14 + 15 15 + /** 16 16 + * Clear redirect rules cache for a specific site 17 17 + * Should be called when a site is updated/recached 18 18 + */ 19 19 + export function clearRedirectRulesCache(did: string, rkey: string) { 20 20 + const cacheKey = `${did}:${rkey}`; 21 21 + redirectRulesCache.delete(cacheKey); 22 22 + } 23 23 + 24 24 + /** 25 25 + * Get redirect rules from cache 26 26 + */ 27 27 + export function getRedirectRulesFromCache(did: string, rkey: string): RedirectRule[] | undefined { 28 28 + const cacheKey = `${did}:${rkey}`; 29 29 + return redirectRulesCache.get(cacheKey); 30 30 + } 31 31 + 32 32 + /** 33 33 + * Set redirect rules in cache 34 34 + */ 35 35 + export function setRedirectRulesInCache(did: string, rkey: string, rules: RedirectRule[]) { 36 36 + const cacheKey = `${did}:${rkey}`; 37 37 + redirectRulesCache.set(cacheKey, rules); 38 38 + } 39 39 + 40 40 + /** 41 41 + * Helper to ensure site is cached 42 42 + * Returns true if site is successfully cached, false otherwise 43 43 + */ 44 44 + export async function ensureSiteCached(did: string, rkey: string): Promise<boolean> { 45 45 + if (isCached(did, rkey)) { 46 46 + return true; 47 47 + } 48 48 + 49 49 + // Fetch and cache the site 50 50 + const siteData = await fetchSiteRecord(did, rkey); 51 51 + if (!siteData) { 52 52 + logger.error('Site record not found', null, { did, rkey }); 53 53 + return false; 54 54 + } 55 55 + 56 56 + const pdsEndpoint = await getPdsForDid(did); 57 57 + if (!pdsEndpoint) { 58 58 + logger.error('PDS not found for DID', null, { did }); 59 59 + return false; 60 60 + } 61 61 + 62 62 + // Mark site as being cached to prevent serving stale content during update 63 63 + markSiteAsBeingCached(did, rkey); 64 64 + 65 65 + try { 66 66 + await downloadAndCacheSite(did, rkey, siteData.record, pdsEndpoint, siteData.cid); 67 67 + // Clear redirect rules cache since the site was updated 68 68 + clearRedirectRulesCache(did, rkey); 69 69 + logger.info('Site cached successfully', { did, rkey }); 70 70 + return true; 71 71 + } catch (err) { 72 72 + logger.error('Failed to cache site', err, { did, rkey }); 73 73 + return false; 74 74 + } finally { 75 75 + // Always unmark, even if caching fails 76 76 + unmarkSiteAsBeingCached(did, rkey); 77 77 + } 78 78 + } 79 79 +

+234

apps/hosting-service/src/server.ts

··· 1 1 + /** 2 2 + * Main server entry point for the hosting service 3 3 + * Handles routing and request dispatching 4 4 + */ 5 5 + 6 6 + import { Hono } from 'hono'; 7 7 + import { cors } from 'hono/cors'; 8 8 + import { getWispDomain, getCustomDomain, getCustomDomainByHash } from './lib/db'; 9 9 + import { resolveDid } from './lib/utils'; 10 10 + import { logCollector, errorTracker, metricsCollector } from '@wisp/observability'; 11 11 + import { observabilityMiddleware, observabilityErrorHandler } from '@wisp/observability/middleware/hono'; 12 12 + import { sanitizePath } from '@wisp/fs-utils'; 13 13 + import { isSiteBeingCached } from './lib/cache'; 14 14 + import { isValidRkey, extractHeaders } from './lib/request-utils'; 15 15 + import { siteUpdatingResponse } from './lib/page-generators'; 16 16 + import { ensureSiteCached } from './lib/site-cache'; 17 17 + import { serveFromCache, serveFromCacheWithRewrite } from './lib/file-serving'; 18 18 + 19 19 + const BASE_HOST = process.env.BASE_HOST || 'wisp.place'; 20 20 + 21 21 + const app = new Hono(); 22 22 + 23 23 + // Add CORS middleware - allow all origins for static site hosting 24 24 + app.use('*', cors({ 25 25 + origin: '*', 26 26 + allowMethods: ['GET', 'HEAD', 'OPTIONS'], 27 27 + allowHeaders: ['Content-Type', 'Authorization'], 28 28 + exposeHeaders: ['Content-Length', 'Content-Type', 'Content-Encoding', 'Cache-Control'], 29 29 + maxAge: 86400, // 24 hours 30 30 + credentials: false, 31 31 + })); 32 32 + 33 33 + // Add observability middleware 34 34 + app.use('*', observabilityMiddleware('hosting-service')); 35 35 + 36 36 + // Error handler 37 37 + app.onError(observabilityErrorHandler('hosting-service')); 38 38 + 39 39 + // Main site serving route 40 40 + app.get('/*', async (c) => { 41 41 + const url = new URL(c.req.url); 42 42 + const hostname = c.req.header('host') || ''; 43 43 + const rawPath = url.pathname.replace(/^\//, ''); 44 44 + const path = sanitizePath(rawPath); 45 45 + 46 46 + // Check if this is sites.wisp.place subdomain (strip port for comparison) 47 47 + const hostnameWithoutPort = hostname.split(':')[0]; 48 48 + if (hostnameWithoutPort === `sites.${BASE_HOST}`) { 49 49 + // Sanitize the path FIRST to prevent path traversal 50 50 + const sanitizedFullPath = sanitizePath(rawPath); 51 51 + 52 52 + // Extract identifier and site from sanitized path: did:plc:123abc/sitename/file.html 53 53 + const pathParts = sanitizedFullPath.split('/'); 54 54 + if (pathParts.length < 2) { 55 55 + return c.text('Invalid path format. Expected: /identifier/sitename/path', 400); 56 56 + } 57 57 + 58 58 + const identifier = pathParts[0]; 59 59 + const site = pathParts[1]; 60 60 + const filePath = pathParts.slice(2).join('/'); 61 61 + 62 62 + // Additional validation: identifier must be a valid DID or handle format 63 63 + if (!identifier || identifier.length < 3 || identifier.includes('..') || identifier.includes('\0')) { 64 64 + return c.text('Invalid identifier', 400); 65 65 + } 66 66 + 67 67 + // Validate site parameter exists 68 68 + if (!site) { 69 69 + return c.text('Site name required', 400); 70 70 + } 71 71 + 72 72 + // Validate site name (rkey) 73 73 + if (!isValidRkey(site)) { 74 74 + return c.text('Invalid site name', 400); 75 75 + } 76 76 + 77 77 + // Resolve identifier to DID 78 78 + const did = await resolveDid(identifier); 79 79 + if (!did) { 80 80 + return c.text('Invalid identifier', 400); 81 81 + } 82 82 + 83 83 + // Check if site is currently being cached - return updating response early 84 84 + if (isSiteBeingCached(did, site)) { 85 85 + return siteUpdatingResponse(); 86 86 + } 87 87 + 88 88 + // Ensure site is cached 89 89 + const cached = await ensureSiteCached(did, site); 90 90 + if (!cached) { 91 91 + return c.text('Site not found', 404); 92 92 + } 93 93 + 94 94 + // Serve with HTML path rewriting to handle absolute paths 95 95 + const basePath = `/${identifier}/${site}/`; 96 96 + const headers = extractHeaders(c.req.raw.headers); 97 97 + return serveFromCacheWithRewrite(did, site, filePath, basePath, c.req.url, headers); 98 98 + } 99 99 + 100 100 + // Check if this is a DNS hash subdomain 101 101 + const dnsMatch = hostname.match(/^([a-f0-9]{16})\.dns\.(.+)$/); 102 102 + if (dnsMatch) { 103 103 + const hash = dnsMatch[1]; 104 104 + const baseDomain = dnsMatch[2]; 105 105 + 106 106 + if (!hash) { 107 107 + return c.text('Invalid DNS hash', 400); 108 108 + } 109 109 + 110 110 + if (baseDomain !== BASE_HOST) { 111 111 + return c.text('Invalid base domain', 400); 112 112 + } 113 113 + 114 114 + const customDomain = await getCustomDomainByHash(hash); 115 115 + if (!customDomain) { 116 116 + return c.text('Custom domain not found or not verified', 404); 117 117 + } 118 118 + 119 119 + if (!customDomain.rkey) { 120 120 + return c.text('Domain not mapped to a site', 404); 121 121 + } 122 122 + 123 123 + const rkey = customDomain.rkey; 124 124 + if (!isValidRkey(rkey)) { 125 125 + return c.text('Invalid site configuration', 500); 126 126 + } 127 127 + 128 128 + // Check if site is currently being cached - return updating response early 129 129 + if (isSiteBeingCached(customDomain.did, rkey)) { 130 130 + return siteUpdatingResponse(); 131 131 + } 132 132 + 133 133 + const cached = await ensureSiteCached(customDomain.did, rkey); 134 134 + if (!cached) { 135 135 + return c.text('Site not found', 404); 136 136 + } 137 137 + 138 138 + const headers = extractHeaders(c.req.raw.headers); 139 139 + return serveFromCache(customDomain.did, rkey, path, c.req.url, headers); 140 140 + } 141 141 + 142 142 + // Route 2: Registered subdomains - /*.wisp.place/* 143 143 + if (hostname.endsWith(`.${BASE_HOST}`)) { 144 144 + const domainInfo = await getWispDomain(hostname); 145 145 + if (!domainInfo) { 146 146 + return c.text('Subdomain not registered', 404); 147 147 + } 148 148 + 149 149 + if (!domainInfo.rkey) { 150 150 + return c.text('Domain not mapped to a site', 404); 151 151 + } 152 152 + 153 153 + const rkey = domainInfo.rkey; 154 154 + if (!isValidRkey(rkey)) { 155 155 + return c.text('Invalid site configuration', 500); 156 156 + } 157 157 + 158 158 + // Check if site is currently being cached - return updating response early 159 159 + if (isSiteBeingCached(domainInfo.did, rkey)) { 160 160 + return siteUpdatingResponse(); 161 161 + } 162 162 + 163 163 + const cached = await ensureSiteCached(domainInfo.did, rkey); 164 164 + if (!cached) { 165 165 + return c.text('Site not found', 404); 166 166 + } 167 167 + 168 168 + const headers = extractHeaders(c.req.raw.headers); 169 169 + return serveFromCache(domainInfo.did, rkey, path, c.req.url, headers); 170 170 + } 171 171 + 172 172 + // Route 1: Custom domains - /* 173 173 + const customDomain = await getCustomDomain(hostname); 174 174 + if (!customDomain) { 175 175 + return c.text('Custom domain not found or not verified', 404); 176 176 + } 177 177 + 178 178 + if (!customDomain.rkey) { 179 179 + return c.text('Domain not mapped to a site', 404); 180 180 + } 181 181 + 182 182 + const rkey = customDomain.rkey; 183 183 + if (!isValidRkey(rkey)) { 184 184 + return c.text('Invalid site configuration', 500); 185 185 + } 186 186 + 187 187 + // Check if site is currently being cached - return updating response early 188 188 + if (isSiteBeingCached(customDomain.did, rkey)) { 189 189 + return siteUpdatingResponse(); 190 190 + } 191 191 + 192 192 + const cached = await ensureSiteCached(customDomain.did, rkey); 193 193 + if (!cached) { 194 194 + return c.text('Site not found', 404); 195 195 + } 196 196 + 197 197 + const headers = extractHeaders(c.req.raw.headers); 198 198 + return serveFromCache(customDomain.did, rkey, path, c.req.url, headers); 199 199 + }); 200 200 + 201 201 + // Internal observability endpoints (for admin panel) 202 202 + app.get('/__internal__/observability/logs', (c) => { 203 203 + const query = c.req.query(); 204 204 + const filter: any = {}; 205 205 + if (query.level) filter.level = query.level; 206 206 + if (query.service) filter.service = query.service; 207 207 + if (query.search) filter.search = query.search; 208 208 + if (query.eventType) filter.eventType = query.eventType; 209 209 + if (query.limit) filter.limit = parseInt(query.limit as string); 210 210 + return c.json({ logs: logCollector.getLogs(filter) }); 211 211 + }); 212 212 + 213 213 + app.get('/__internal__/observability/errors', (c) => { 214 214 + const query = c.req.query(); 215 215 + const filter: any = {}; 216 216 + if (query.service) filter.service = query.service; 217 217 + if (query.limit) filter.limit = parseInt(query.limit as string); 218 218 + return c.json({ errors: errorTracker.getErrors(filter) }); 219 219 + }); 220 220 + 221 221 + app.get('/__internal__/observability/metrics', (c) => { 222 222 + const query = c.req.query(); 223 223 + const timeWindow = query.timeWindow ? parseInt(query.timeWindow as string) : 3600000; 224 224 + const stats = metricsCollector.getStats('hosting-service', timeWindow); 225 225 + return c.json({ stats, timeWindow }); 226 226 + }); 227 227 + 228 228 + app.get('/__internal__/observability/cache', async (c) => { 229 229 + const { getCacheStats } = await import('./lib/cache'); 230 230 + const stats = getCacheStats(); 231 231 + return c.json({ cache: stats }); 232 232 + }); 233 233 + 234 234 + export default app;

+67

apps/main-app/package.json

··· 1 1 + { 2 2 + "name": "@wisp/main-app", 3 3 + "version": "1.0.50", 4 4 + "private": true, 5 5 + "scripts": { 6 6 + "test": "bun test", 7 7 + "dev": "bun run --watch src/index.ts", 8 8 + "start": "bun run src/index.ts", 9 9 + "build": "bun build --compile --target bun --outfile server src/index.ts", 10 10 + "screenshot": "bun run scripts/screenshot-sites.ts" 11 11 + }, 12 12 + "dependencies": { 13 13 + "@wisp/lexicons": "workspace:*", 14 14 + "@wisp/constants": "workspace:*", 15 15 + "@wisp/observability": "workspace:*", 16 16 + "@wisp/atproto-utils": "workspace:*", 17 17 + "@wisp/database": "workspace:*", 18 18 + "@wisp/fs-utils": "workspace:*", 19 19 + "@atproto/api": "^0.17.3", 20 20 + "@atproto/lex-cli": "^0.9.5", 21 21 + "@atproto/oauth-client-node": "^0.3.9", 22 22 + "@atproto/xrpc-server": "^0.9.5", 23 23 + "@elysiajs/cors": "^1.4.0", 24 24 + "@elysiajs/eden": "^1.4.3", 25 25 + "@elysiajs/openapi": "^1.4.11", 26 26 + "@elysiajs/opentelemetry": "^1.4.6", 27 27 + "@elysiajs/static": "^1.4.2", 28 28 + "@radix-ui/react-checkbox": "^1.3.3", 29 29 + "@radix-ui/react-dialog": "^1.1.15", 30 30 + "@radix-ui/react-label": "^2.1.7", 31 31 + "@radix-ui/react-radio-group": "^1.3.8", 32 32 + "@radix-ui/react-slot": "^1.2.3", 33 33 + "@radix-ui/react-tabs": "^1.1.13", 34 34 + "@tanstack/react-query": "^5.90.2", 35 35 + "actor-typeahead": "^0.1.1", 36 36 + "atproto-ui": "^0.11.3", 37 37 + "class-variance-authority": "^0.7.1", 38 38 + "clsx": "^2.1.1", 39 39 + "elysia": "latest", 40 40 + "iron-session": "^8.0.4", 41 41 + "lucide-react": "^0.546.0", 42 42 + "multiformats": "^13.4.1", 43 43 + "prismjs": "^1.30.0", 44 44 + "react": "^19.2.0", 45 45 + "react-dom": "^19.2.0", 46 46 + "tailwind-merge": "^3.3.1", 47 47 + "tailwindcss": "4", 48 48 + "tw-animate-css": "^1.4.0", 49 49 + "typescript": "^5.9.3", 50 50 + "zlib": "^1.0.5" 51 51 + }, 52 52 + "devDependencies": { 53 53 + "@types/react": "^19.2.2", 54 54 + "@types/react-dom": "^19.2.1", 55 55 + "bun-plugin-tailwind": "^0.1.2", 56 56 + "bun-types": "latest", 57 57 + "esbuild": "0.26.0", 58 58 + "playwright": "^1.49.0" 59 59 + }, 60 60 + "module": "src/index.js", 61 61 + "trustedDependencies": [ 62 62 + "bun", 63 63 + "cbor-extract", 64 64 + "core-js", 65 65 + "protobufjs" 66 66 + ] 67 67 + }

+9

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

··· 1 1 + /** 2 2 + * Main app logger using @wisp/observability 3 3 + * 4 4 + * Note: This file is kept for backward compatibility. 5 5 + * New code should import createLogger from @wisp/observability directly. 6 6 + */ 7 7 + import { createLogger } from '@wisp/observability' 8 8 + 9 9 + export const logger = createLogger('main-app')

+14

apps/main-app/tsconfig.json

··· 1 1 + { 2 2 + "extends": "../../tsconfig.json", 3 3 + "compilerOptions": { 4 4 + "baseUrl": ".", 5 5 + "paths": { 6 6 + "@server": ["./src/index.ts"], 7 7 + "@server/*": ["./src/*"], 8 8 + "@public/*": ["./public/*"], 9 9 + "@wisp/*": ["../../packages/@wisp/*/src"] 10 10 + } 11 11 + }, 12 12 + "include": ["src/**/*", "public/**/*", "scripts/**/*"], 13 13 + "exclude": ["node_modules"] 14 14 + }

+291 -9

bun.lock

··· 4 4 "workspaces": { 5 5 "": { 6 6 "name": "elysia-static", 7 7 + }, 8 8 + "apps/hosting-service": { 9 9 + "name": "wisp-hosting-service", 10 10 + "version": "1.0.0", 11 11 + "dependencies": { 12 12 + "@atproto/api": "^0.17.4", 13 13 + "@atproto/identity": "^0.4.9", 14 14 + "@atproto/lexicon": "^0.5.1", 15 15 + "@atproto/sync": "^0.1.36", 16 16 + "@atproto/xrpc": "^0.7.5", 17 17 + "@hono/node-server": "^1.19.6", 18 18 + "@wisp/atproto-utils": "workspace:*", 19 19 + "@wisp/constants": "workspace:*", 20 20 + "@wisp/database": "workspace:*", 21 21 + "@wisp/fs-utils": "workspace:*", 22 22 + "@wisp/lexicons": "workspace:*", 23 23 + "@wisp/observability": "workspace:*", 24 24 + "@wisp/safe-fetch": "workspace:*", 25 25 + "hono": "^4.10.4", 26 26 + "mime-types": "^2.1.35", 27 27 + "multiformats": "^13.4.1", 28 28 + "postgres": "^3.4.5", 29 29 + }, 30 30 + "devDependencies": { 31 31 + "@types/bun": "^1.3.1", 32 32 + "@types/mime-types": "^2.1.4", 33 33 + "@types/node": "^22.10.5", 34 34 + "tsx": "^4.19.2", 35 35 + }, 36 36 + }, 37 37 + "apps/main-app": { 38 38 + "name": "@wisp/main-app", 39 39 + "version": "1.0.50", 7 40 "dependencies": { 8 41 "@atproto/api": "^0.17.3", 9 42 "@atproto/lex-cli": "^0.9.5", ··· 21 54 "@radix-ui/react-slot": "^1.2.3", 22 55 "@radix-ui/react-tabs": "^1.1.13", 23 56 "@tanstack/react-query": "^5.90.2", 57 57 + "@wisp/atproto-utils": "workspace:*", 58 58 + "@wisp/constants": "workspace:*", 59 59 + "@wisp/database": "workspace:*", 60 60 + "@wisp/fs-utils": "workspace:*", 61 61 + "@wisp/lexicons": "workspace:*", 62 62 + "@wisp/observability": "workspace:*", 24 63 "actor-typeahead": "^0.1.1", 25 64 "atproto-ui": "^0.11.3", 26 65 "class-variance-authority": "^0.7.1", ··· 47 86 "playwright": "^1.49.0", 48 87 }, 49 88 }, 89 89 + "packages/@wisp/atproto-utils": { 90 90 + "name": "@wisp/atproto-utils", 91 91 + "version": "1.0.0", 92 92 + "dependencies": { 93 93 + "@atproto/api": "^0.14.1", 94 94 + "@wisp/lexicons": "workspace:*", 95 95 + "multiformats": "^13.3.1", 96 96 + }, 97 97 + }, 98 98 + "packages/@wisp/constants": { 99 99 + "name": "@wisp/constants", 100 100 + "version": "1.0.0", 101 101 + }, 102 102 + "packages/@wisp/database": { 103 103 + "name": "@wisp/database", 104 104 + "version": "1.0.0", 105 105 + "dependencies": { 106 106 + "postgres": "^3.4.5", 107 107 + }, 108 108 + "peerDependencies": { 109 109 + "bun": "^1.0.0", 110 110 + }, 111 111 + "optionalPeers": [ 112 112 + "bun", 113 113 + ], 114 114 + }, 115 115 + "packages/@wisp/fs-utils": { 116 116 + "name": "@wisp/fs-utils", 117 117 + "version": "1.0.0", 118 118 + "dependencies": { 119 119 + "@atproto/api": "^0.14.1", 120 120 + "@wisp/lexicons": "workspace:*", 121 121 + }, 122 122 + }, 123 123 + "packages/@wisp/lexicons": { 124 124 + "name": "@wisp/lexicons", 125 125 + "version": "1.0.0", 126 126 + "dependencies": { 127 127 + "@atproto/lexicon": "^0.5.1", 128 128 + "@atproto/xrpc-server": "^0.9.5", 129 129 + }, 130 130 + "devDependencies": { 131 131 + "@atproto/lex-cli": "^0.9.5", 132 132 + }, 133 133 + }, 134 134 + "packages/@wisp/observability": { 135 135 + "name": "@wisp/observability", 136 136 + "version": "1.0.0", 137 137 + "peerDependencies": { 138 138 + "hono": "^4.0.0", 139 139 + }, 140 140 + "optionalPeers": [ 141 141 + "hono", 142 142 + ], 143 143 + }, 144 144 + "packages/@wisp/safe-fetch": { 145 145 + "name": "@wisp/safe-fetch", 146 146 + "version": "1.0.0", 147 147 + }, 50 148 }, 51 149 "trustedDependencies": [ 52 150 "core-js", ··· 89 187 90 188 "@atproto-labs/simple-store-memory": ["@atproto-labs/simple-store-memory@0.1.4", "", { "dependencies": { "@atproto-labs/simple-store": "0.3.0", "lru-cache": "^10.2.0" } }, "sha512-3mKY4dP8I7yKPFj9VKpYyCRzGJOi5CEpOLPlRhoJyLmgs3J4RzDrjn323Oakjz2Aj2JzRU/AIvWRAZVhpYNJHw=="], 91 189 92 92 - "@atproto/api": ["@atproto/api@0.17.7", "", { "dependencies": { "@atproto/common-web": "^0.4.3", "@atproto/lexicon": "^0.5.1", "@atproto/syntax": "^0.4.1", "@atproto/xrpc": "^0.7.5", "await-lock": "^2.2.2", "multiformats": "^9.9.0", "tlds": "^1.234.0", "zod": "^3.23.8" } }, "sha512-V+OJBZq9chcrD21xk1bUa6oc5DSKfQj5DmUPf5rmZncqL1w9ZEbS38H5cMyqqdhfgo2LWeDRdZHD0rvNyJsIaw=="], 190 190 + "@atproto/api": ["@atproto/api@0.14.22", "", { "dependencies": { "@atproto/common-web": "^0.4.1", "@atproto/lexicon": "^0.4.10", "@atproto/syntax": "^0.4.0", "@atproto/xrpc": "^0.6.12", "await-lock": "^2.2.2", "multiformats": "^9.9.0", "tlds": "^1.234.0", "zod": "^3.23.8" } }, "sha512-ziXPau+sUdFovObSnsoN7JbOmUw1C5e5L28/yXf3P8vbEnSS3HVVGD1jYcscBYY34xQqi4bVDpwMYx/4yRsTuQ=="], 93 191 94 192 "@atproto/common": ["@atproto/common@0.4.12", "", { "dependencies": { "@atproto/common-web": "^0.4.3", "@ipld/dag-cbor": "^7.0.3", "cbor-x": "^1.5.1", "iso-datestring-validator": "^2.2.2", "multiformats": "^9.9.0", "pino": "^8.21.0" } }, "sha512-NC+TULLQiqs6MvNymhQS5WDms3SlbIKGLf4n33tpftRJcalh507rI+snbcUb7TLIkKw7VO17qMqxEXtIdd5auQ=="], 95 193 ··· 98 196 "@atproto/crypto": ["@atproto/crypto@0.4.4", "", { "dependencies": { "@noble/curves": "^1.7.0", "@noble/hashes": "^1.6.1", "uint8arrays": "3.0.0" } }, "sha512-Yq9+crJ7WQl7sxStVpHgie5Z51R05etaK9DLWYG/7bR5T4bhdcIgF6IfklLShtZwLYdVVj+K15s0BqW9a8PSDA=="], 99 197 100 198 "@atproto/did": ["@atproto/did@0.2.1", "", { "dependencies": { "zod": "^3.23.8" } }, "sha512-1i5BTU2GnBaaeYWhxUOnuEKFVq9euT5+dQPFabHpa927BlJ54PmLGyBBaOI7/NbLmN5HWwBa18SBkMpg3jGZRA=="], 199 199 + 200 200 + "@atproto/identity": ["@atproto/identity@0.4.10", "", { "dependencies": { "@atproto/common-web": "^0.4.4", "@atproto/crypto": "^0.4.4" } }, "sha512-nQbzDLXOhM8p/wo0cTh5DfMSOSHzj6jizpodX37LJ4S1TZzumSxAjHEZa5Rev3JaoD5uSWMVE0MmKEGWkPPvfQ=="], 101 201 102 202 "@atproto/jwk": ["@atproto/jwk@0.6.0", "", { "dependencies": { "multiformats": "^9.9.0", "zod": "^3.23.8" } }, "sha512-bDoJPvt7TrQVi/rBfBrSSpGykhtIriKxeYCYQTiPRKFfyRhbgpElF0wPXADjIswnbzZdOwbY63az4E/CFVT3Tw=="], 103 203 ··· 105 205 106 206 "@atproto/jwk-webcrypto": ["@atproto/jwk-webcrypto@0.2.0", "", { "dependencies": { "@atproto/jwk": "0.6.0", "@atproto/jwk-jose": "0.1.11", "zod": "^3.23.8" } }, "sha512-UmgRrrEAkWvxwhlwe30UmDOdTEFidlIzBC7C3cCbeJMcBN1x8B3KH+crXrsTqfWQBG58mXgt8wgSK3Kxs2LhFg=="], 107 207 208 208 + "@atproto/lex-cbor": ["@atproto/lex-cbor@0.0.1", "", { "dependencies": { "@atproto/lex-data": "0.0.1", "multiformats": "^9.9.0", "tslib": "^2.8.1" } }, "sha512-GCgowcC041tYmsoIxalIECJq4ZRHgREk6lFa4BzNRUZarMqwz57YF/7eUlo2Q6hoaMUL7Bjr6FvXwcZFaKrhvA=="], 209 209 + 108 210 "@atproto/lex-cli": ["@atproto/lex-cli@0.9.6", "", { "dependencies": { "@atproto/lexicon": "^0.5.1", "@atproto/syntax": "^0.4.1", "chalk": "^4.1.2", "commander": "^9.4.0", "prettier": "^3.2.5", "ts-morph": "^24.0.0", "yesno": "^0.4.0", "zod": "^3.23.8" }, "bin": { "lex": "dist/index.js" } }, "sha512-EedEKmURoSP735YwSDHsFrLOhZ4P2it8goCHv5ApWi/R9DFpOKOpmYfIXJ9MAprK8cw+yBnjDJbzpLJy7UXlTg=="], 109 211 110 110 - "@atproto/lexicon": ["@atproto/lexicon@0.5.1", "", { "dependencies": { "@atproto/common-web": "^0.4.3", "@atproto/syntax": "^0.4.1", "iso-datestring-validator": "^2.2.2", "multiformats": "^9.9.0", "zod": "^3.23.8" } }, "sha512-y8AEtYmfgVl4fqFxqXAeGvhesiGkxiy3CWoJIfsFDDdTlZUC8DFnZrYhcqkIop3OlCkkljvpSJi1hbeC1tbi8A=="], 212 212 + "@atproto/lex-data": ["@atproto/lex-data@0.0.1", "", { "dependencies": { "@atproto/syntax": "0.4.1", "multiformats": "^9.9.0", "tslib": "^2.8.1", "uint8arrays": "3.0.0", "unicode-segmenter": "^0.14.0" } }, "sha512-DrS/8cQcQs3s5t9ELAFNtyDZ8/PdiCx47ALtFEP2GnX2uCBHZRkqWG7xmu6ehjc787nsFzZBvlnz3T/gov5fGA=="], 213 213 + 214 214 + "@atproto/lex-json": ["@atproto/lex-json@0.0.1", "", { "dependencies": { "@atproto/lex-data": "0.0.1", "tslib": "^2.8.1" } }, "sha512-ivcF7+pDRuD/P97IEKQ/9TruunXj0w58Khvwk3M6psaI5eZT6LRsRZ4cWcKaXiFX4SHnjy+x43g0f7pPtIsERg=="], 215 215 + 216 216 + "@atproto/lexicon": ["@atproto/lexicon@0.5.2", "", { "dependencies": { "@atproto/common-web": "^0.4.4", "@atproto/syntax": "^0.4.1", "iso-datestring-validator": "^2.2.2", "multiformats": "^9.9.0", "zod": "^3.23.8" } }, "sha512-lRmJgMA8f5j7VB5Iu5cp188ald5FuI4FlmZ7nn6EBrk1dgOstWVrI5Ft6K3z2vjyLZRG6nzknlsw+tDP63p7bQ=="], 111 217 112 218 "@atproto/oauth-client": ["@atproto/oauth-client@0.5.8", "", { "dependencies": { "@atproto-labs/did-resolver": "0.2.2", "@atproto-labs/fetch": "0.2.3", "@atproto-labs/handle-resolver": "0.3.2", "@atproto-labs/identity-resolver": "0.3.2", "@atproto-labs/simple-store": "0.3.0", "@atproto-labs/simple-store-memory": "0.1.4", "@atproto/did": "0.2.1", "@atproto/jwk": "0.6.0", "@atproto/oauth-types": "0.5.0", "@atproto/xrpc": "0.7.5", "core-js": "^3", "multiformats": "^9.9.0", "zod": "^3.23.8" } }, "sha512-7YEym6d97+Dd73qGdkQTXi5La8xvCQxwRUDzzlR/NVAARa9a4YP7MCmqBJVeP2anT0By+DSAPyPDLTsxcjIcCg=="], 113 219 ··· 115 221 116 222 "@atproto/oauth-types": ["@atproto/oauth-types@0.5.0", "", { "dependencies": { "@atproto/did": "0.2.1", "@atproto/jwk": "0.6.0", "zod": "^3.23.8" } }, "sha512-33xz7HcXhbl+XRqbIMVu3GE02iK1nKe2oMWENASsfZEYbCz2b9ZOarOFuwi7g4LKqpGowGp0iRKsQHFcq4SDaQ=="], 117 223 224 224 + "@atproto/repo": ["@atproto/repo@0.8.11", "", { "dependencies": { "@atproto/common": "^0.5.0", "@atproto/common-web": "^0.4.4", "@atproto/crypto": "^0.4.4", "@atproto/lexicon": "^0.5.2", "@ipld/dag-cbor": "^7.0.0", "multiformats": "^9.9.0", "uint8arrays": "3.0.0", "varint": "^6.0.0", "zod": "^3.23.8" } }, "sha512-b/WCu5ITws4ILHoXiZz0XXB5U9C08fUVzkBQDwpnme62GXv8gUaAPL/ttG61OusW09ARwMMQm4vxoP0hTFg+zA=="], 225 225 + 226 226 + "@atproto/sync": ["@atproto/sync@0.1.38", "", { "dependencies": { "@atproto/common": "^0.5.0", "@atproto/identity": "^0.4.10", "@atproto/lexicon": "^0.5.2", "@atproto/repo": "^0.8.11", "@atproto/syntax": "^0.4.1", "@atproto/xrpc-server": "^0.10.0", "multiformats": "^9.9.0", "p-queue": "^6.6.2", "ws": "^8.12.0" } }, "sha512-2rE0SM21Nk4hWw/XcIYFnzlWO6/gBg8mrzuWbOvDhD49sA/wW4zyjaHZ5t1gvk28/SLok2VZiIR8nYBdbf7F5Q=="], 227 227 + 118 228 "@atproto/syntax": ["@atproto/syntax@0.4.1", "", {}, "sha512-CJdImtLAiFO+0z3BWTtxwk6aY5w4t8orHTMVJgkf++QRJWTxPbIFko/0hrkADB7n2EruDxDSeAgfUGehpH6ngw=="], 229 229 + 230 230 + "@atproto/ws-client": ["@atproto/ws-client@0.0.3", "", { "dependencies": { "@atproto/common": "^0.5.0", "ws": "^8.12.0" } }, "sha512-eKqkTWBk6zuMY+6gs02eT7mS8Btewm8/qaL/Dp00NDCqpNC+U59MWvQsOWT3xkNGfd9Eip+V6VI4oyPvAfsfTA=="], 119 231 120 232 "@atproto/xrpc": ["@atproto/xrpc@0.7.5", "", { "dependencies": { "@atproto/lexicon": "^0.5.1", "zod": "^3.23.8" } }, "sha512-MUYNn5d2hv8yVegRL0ccHvTHAVj5JSnW07bkbiaz96UH45lvYNRVwt44z+yYVnb0/mvBzyD3/ZQ55TRGt7fHkA=="], 121 233 ··· 202 314 "@grpc/grpc-js": ["@grpc/grpc-js@1.14.1", "", { "dependencies": { "@grpc/proto-loader": "^0.8.0", "@js-sdsl/ordered-map": "^4.4.2" } }, "sha512-sPxgEWtPUR3EnRJCEtbGZG2iX8LQDUls2wUS3o27jg07KqJFMq6YDeWvMo1wfpmy3rqRdS0rivpLwhqQtEyCuQ=="], 203 315 204 316 "@grpc/proto-loader": ["@grpc/proto-loader@0.8.0", "", { "dependencies": { "lodash.camelcase": "^4.3.0", "long": "^5.0.0", "protobufjs": "^7.5.3", "yargs": "^17.7.2" }, "bin": { "proto-loader-gen-types": "build/bin/proto-loader-gen-types.js" } }, "sha512-rc1hOQtjIWGxcxpb9aHAfLpIctjEnsDehj0DAiVfBlmT84uvR0uUtN2hEi/ecvWVjXUGf5qPF4qEgiLOx1YIMQ=="], 317 317 + 318 318 + "@hono/node-server": ["@hono/node-server@1.19.6", "", { "peerDependencies": { "hono": "^4" } }, "sha512-Shz/KjlIeAhfiuE93NDKVdZ7HdBVLQAfdbaXEaoAVO3ic9ibRSLGIQGkcBbFyuLr+7/1D5ZCINM8B+6IvXeMtw=="], 205 319 206 320 "@ipld/dag-cbor": ["@ipld/dag-cbor@7.0.3", "", { "dependencies": { "cborg": "^1.6.0", "multiformats": "^9.5.4" } }, "sha512-1VVh2huHsuohdXC1bGJNE8WR72slZ9XE2T3wbBBq31dm7ZBatmKLLxrB+XAqafxfRFjv08RZmj/W/ZqaM13AuA=="], 207 321 ··· 375 489 376 490 "@ts-morph/common": ["@ts-morph/common@0.25.0", "", { "dependencies": { "minimatch": "^9.0.4", "path-browserify": "^1.0.1", "tinyglobby": "^0.2.9" } }, "sha512-kMnZz+vGGHi4GoHnLmMhGNjm44kGtKUXGnOvrKmMwAuvNjM/PgKVGfUnL7IDvK7Jb2QQ82jq3Zmp04Gy+r3Dkg=="], 377 491 378 378 - "@types/node": ["@types/node@24.10.0", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-qzQZRBqkFsYyaSWXuEHc2WR9c0a0CXwiE5FWUvn7ZM+vdy1uZLfCunD38UzhuB7YN/J11ndbDBcTmOdxJo9Q7A=="], 492 492 + "@types/bun": ["@types/bun@1.3.3", "", { "dependencies": { "bun-types": "1.3.3" } }, "sha512-ogrKbJ2X5N0kWLLFKeytG0eHDleBYtngtlbu9cyBKFtNL3cnpDZkNdQj8flVf6WTZUX5ulI9AY1oa7ljhSrp+g=="], 493 493 + 494 494 + "@types/mime-types": ["@types/mime-types@2.1.4", "", {}, "sha512-lfU4b34HOri+kAY5UheuFMWPDOI+OPceBSHZKp69gEyTL/mmJ4cnU6Y/rlme3UL3GyOn6Y42hyIEw0/q8sWx5w=="], 495 495 + 496 496 + "@types/node": ["@types/node@22.19.1", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-LCCV0HdSZZZb34qifBsyWlUmok6W7ouER+oQIGBScS8EsZsQbrtFTUrDX4hOl+CS6p7cnNC4td+qrSVGSCTUfQ=="], 379 497 380 498 "@types/react": ["@types/react@19.2.2", "", { "dependencies": { "csstype": "^3.0.2" } }, "sha512-6mDvHUFSjyT2B2yeNx2nUgMxh9LtOWvkhIU3uePn2I2oyNymUAX1NIsdgviM4CH+JSrp2D2hsMvJOkxY+0wNRA=="], 381 499 ··· 383 501 384 502 "@types/shimmer": ["@types/shimmer@1.2.0", "", {}, "sha512-UE7oxhQLLd9gub6JKIAhDq06T0F6FnztwMNRvYgjeQSBeMc1ZG/tA47EwfduvkuQS8apbkM/lpLpWsaCeYsXVg=="], 385 503 504 504 + "@wisp/atproto-utils": ["@wisp/atproto-utils@workspace:packages/@wisp/atproto-utils"], 505 505 + 506 506 + "@wisp/constants": ["@wisp/constants@workspace:packages/@wisp/constants"], 507 507 + 508 508 + "@wisp/database": ["@wisp/database@workspace:packages/@wisp/database"], 509 509 + 510 510 + "@wisp/fs-utils": ["@wisp/fs-utils@workspace:packages/@wisp/fs-utils"], 511 511 + 512 512 + "@wisp/lexicons": ["@wisp/lexicons@workspace:packages/@wisp/lexicons"], 513 513 + 514 514 + "@wisp/main-app": ["@wisp/main-app@workspace:apps/main-app"], 515 515 + 516 516 + "@wisp/observability": ["@wisp/observability@workspace:packages/@wisp/observability"], 517 517 + 518 518 + "@wisp/safe-fetch": ["@wisp/safe-fetch@workspace:packages/@wisp/safe-fetch"], 519 519 + 386 520 "abort-controller": ["abort-controller@3.0.0", "", { "dependencies": { "event-target-shim": "^5.0.0" } }, "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg=="], 387 521 388 522 "accepts": ["accepts@1.3.8", "", { "dependencies": { "mime-types": "~2.1.34", "negotiator": "0.6.3" } }, "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw=="], ··· 421 555 422 556 "bun-plugin-tailwind": ["bun-plugin-tailwind@0.1.2", "", { "peerDependencies": { "bun": ">=1.0.0" } }, "sha512-41jNC1tZRSK3s1o7pTNrLuQG8kL/0vR/JgiTmZAJ1eHwe0w5j6HFPKeqEk0WAD13jfrUC7+ULuewFBBCoADPpg=="], 423 557 424 424 - "bun-types": ["bun-types@1.3.2", "", { "dependencies": { "@types/node": "*" }, "peerDependencies": { "@types/react": "^19" } }, "sha512-i/Gln4tbzKNuxP70OWhJRZz1MRfvqExowP7U6JKoI8cntFrtxg7RJK3jvz7wQW54UuvNC8tbKHHri5fy74FVqg=="], 558 558 + "bun-types": ["bun-types@1.3.3", "", { "dependencies": { "@types/node": "*" } }, "sha512-z3Xwlg7j2l9JY27x5Qn3Wlyos8YAp0kKRlrePAOjgjMGS5IG6E7Jnlx736vH9UVI4wUICwwhC9anYL++XeOgTQ=="], 425 559 426 560 "bytes": ["bytes@3.1.2", "", {}, "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg=="], 427 561 ··· 479 613 480 614 "ee-first": ["ee-first@1.1.1", "", {}, "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="], 481 615 482 482 - "elysia": ["elysia@1.4.15", "", { "dependencies": { "cookie": "^1.0.2", "exact-mirror": "0.2.2", "fast-decode-uri-component": "^1.0.1", "memoirist": "^0.4.0" }, "peerDependencies": { "@sinclair/typebox": ">= 0.34.0 < 1", "@types/bun": ">= 1.2.0", "file-type": ">= 20.0.0", "openapi-types": ">= 12.0.0", "typescript": ">= 5.0.0" }, "optionalPeers": ["@types/bun", "typescript"] }, "sha512-RaDqqZdLuC4UJetfVRQ4Z5aVpGgEtQ+pZnsbI4ZzEaf3l/MzuHcqSVoL/Fue3d6qE4RV9HMB2rAZaHyPIxkyzg=="], 616 616 + "elysia": ["elysia@1.4.16", "", { "dependencies": { "cookie": "^1.0.2", "exact-mirror": "0.2.3", "fast-decode-uri-component": "^1.0.1", "memoirist": "^0.4.0" }, "peerDependencies": { "@sinclair/typebox": ">= 0.34.0 < 1", "@types/bun": ">= 1.2.0", "file-type": ">= 20.0.0", "openapi-types": ">= 12.0.0", "typescript": ">= 5.0.0" }, "optionalPeers": ["@types/bun", "typescript"] }, "sha512-KZtKN160/bdWVKg2hEgyoNXY8jRRquc+m6PboyisaLZL891I+Ufb7Ja6lDAD7vMQur8sLEWIcidZOzj5lWw9UA=="], 483 617 484 618 "emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="], 485 619 ··· 502 636 "etag": ["etag@1.8.1", "", {}, "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg=="], 503 637 504 638 "event-target-shim": ["event-target-shim@5.0.1", "", {}, "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ=="], 639 639 + 640 640 + "eventemitter3": ["eventemitter3@4.0.7", "", {}, "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw=="], 505 641 506 642 "events": ["events@3.3.0", "", {}, "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q=="], 507 643 508 508 - "exact-mirror": ["exact-mirror@0.2.2", "", { "peerDependencies": { "@sinclair/typebox": "^0.34.15" }, "optionalPeers": ["@sinclair/typebox"] }, "sha512-CrGe+4QzHZlnrXZVlo/WbUZ4qQZq8C0uATQVGVgXIrNXgHDBBNFD1VRfssRA2C9t3RYvh3MadZSdg2Wy7HBoQA=="], 644 644 + "exact-mirror": ["exact-mirror@0.2.3", "", { "peerDependencies": { "@sinclair/typebox": "^0.34.15" }, "optionalPeers": ["@sinclair/typebox"] }, "sha512-aLdARfO0W0ntufjDyytUJQMbNXoB9g+BbA8KcgIq4XOOTYRw48yUGON/Pr64iDrYNZKcKvKbqE0MPW56FF2BXA=="], 509 645 510 646 "express": ["express@4.21.2", "", { "dependencies": { "accepts": "~1.3.8", "array-flatten": "1.1.1", "body-parser": "1.20.3", "content-disposition": "0.5.4", "content-type": "~1.0.4", "cookie": "0.7.1", "cookie-signature": "1.0.6", "debug": "2.6.9", "depd": "2.0.0", "encodeurl": "~2.0.0", "escape-html": "~1.0.3", "etag": "~1.8.1", "finalhandler": "1.3.1", "fresh": "0.5.2", "http-errors": "2.0.0", "merge-descriptors": "1.0.3", "methods": "~1.1.2", "on-finished": "2.4.1", "parseurl": "~1.3.3", "path-to-regexp": "0.1.12", "proxy-addr": "~2.0.7", "qs": "6.13.0", "range-parser": "~1.2.1", "safe-buffer": "5.2.1", "send": "0.19.0", "serve-static": "1.16.2", "setprototypeof": "1.2.0", "statuses": "2.0.1", "type-is": "~1.6.18", "utils-merge": "1.0.1", "vary": "~1.1.2" } }, "sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA=="], 511 647 ··· 536 672 "get-nonce": ["get-nonce@1.0.1", "", {}, "sha512-FJhYRoDaiatfEkUK8HKlicmu/3SGFD51q3itKDGoSTysQJBnfOcxU5GxnhE1E6soB76MbT0MBtnKJuXyAx+96Q=="], 537 673 538 674 "get-proto": ["get-proto@1.0.1", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" } }, "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g=="], 675 675 + 676 676 + "get-tsconfig": ["get-tsconfig@4.13.0", "", { "dependencies": { "resolve-pkg-maps": "^1.0.0" } }, "sha512-1VKTZJCwBrvbd+Wn3AOgQP/2Av+TfTCOlE4AcRJE72W1ksZXbAx8PPBR9RzgTeSPzlPMHrbANMH3LbltH73wxQ=="], 539 677 540 678 "gopd": ["gopd@1.2.0", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="], 541 679 ··· 547 685 548 686 "hasown": ["hasown@2.0.2", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ=="], 549 687 688 688 + "hono": ["hono@4.10.6", "", {}, "sha512-BIdolzGpDO9MQ4nu3AUuDwHZZ+KViNm+EZ75Ae55eMXMqLVhDFqEMXxtUe9Qh8hjL+pIna/frs2j6Y2yD5Ua/g=="], 689 689 + 550 690 "http-errors": ["http-errors@2.0.0", "", { "dependencies": { "depd": "2.0.0", "inherits": "2.0.4", "setprototypeof": "1.2.0", "statuses": "2.0.1", "toidentifier": "1.0.1" } }, "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ=="], 551 691 552 692 "iconv-lite": ["iconv-lite@0.4.24", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3" } }, "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA=="], ··· 557 697 558 698 "inherits": ["inherits@2.0.4", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="], 559 699 560 560 - "ipaddr.js": ["ipaddr.js@2.2.0", "", {}, "sha512-Ag3wB2o37wslZS19hZqorUnrnzSkpOVy+IiiDEiTqNubEYpYuHWIf6K4psgN2ZWKExS4xhVCrRVfb/wfW8fWJA=="], 700 700 + "ipaddr.js": ["ipaddr.js@1.9.1", "", {}, "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g=="], 561 701 562 702 "iron-session": ["iron-session@8.0.4", "", { "dependencies": { "cookie": "^0.7.2", "iron-webcrypto": "^1.2.1", "uncrypto": "^0.1.3" } }, "sha512-9ivNnaKOd08osD0lJ3i6If23GFS2LsxyMU8Gf/uBUEgm8/8CC1hrrCHFDpMo3IFbpBgwoo/eairRsaD3c5itxA=="], 563 703 ··· 614 754 "on-finished": ["on-finished@2.4.1", "", { "dependencies": { "ee-first": "1.1.1" } }, "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg=="], 615 755 616 756 "openapi-types": ["openapi-types@12.1.3", "", {}, "sha512-N4YtSYJqghVu4iek2ZUvcN/0aqH1kRDuNqzcycDxhOUpg7GdvLa2F3DgS6yBNhInhv2r/6I0Flkn7CqL8+nIcw=="], 757 757 + 758 758 + "p-finally": ["p-finally@1.0.0", "", {}, "sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow=="], 759 759 + 760 760 + "p-queue": ["p-queue@6.6.2", "", { "dependencies": { "eventemitter3": "^4.0.4", "p-timeout": "^3.2.0" } }, "sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ=="], 761 761 + 762 762 + "p-timeout": ["p-timeout@3.2.0", "", { "dependencies": { "p-finally": "^1.0.0" } }, "sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg=="], 617 763 618 764 "parseurl": ["parseurl@1.3.3", "", {}, "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ=="], 619 765 ··· 635 781 636 782 "playwright-core": ["playwright-core@1.56.1", "", { "bin": { "playwright-core": "cli.js" } }, "sha512-hutraynyn31F+Bifme+Ps9Vq59hKuUCz7H1kDOcBs+2oGguKkWTU50bBWrtz34OUWmIwpBTWDxaRPXrIXkgvmQ=="], 637 783 784 784 + "postgres": ["postgres@3.4.7", "", {}, "sha512-Jtc2612XINuBjIl/QTWsV5UvE8UHuNblcO3vVADSrKsrc6RqGX6lOW1cEo3CM2v0XG4Nat8nI+YM7/f26VxXLw=="], 785 785 + 638 786 "prettier": ["prettier@3.6.2", "", { "bin": { "prettier": "bin/prettier.cjs" } }, "sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ=="], 639 787 640 788 "prismjs": ["prismjs@1.30.0", "", {}, "sha512-DEvV2ZF2r2/63V+tK8hQvrR2ZGn10srHbXviTlcv7Kpzw8jWiNTqbVgjO3IY8RxrrOUF8VPMQQFysYYYv0YZxw=="], ··· 676 824 "require-in-the-middle": ["require-in-the-middle@7.5.2", "", { "dependencies": { "debug": "^4.3.5", "module-details-from-path": "^1.0.3", "resolve": "^1.22.8" } }, "sha512-gAZ+kLqBdHarXB64XpAe2VCjB7rIRv+mU8tfRWziHRJ5umKsIHN2tLLv6EtMw7WCdP19S0ERVMldNvxYCHnhSQ=="], 677 825 678 826 "resolve": ["resolve@1.22.11", "", { "dependencies": { "is-core-module": "^2.16.1", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": { "resolve": "bin/resolve" } }, "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ=="], 827 827 + 828 828 + "resolve-pkg-maps": ["resolve-pkg-maps@1.0.0", "", {}, "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw=="], 679 829 680 830 "safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="], 681 831 ··· 737 887 738 888 "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="], 739 889 890 890 + "tsx": ["tsx@4.20.6", "", { "dependencies": { "esbuild": "~0.25.0", "get-tsconfig": "^4.7.5" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "bin": { "tsx": "dist/cli.mjs" } }, "sha512-ytQKuwgmrrkDTFP4LjR0ToE2nqgy886GpvRSpU0JAnrdBYppuY5rLkRUYPU1yCryb24SsKBTL/hlDQAEFVwtZg=="], 891 891 + 740 892 "tw-animate-css": ["tw-animate-css@1.4.0", "", {}, "sha512-7bziOlRqH0hJx80h/3mbicLW7o8qLsH5+RaLR2t+OHM3D0JlWGODQKQ4cxbK7WlvmUxpcj6Kgu6EKqjrGFe3QQ=="], 741 893 742 894 "type-is": ["type-is@1.6.18", "", { "dependencies": { "media-typer": "0.3.0", "mime-types": "~2.1.24" } }, "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g=="], ··· 751 903 752 904 "undici": ["undici@6.22.0", "", {}, "sha512-hU/10obOIu62MGYjdskASR3CUAiYaFTtC9Pa6vHyf//mAipSvSQg6od2CnJswq7fvzNS3zJhxoRkgNVaHurWKw=="], 753 905 754 754 - "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="], 906 906 + "undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="], 907 907 + 908 908 + "unicode-segmenter": ["unicode-segmenter@0.14.0", "", {}, "sha512-AH4lhPCJANUnSLEKnM4byboctePJzltF4xj8b+NbNiYeAkAXGh7px2K/4NANFp7dnr6+zB3e6HLu8Jj8SKyvYg=="], 755 909 756 910 "unpipe": ["unpipe@1.0.0", "", {}, "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ=="], 757 911 ··· 761 915 762 916 "utils-merge": ["utils-merge@1.0.1", "", {}, "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA=="], 763 917 918 918 + "varint": ["varint@6.0.0", "", {}, "sha512-cXEIW6cfr15lFv563k4GuVuW/fiwjknytD37jIOLSdSWuOI6WnO/oKwmP2FQTU2l01LP8/M5TSAJpzUaGe3uWg=="], 919 919 + 764 920 "vary": ["vary@1.1.2", "", {}, "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg=="], 921 921 + 922 922 + "wisp-hosting-service": ["wisp-hosting-service@workspace:apps/hosting-service"], 765 923 766 924 "wrap-ansi": ["wrap-ansi@7.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="], 767 925 ··· 779 937 780 938 "zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="], 781 939 940 940 + "@atproto-labs/fetch-node/ipaddr.js": ["ipaddr.js@2.2.0", "", {}, "sha512-Ag3wB2o37wslZS19hZqorUnrnzSkpOVy+IiiDEiTqNubEYpYuHWIf6K4psgN2ZWKExS4xhVCrRVfb/wfW8fWJA=="], 941 941 + 942 942 + "@atproto/api/@atproto/lexicon": ["@atproto/lexicon@0.4.14", "", { "dependencies": { "@atproto/common-web": "^0.4.2", "@atproto/syntax": "^0.4.0", "iso-datestring-validator": "^2.2.2", "multiformats": "^9.9.0", "zod": "^3.23.8" } }, "sha512-jiKpmH1QER3Gvc7JVY5brwrfo+etFoe57tKPQX/SmPwjvUsFnJAow5xLIryuBaJgFAhnTZViXKs41t//pahGHQ=="], 943 943 + 944 944 + "@atproto/api/@atproto/xrpc": ["@atproto/xrpc@0.6.12", "", { "dependencies": { "@atproto/lexicon": "^0.4.10", "zod": "^3.23.8" } }, "sha512-Ut3iISNLujlmY9Gu8sNU+SPDJDvqlVzWddU8qUr0Yae5oD4SguaUFjjhireMGhQ3M5E0KljQgDbTmnBo1kIZ3w=="], 945 945 + 782 946 "@atproto/api/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 783 947 784 948 "@atproto/common/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 785 949 786 950 "@atproto/common-web/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 787 951 952 952 + "@atproto/identity/@atproto/common-web": ["@atproto/common-web@0.4.5", "", { "dependencies": { "@atproto/lex-data": "0.0.1", "@atproto/lex-json": "0.0.1", "zod": "^3.23.8" } }, "sha512-Tx0xUafLm3vRvOQpbBl5eb9V8xlC7TaRXs6dAulHRkDG3Kb+P9qn3pkDteq+aeMshbVXbVa1rm3Ok4vFyuoyYA=="], 953 953 + 788 954 "@atproto/jwk/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 789 955 956 956 + "@atproto/lex-cbor/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 957 957 + 958 958 + "@atproto/lex-cli/@atproto/lexicon": ["@atproto/lexicon@0.5.1", "", { "dependencies": { "@atproto/common-web": "^0.4.3", "@atproto/syntax": "^0.4.1", "iso-datestring-validator": "^2.2.2", "multiformats": "^9.9.0", "zod": "^3.23.8" } }, "sha512-y8AEtYmfgVl4fqFxqXAeGvhesiGkxiy3CWoJIfsFDDdTlZUC8DFnZrYhcqkIop3OlCkkljvpSJi1hbeC1tbi8A=="], 959 959 + 960 960 + "@atproto/lex-data/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 961 961 + 962 962 + "@atproto/lexicon/@atproto/common-web": ["@atproto/common-web@0.4.5", "", { "dependencies": { "@atproto/lex-data": "0.0.1", "@atproto/lex-json": "0.0.1", "zod": "^3.23.8" } }, "sha512-Tx0xUafLm3vRvOQpbBl5eb9V8xlC7TaRXs6dAulHRkDG3Kb+P9qn3pkDteq+aeMshbVXbVa1rm3Ok4vFyuoyYA=="], 963 963 + 790 964 "@atproto/lexicon/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 791 965 792 966 "@atproto/oauth-client/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 793 967 968 968 + "@atproto/repo/@atproto/common": ["@atproto/common@0.5.1", "", { "dependencies": { "@atproto/common-web": "^0.4.5", "@atproto/lex-cbor": "0.0.1", "@atproto/lex-data": "0.0.1", "iso-datestring-validator": "^2.2.2", "multiformats": "^9.9.0", "pino": "^8.21.0" } }, "sha512-0S57sjzw4r9OLc5srJFi6uAz/aTKYl6btz3x36tSnGriL716m6h0x2IVtgd+FhUfIQfisevrqcqw8SfaGk8VTw=="], 969 969 + 970 970 + "@atproto/repo/@atproto/common-web": ["@atproto/common-web@0.4.5", "", { "dependencies": { "@atproto/lex-data": "0.0.1", "@atproto/lex-json": "0.0.1", "zod": "^3.23.8" } }, "sha512-Tx0xUafLm3vRvOQpbBl5eb9V8xlC7TaRXs6dAulHRkDG3Kb+P9qn3pkDteq+aeMshbVXbVa1rm3Ok4vFyuoyYA=="], 971 971 + 972 972 + "@atproto/repo/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 973 973 + 974 974 + "@atproto/sync/@atproto/common": ["@atproto/common@0.5.1", "", { "dependencies": { "@atproto/common-web": "^0.4.5", "@atproto/lex-cbor": "0.0.1", "@atproto/lex-data": "0.0.1", "iso-datestring-validator": "^2.2.2", "multiformats": "^9.9.0", "pino": "^8.21.0" } }, "sha512-0S57sjzw4r9OLc5srJFi6uAz/aTKYl6btz3x36tSnGriL716m6h0x2IVtgd+FhUfIQfisevrqcqw8SfaGk8VTw=="], 975 975 + 976 976 + "@atproto/sync/@atproto/xrpc-server": ["@atproto/xrpc-server@0.10.1", "", { "dependencies": { "@atproto/common": "^0.5.1", "@atproto/crypto": "^0.4.4", "@atproto/lex-cbor": "0.0.1", "@atproto/lex-data": "0.0.1", "@atproto/lexicon": "^0.5.2", "@atproto/ws-client": "^0.0.3", "@atproto/xrpc": "^0.7.6", "express": "^4.17.2", "http-errors": "^2.0.0", "mime-types": "^2.1.35", "rate-limiter-flexible": "^2.4.1", "ws": "^8.12.0", "zod": "^3.23.8" } }, "sha512-kHXykL4inBV/49vefn5zR5zv/VM1//+BIRqk9OvB3+mbERw0jkFiHhc6PWyY/81VD4ciu7FZwUCpRy/mtQtIaA=="], 977 977 + 978 978 + "@atproto/sync/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 979 979 + 980 980 + "@atproto/ws-client/@atproto/common": ["@atproto/common@0.5.1", "", { "dependencies": { "@atproto/common-web": "^0.4.5", "@atproto/lex-cbor": "0.0.1", "@atproto/lex-data": "0.0.1", "iso-datestring-validator": "^2.2.2", "multiformats": "^9.9.0", "pino": "^8.21.0" } }, "sha512-0S57sjzw4r9OLc5srJFi6uAz/aTKYl6btz3x36tSnGriL716m6h0x2IVtgd+FhUfIQfisevrqcqw8SfaGk8VTw=="], 981 981 + 982 982 + "@atproto/xrpc/@atproto/lexicon": ["@atproto/lexicon@0.5.1", "", { "dependencies": { "@atproto/common-web": "^0.4.3", "@atproto/syntax": "^0.4.1", "iso-datestring-validator": "^2.2.2", "multiformats": "^9.9.0", "zod": "^3.23.8" } }, "sha512-y8AEtYmfgVl4fqFxqXAeGvhesiGkxiy3CWoJIfsFDDdTlZUC8DFnZrYhcqkIop3OlCkkljvpSJi1hbeC1tbi8A=="], 983 983 + 984 984 + "@atproto/xrpc-server/@atproto/lexicon": ["@atproto/lexicon@0.5.1", "", { "dependencies": { "@atproto/common-web": "^0.4.3", "@atproto/syntax": "^0.4.1", "iso-datestring-validator": "^2.2.2", "multiformats": "^9.9.0", "zod": "^3.23.8" } }, "sha512-y8AEtYmfgVl4fqFxqXAeGvhesiGkxiy3CWoJIfsFDDdTlZUC8DFnZrYhcqkIop3OlCkkljvpSJi1hbeC1tbi8A=="], 985 985 + 794 986 "@ipld/dag-cbor/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 795 987 796 988 "@radix-ui/react-collection/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="], ··· 802 994 "@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="], 803 995 804 996 "@tokenizer/inflate/debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="], 997 997 + 998 998 + "@wisp/main-app/@atproto/api": ["@atproto/api@0.17.7", "", { "dependencies": { "@atproto/common-web": "^0.4.3", "@atproto/lexicon": "^0.5.1", "@atproto/syntax": "^0.4.1", "@atproto/xrpc": "^0.7.5", "await-lock": "^2.2.2", "multiformats": "^9.9.0", "tlds": "^1.234.0", "zod": "^3.23.8" } }, "sha512-V+OJBZq9chcrD21xk1bUa6oc5DSKfQj5DmUPf5rmZncqL1w9ZEbS38H5cMyqqdhfgo2LWeDRdZHD0rvNyJsIaw=="], 999 999 + 1000 1000 + "bun-types/@types/node": ["@types/node@24.10.0", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-qzQZRBqkFsYyaSWXuEHc2WR9c0a0CXwiE5FWUvn7ZM+vdy1uZLfCunD38UzhuB7YN/J11ndbDBcTmOdxJo9Q7A=="], 805 1001 806 1002 "express/cookie": ["cookie@0.7.1", "", {}, "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w=="], 807 1003 808 1004 "iron-session/cookie": ["cookie@0.7.2", "", {}, "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w=="], 809 1005 810 810 - "proxy-addr/ipaddr.js": ["ipaddr.js@1.9.1", "", {}, "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g=="], 1006 1006 + "protobufjs/@types/node": ["@types/node@24.10.0", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-qzQZRBqkFsYyaSWXuEHc2WR9c0a0CXwiE5FWUvn7ZM+vdy1uZLfCunD38UzhuB7YN/J11ndbDBcTmOdxJo9Q7A=="], 811 1007 812 1008 "require-in-the-middle/debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="], 813 1009 ··· 815 1011 816 1012 "send/ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="], 817 1013 1014 1014 + "tsx/esbuild": ["esbuild@0.25.12", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.25.12", "@esbuild/android-arm": "0.25.12", "@esbuild/android-arm64": "0.25.12", "@esbuild/android-x64": "0.25.12", "@esbuild/darwin-arm64": "0.25.12", "@esbuild/darwin-x64": "0.25.12", "@esbuild/freebsd-arm64": "0.25.12", "@esbuild/freebsd-x64": "0.25.12", "@esbuild/linux-arm": "0.25.12", "@esbuild/linux-arm64": "0.25.12", "@esbuild/linux-ia32": "0.25.12", "@esbuild/linux-loong64": "0.25.12", "@esbuild/linux-mips64el": "0.25.12", "@esbuild/linux-ppc64": "0.25.12", "@esbuild/linux-riscv64": "0.25.12", "@esbuild/linux-s390x": "0.25.12", "@esbuild/linux-x64": "0.25.12", "@esbuild/netbsd-arm64": "0.25.12", "@esbuild/netbsd-x64": "0.25.12", "@esbuild/openbsd-arm64": "0.25.12", "@esbuild/openbsd-x64": "0.25.12", "@esbuild/openharmony-arm64": "0.25.12", "@esbuild/sunos-x64": "0.25.12", "@esbuild/win32-arm64": "0.25.12", "@esbuild/win32-ia32": "0.25.12", "@esbuild/win32-x64": "0.25.12" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg=="], 1015 1015 + 1016 1016 + "tsx/fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="], 1017 1017 + 818 1018 "uint8arrays/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 819 1019 1020 1020 + "wisp-hosting-service/@atproto/api": ["@atproto/api@0.17.7", "", { "dependencies": { "@atproto/common-web": "^0.4.3", "@atproto/lexicon": "^0.5.1", "@atproto/syntax": "^0.4.1", "@atproto/xrpc": "^0.7.5", "await-lock": "^2.2.2", "multiformats": "^9.9.0", "tlds": "^1.234.0", "zod": "^3.23.8" } }, "sha512-V+OJBZq9chcrD21xk1bUa6oc5DSKfQj5DmUPf5rmZncqL1w9ZEbS38H5cMyqqdhfgo2LWeDRdZHD0rvNyJsIaw=="], 1021 1021 + 1022 1022 + "wisp-hosting-service/@atproto/lexicon": ["@atproto/lexicon@0.5.1", "", { "dependencies": { "@atproto/common-web": "^0.4.3", "@atproto/syntax": "^0.4.1", "iso-datestring-validator": "^2.2.2", "multiformats": "^9.9.0", "zod": "^3.23.8" } }, "sha512-y8AEtYmfgVl4fqFxqXAeGvhesiGkxiy3CWoJIfsFDDdTlZUC8DFnZrYhcqkIop3OlCkkljvpSJi1hbeC1tbi8A=="], 1023 1023 + 1024 1024 + "@atproto/lex-cli/@atproto/lexicon/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 1025 1025 + 1026 1026 + "@atproto/sync/@atproto/common/@atproto/common-web": ["@atproto/common-web@0.4.5", "", { "dependencies": { "@atproto/lex-data": "0.0.1", "@atproto/lex-json": "0.0.1", "zod": "^3.23.8" } }, "sha512-Tx0xUafLm3vRvOQpbBl5eb9V8xlC7TaRXs6dAulHRkDG3Kb+P9qn3pkDteq+aeMshbVXbVa1rm3Ok4vFyuoyYA=="], 1027 1027 + 1028 1028 + "@atproto/sync/@atproto/xrpc-server/@atproto/xrpc": ["@atproto/xrpc@0.7.6", "", { "dependencies": { "@atproto/lexicon": "^0.5.2", "zod": "^3.23.8" } }, "sha512-RvCf4j0JnKYWuz3QzsYCntJi3VuiAAybQsMIUw2wLWcHhchO9F7UaBZINLL2z0qc/cYWPv5NSwcVydMseoCZLA=="], 1029 1029 + 1030 1030 + "@atproto/ws-client/@atproto/common/@atproto/common-web": ["@atproto/common-web@0.4.5", "", { "dependencies": { "@atproto/lex-data": "0.0.1", "@atproto/lex-json": "0.0.1", "zod": "^3.23.8" } }, "sha512-Tx0xUafLm3vRvOQpbBl5eb9V8xlC7TaRXs6dAulHRkDG3Kb+P9qn3pkDteq+aeMshbVXbVa1rm3Ok4vFyuoyYA=="], 1031 1031 + 1032 1032 + "@atproto/ws-client/@atproto/common/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 1033 1033 + 1034 1034 + "@atproto/xrpc-server/@atproto/lexicon/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 1035 1035 + 1036 1036 + "@atproto/xrpc/@atproto/lexicon/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 1037 1037 + 820 1038 "@tokenizer/inflate/debug/ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="], 1039 1039 + 1040 1040 + "@wisp/main-app/@atproto/api/@atproto/lexicon": ["@atproto/lexicon@0.5.1", "", { "dependencies": { "@atproto/common-web": "^0.4.3", "@atproto/syntax": "^0.4.1", "iso-datestring-validator": "^2.2.2", "multiformats": "^9.9.0", "zod": "^3.23.8" } }, "sha512-y8AEtYmfgVl4fqFxqXAeGvhesiGkxiy3CWoJIfsFDDdTlZUC8DFnZrYhcqkIop3OlCkkljvpSJi1hbeC1tbi8A=="], 1041 1041 + 1042 1042 + "@wisp/main-app/@atproto/api/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 1043 1043 + 1044 1044 + "bun-types/@types/node/undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="], 1045 1045 + 1046 1046 + "protobufjs/@types/node/undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="], 821 1047 822 1048 "require-in-the-middle/debug/ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="], 1049 1049 + 1050 1050 + "tsx/esbuild/@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.25.12", "", { "os": "aix", "cpu": "ppc64" }, "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA=="], 1051 1051 + 1052 1052 + "tsx/esbuild/@esbuild/android-arm": ["@esbuild/android-arm@0.25.12", "", { "os": "android", "cpu": "arm" }, "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg=="], 1053 1053 + 1054 1054 + "tsx/esbuild/@esbuild/android-arm64": ["@esbuild/android-arm64@0.25.12", "", { "os": "android", "cpu": "arm64" }, "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg=="], 1055 1055 + 1056 1056 + "tsx/esbuild/@esbuild/android-x64": ["@esbuild/android-x64@0.25.12", "", { "os": "android", "cpu": "x64" }, "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg=="], 1057 1057 + 1058 1058 + "tsx/esbuild/@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.25.12", "", { "os": "darwin", "cpu": "arm64" }, "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg=="], 1059 1059 + 1060 1060 + "tsx/esbuild/@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.25.12", "", { "os": "darwin", "cpu": "x64" }, "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA=="], 1061 1061 + 1062 1062 + "tsx/esbuild/@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.25.12", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg=="], 1063 1063 + 1064 1064 + "tsx/esbuild/@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.25.12", "", { "os": "freebsd", "cpu": "x64" }, "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ=="], 1065 1065 + 1066 1066 + "tsx/esbuild/@esbuild/linux-arm": ["@esbuild/linux-arm@0.25.12", "", { "os": "linux", "cpu": "arm" }, "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw=="], 1067 1067 + 1068 1068 + "tsx/esbuild/@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.25.12", "", { "os": "linux", "cpu": "arm64" }, "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ=="], 1069 1069 + 1070 1070 + "tsx/esbuild/@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.25.12", "", { "os": "linux", "cpu": "ia32" }, "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA=="], 1071 1071 + 1072 1072 + "tsx/esbuild/@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.25.12", "", { "os": "linux", "cpu": "none" }, "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng=="], 1073 1073 + 1074 1074 + "tsx/esbuild/@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.25.12", "", { "os": "linux", "cpu": "none" }, "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw=="], 1075 1075 + 1076 1076 + "tsx/esbuild/@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.25.12", "", { "os": "linux", "cpu": "ppc64" }, "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA=="], 1077 1077 + 1078 1078 + "tsx/esbuild/@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.25.12", "", { "os": "linux", "cpu": "none" }, "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w=="], 1079 1079 + 1080 1080 + "tsx/esbuild/@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.25.12", "", { "os": "linux", "cpu": "s390x" }, "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg=="], 1081 1081 + 1082 1082 + "tsx/esbuild/@esbuild/linux-x64": ["@esbuild/linux-x64@0.25.12", "", { "os": "linux", "cpu": "x64" }, "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw=="], 1083 1083 + 1084 1084 + "tsx/esbuild/@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.25.12", "", { "os": "none", "cpu": "arm64" }, "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg=="], 1085 1085 + 1086 1086 + "tsx/esbuild/@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.25.12", "", { "os": "none", "cpu": "x64" }, "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ=="], 1087 1087 + 1088 1088 + "tsx/esbuild/@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.25.12", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A=="], 1089 1089 + 1090 1090 + "tsx/esbuild/@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.25.12", "", { "os": "openbsd", "cpu": "x64" }, "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw=="], 1091 1091 + 1092 1092 + "tsx/esbuild/@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.25.12", "", { "os": "none", "cpu": "arm64" }, "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg=="], 1093 1093 + 1094 1094 + "tsx/esbuild/@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.25.12", "", { "os": "sunos", "cpu": "x64" }, "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w=="], 1095 1095 + 1096 1096 + "tsx/esbuild/@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.25.12", "", { "os": "win32", "cpu": "arm64" }, "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg=="], 1097 1097 + 1098 1098 + "tsx/esbuild/@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.25.12", "", { "os": "win32", "cpu": "ia32" }, "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ=="], 1099 1099 + 1100 1100 + "tsx/esbuild/@esbuild/win32-x64": ["@esbuild/win32-x64@0.25.12", "", { "os": "win32", "cpu": "x64" }, "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA=="], 1101 1101 + 1102 1102 + "wisp-hosting-service/@atproto/api/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 1103 1103 + 1104 1104 + "wisp-hosting-service/@atproto/lexicon/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 823 1105 } 824 1106 }

hosting-service/.dockerignore apps/hosting-service/.dockerignore

hosting-service/.env.example apps/hosting-service/.env.example

hosting-service/.gitignore apps/hosting-service/.gitignore

hosting-service/Dockerfile apps/hosting-service/Dockerfile

hosting-service/README.md apps/hosting-service/README.md

hosting-service/bun.lock apps/hosting-service/bun.lock

-51

hosting-service/debug-settings.ts

··· 1 1 - #!/usr/bin/env tsx 2 2 - /** 3 3 - * Debug script to check cached settings for a site 4 4 - * Usage: tsx debug-settings.ts <did> <rkey> 5 5 - */ 6 6 - 7 7 - import { readFile } from 'fs/promises'; 8 8 - import { existsSync } from 'fs'; 9 9 - 10 10 - const CACHE_DIR = './cache'; 11 11 - 12 12 - async function debugSettings(did: string, rkey: string) { 13 13 - const metadataPath = `${CACHE_DIR}/${did}/${rkey}/.metadata.json`; 14 14 - 15 15 - console.log('Checking metadata at:', metadataPath); 16 16 - console.log('Exists:', existsSync(metadataPath)); 17 17 - 18 18 - if (!existsSync(metadataPath)) { 19 19 - console.log('\n❌ Metadata file does not exist - site may not be cached yet'); 20 20 - return; 21 21 - } 22 22 - 23 23 - const content = await readFile(metadataPath, 'utf-8'); 24 24 - const metadata = JSON.parse(content); 25 25 - 26 26 - console.log('\n=== Cached Metadata ==='); 27 27 - console.log('CID:', metadata.cid); 28 28 - console.log('Cached at:', metadata.cachedAt); 29 29 - console.log('\n=== Settings ==='); 30 30 - if (metadata.settings) { 31 31 - console.log(JSON.stringify(metadata.settings, null, 2)); 32 32 - } else { 33 33 - console.log('❌ No settings found in metadata'); 34 34 - console.log('This means:'); 35 35 - console.log(' 1. No place.wisp.settings record exists on the PDS'); 36 36 - console.log(' 2. Or the firehose hasn\'t picked up the settings yet'); 37 37 - console.log('\nTo fix:'); 38 38 - console.log(' 1. Create a place.wisp.settings record with the same rkey'); 39 39 - console.log(' 2. Wait for firehose to pick it up (a few seconds)'); 40 40 - console.log(' 3. Or manually re-cache the site'); 41 41 - } 42 42 - } 43 43 - 44 44 - const [did, rkey] = process.argv.slice(2); 45 45 - if (!did || !rkey) { 46 46 - console.log('Usage: tsx debug-settings.ts <did> <rkey>'); 47 47 - console.log('Example: tsx debug-settings.ts did:plc:abc123 my-site'); 48 48 - process.exit(1); 49 49 - } 50 50 - 51 51 - debugSettings(did, rkey).catch(console.error);

hosting-service/docker-entrypoint.sh apps/hosting-service/docker-entrypoint.sh

-134

hosting-service/example-_redirects

··· 1 1 - # Example _redirects file for Wisp hosting 2 2 - # Place this file in the root directory of your site as "_redirects" 3 3 - # Lines starting with # are comments 4 4 - 5 5 - # =================================== 6 6 - # SIMPLE REDIRECTS 7 7 - # =================================== 8 8 - 9 9 - # Redirect home page 10 10 - # /home / 11 11 - 12 12 - # Redirect old URLs to new ones 13 13 - # /old-blog /blog 14 14 - # /about-us /about 15 15 - 16 16 - # =================================== 17 17 - # SPLAT REDIRECTS (WILDCARDS) 18 18 - # =================================== 19 19 - 20 20 - # Redirect entire directories 21 21 - # /news/* /blog/:splat 22 22 - # /old-site/* /new-site/:splat 23 23 - 24 24 - # =================================== 25 25 - # PLACEHOLDER REDIRECTS 26 26 - # =================================== 27 27 - 28 28 - # Restructure blog URLs 29 29 - # /blog/:year/:month/:day/:slug /posts/:year-:month-:day/:slug 30 30 - 31 31 - # Capture multiple parameters 32 32 - # /products/:category/:id /shop/:category/item/:id 33 33 - 34 34 - # =================================== 35 35 - # STATUS CODES 36 36 - # =================================== 37 37 - 38 38 - # Permanent redirect (301) - default if not specified 39 39 - # /permanent-move /new-location 301 40 40 - 41 41 - # Temporary redirect (302) 42 42 - # /temp-redirect /temp-location 302 43 43 - 44 44 - # Rewrite (200) - serves different content, URL stays the same 45 45 - # /api/* /functions/:splat 200 46 46 - 47 47 - # Custom 404 page 48 48 - # /shop/* /shop-closed.html 404 49 49 - 50 50 - # =================================== 51 51 - # FORCE REDIRECTS 52 52 - # =================================== 53 53 - 54 54 - # Force redirect even if file exists (note the ! after status code) 55 55 - # /override-file /other-file.html 200! 56 56 - 57 57 - # =================================== 58 58 - # CONDITIONAL REDIRECTS 59 59 - # =================================== 60 60 - 61 61 - # Country-based redirects (ISO 3166-1 alpha-2 codes) 62 62 - # / /us/ 302 Country=us 63 63 - # / /uk/ 302 Country=gb 64 64 - # / /anz/ 302 Country=au,nz 65 65 - 66 66 - # Language-based redirects 67 67 - # /products /en/products 301 Language=en 68 68 - # /products /de/products 301 Language=de 69 69 - # /products /fr/products 301 Language=fr 70 70 - 71 71 - # Cookie-based redirects (checks if cookie exists) 72 72 - # /* /legacy/:splat 200 Cookie=is_legacy 73 73 - 74 74 - # =================================== 75 75 - # QUERY PARAMETERS 76 76 - # =================================== 77 77 - 78 78 - # Match specific query parameters 79 79 - # /store id=:id /blog/:id 301 80 80 - 81 81 - # Multiple parameters 82 82 - # /search q=:query category=:cat /find/:cat/:query 301 83 83 - 84 84 - # =================================== 85 85 - # DOMAIN-LEVEL REDIRECTS 86 86 - # =================================== 87 87 - 88 88 - # Redirect to different domain (must include protocol) 89 89 - # /external https://example.com/path 90 90 - 91 91 - # Redirect entire subdomain 92 92 - # http://blog.example.com/* https://example.com/blog/:splat 301! 93 93 - # https://blog.example.com/* https://example.com/blog/:splat 301! 94 94 - 95 95 - # =================================== 96 96 - # COMMON PATTERNS 97 97 - # =================================== 98 98 - 99 99 - # Remove .html extensions 100 100 - # /page.html /page 101 101 - 102 102 - # Add trailing slash 103 103 - # /about /about/ 104 104 - 105 105 - # Single-page app fallback (serve index.html for all paths) 106 106 - # /* /index.html 200 107 107 - 108 108 - # API proxy 109 109 - # /api/* https://api.example.com/:splat 200 110 110 - 111 111 - # =================================== 112 112 - # CUSTOM ERROR PAGES 113 113 - # =================================== 114 114 - 115 115 - # Language-specific 404 pages 116 116 - # /en/* /en/404.html 404 117 117 - # /de/* /de/404.html 404 118 118 - 119 119 - # Section-specific 404 pages 120 120 - # /shop/* /shop/not-found.html 404 121 121 - # /blog/* /blog/404.html 404 122 122 - 123 123 - # =================================== 124 124 - # NOTES 125 125 - # =================================== 126 126 - # 127 127 - # - Rules are processed in order (first match wins) 128 128 - # - More specific rules should come before general ones 129 129 - # - Splats (*) can only be used at the end of a path 130 130 - # - Query parameters are automatically preserved for 200, 301, 302 131 131 - # - Trailing slashes are normalized (/ and no / are treated the same) 132 132 - # - Default status code is 301 if not specified 133 133 - # 134 134 -

+7

hosting-service/package.json apps/hosting-service/package.json

··· 9 9 "backfill": "tsx src/index.ts --backfill" 10 10 }, 11 11 "dependencies": { 12 12 + "@wisp/lexicons": "workspace:*", 13 13 + "@wisp/constants": "workspace:*", 14 14 + "@wisp/observability": "workspace:*", 15 15 + "@wisp/atproto-utils": "workspace:*", 16 16 + "@wisp/database": "workspace:*", 17 17 + "@wisp/fs-utils": "workspace:*", 18 18 + "@wisp/safe-fetch": "workspace:*", 12 19 "@atproto/api": "^0.17.4", 13 20 "@atproto/identity": "^0.4.9", 14 21 "@atproto/lexicon": "^0.5.1",

+3 -1

hosting-service/src/index.ts apps/hosting-service/src/index.ts

··· 1 1 import app from './server'; 2 2 import { serve } from '@hono/node-server'; 3 3 import { FirehoseWorker } from './lib/firehose'; 4 4 - import { logger } from './lib/observability'; 4 4 + import { createLogger } from '@wisp/observability'; 5 5 import { mkdirSync, existsSync } from 'fs'; 6 6 import { backfillCache } from './lib/backfill'; 7 7 import { startDomainCacheCleanup, stopDomainCacheCleanup, setCacheOnlyMode } from './lib/db'; 8 8 + 9 9 + const logger = createLogger('hosting-service'); 8 10 9 11 const PORT = process.env.PORT ? parseInt(process.env.PORT) : 3001; 10 12 const CACHE_DIR = process.env.CACHE_DIR || './cache/sites';

-44

hosting-service/src/lexicon/index.ts

··· 1 1 - /** 2 2 - * GENERATED CODE - DO NOT MODIFY 3 3 - */ 4 4 - import { 5 5 - type Auth, 6 6 - type Options as XrpcOptions, 7 7 - Server as XrpcServer, 8 8 - type StreamConfigOrHandler, 9 9 - type MethodConfigOrHandler, 10 10 - createServer as createXrpcServer, 11 11 - } from '@atproto/xrpc-server' 12 12 - import { schemas } from './lexicons.js' 13 13 - 14 14 - export function createServer(options?: XrpcOptions): Server { 15 15 - return new Server(options) 16 16 - } 17 17 - 18 18 - export class Server { 19 19 - xrpc: XrpcServer 20 20 - place: PlaceNS 21 21 - 22 22 - constructor(options?: XrpcOptions) { 23 23 - this.xrpc = createXrpcServer(schemas, options) 24 24 - this.place = new PlaceNS(this) 25 25 - } 26 26 - } 27 27 - 28 28 - export class PlaceNS { 29 29 - _server: Server 30 30 - wisp: PlaceWispNS 31 31 - 32 32 - constructor(server: Server) { 33 33 - this._server = server 34 34 - this.wisp = new PlaceWispNS(server) 35 35 - } 36 36 - } 37 37 - 38 38 - export class PlaceWispNS { 39 39 - _server: Server 40 40 - 41 41 - constructor(server: Server) { 42 42 - this._server = server 43 43 - } 44 44 - }

-364

hosting-service/src/lexicon/lexicons.ts

··· 1 1 - /** 2 2 - * GENERATED CODE - DO NOT MODIFY 3 3 - */ 4 4 - import { 5 5 - type LexiconDoc, 6 6 - Lexicons, 7 7 - ValidationError, 8 8 - type ValidationResult, 9 9 - } from '@atproto/lexicon' 10 10 - import { type $Typed, is$typed, maybe$typed } from './util.js' 11 11 - 12 12 - export const schemaDict = { 13 13 - PlaceWispFs: { 14 14 - lexicon: 1, 15 15 - id: 'place.wisp.fs', 16 16 - defs: { 17 17 - main: { 18 18 - type: 'record', 19 19 - description: 'Virtual filesystem manifest for a Wisp site', 20 20 - record: { 21 21 - type: 'object', 22 22 - required: ['site', 'root', 'createdAt'], 23 23 - properties: { 24 24 - site: { 25 25 - type: 'string', 26 26 - }, 27 27 - root: { 28 28 - type: 'ref', 29 29 - ref: 'lex:place.wisp.fs#directory', 30 30 - }, 31 31 - fileCount: { 32 32 - type: 'integer', 33 33 - minimum: 0, 34 34 - maximum: 1000, 35 35 - }, 36 36 - createdAt: { 37 37 - type: 'string', 38 38 - format: 'datetime', 39 39 - }, 40 40 - }, 41 41 - }, 42 42 - }, 43 43 - file: { 44 44 - type: 'object', 45 45 - required: ['type', 'blob'], 46 46 - properties: { 47 47 - type: { 48 48 - type: 'string', 49 49 - const: 'file', 50 50 - }, 51 51 - blob: { 52 52 - type: 'blob', 53 53 - accept: ['*/*'], 54 54 - maxSize: 1000000000, 55 55 - description: 'Content blob ref', 56 56 - }, 57 57 - encoding: { 58 58 - type: 'string', 59 59 - enum: ['gzip'], 60 60 - description: 'Content encoding (e.g., gzip for compressed files)', 61 61 - }, 62 62 - mimeType: { 63 63 - type: 'string', 64 64 - description: 'Original MIME type before compression', 65 65 - }, 66 66 - base64: { 67 67 - type: 'boolean', 68 68 - description: 69 69 - 'True if blob content is base64-encoded (used to bypass PDS content sniffing)', 70 70 - }, 71 71 - }, 72 72 - }, 73 73 - directory: { 74 74 - type: 'object', 75 75 - required: ['type', 'entries'], 76 76 - properties: { 77 77 - type: { 78 78 - type: 'string', 79 79 - const: 'directory', 80 80 - }, 81 81 - entries: { 82 82 - type: 'array', 83 83 - maxLength: 500, 84 84 - items: { 85 85 - type: 'ref', 86 86 - ref: 'lex:place.wisp.fs#entry', 87 87 - }, 88 88 - }, 89 89 - }, 90 90 - }, 91 91 - entry: { 92 92 - type: 'object', 93 93 - required: ['name', 'node'], 94 94 - properties: { 95 95 - name: { 96 96 - type: 'string', 97 97 - maxLength: 255, 98 98 - }, 99 99 - node: { 100 100 - type: 'union', 101 101 - refs: [ 102 102 - 'lex:place.wisp.fs#file', 103 103 - 'lex:place.wisp.fs#directory', 104 104 - 'lex:place.wisp.fs#subfs', 105 105 - ], 106 106 - }, 107 107 - }, 108 108 - }, 109 109 - subfs: { 110 110 - type: 'object', 111 111 - required: ['type', 'subject'], 112 112 - properties: { 113 113 - type: { 114 114 - type: 'string', 115 115 - const: 'subfs', 116 116 - }, 117 117 - subject: { 118 118 - type: 'string', 119 119 - format: 'at-uri', 120 120 - description: 121 121 - 'AT-URI pointing to a place.wisp.subfs record containing this subtree.', 122 122 - }, 123 123 - flat: { 124 124 - type: 'boolean', 125 125 - description: 126 126 - "If true (default), the subfs record's root entries are merged (flattened) into the parent directory, replacing the subfs entry. If false, the subfs entries are placed in a subdirectory with the subfs entry's name. Flat merging is useful for splitting large directories across multiple records while maintaining a flat structure.", 127 127 - }, 128 128 - }, 129 129 - }, 130 130 - }, 131 131 - }, 132 132 - PlaceWispSettings: { 133 133 - lexicon: 1, 134 134 - id: 'place.wisp.settings', 135 135 - defs: { 136 136 - main: { 137 137 - type: 'record', 138 138 - description: 139 139 - 'Configuration settings for a static site hosted on wisp.place', 140 140 - key: 'any', 141 141 - record: { 142 142 - type: 'object', 143 143 - properties: { 144 144 - directoryListing: { 145 145 - type: 'boolean', 146 146 - description: 147 147 - 'Enable directory listing mode for paths that resolve to directories without an index file. Incompatible with spaMode.', 148 148 - default: false, 149 149 - }, 150 150 - spaMode: { 151 151 - type: 'string', 152 152 - description: 153 153 - "File to serve for all routes (e.g., 'index.html'). When set, enables SPA mode where all non-file requests are routed to this file. Incompatible with directoryListing and custom404.", 154 154 - maxLength: 500, 155 155 - }, 156 156 - custom404: { 157 157 - type: 'string', 158 158 - description: 159 159 - 'Custom 404 error page file path. Incompatible with directoryListing and spaMode.', 160 160 - maxLength: 500, 161 161 - }, 162 162 - indexFiles: { 163 163 - type: 'array', 164 164 - description: 165 165 - "Ordered list of files to try when serving a directory. Defaults to ['index.html'] if not specified.", 166 166 - items: { 167 167 - type: 'string', 168 168 - maxLength: 255, 169 169 - }, 170 170 - maxLength: 10, 171 171 - }, 172 172 - cleanUrls: { 173 173 - type: 'boolean', 174 174 - description: 175 175 - "Enable clean URL routing. When enabled, '/about' will attempt to serve '/about.html' or '/about/index.html' automatically.", 176 176 - default: false, 177 177 - }, 178 178 - headers: { 179 179 - type: 'array', 180 180 - description: 'Custom HTTP headers to set on responses', 181 181 - items: { 182 182 - type: 'ref', 183 183 - ref: 'lex:place.wisp.settings#customHeader', 184 184 - }, 185 185 - maxLength: 50, 186 186 - }, 187 187 - }, 188 188 - }, 189 189 - }, 190 190 - customHeader: { 191 191 - type: 'object', 192 192 - description: 'Custom HTTP header configuration', 193 193 - required: ['name', 'value'], 194 194 - properties: { 195 195 - name: { 196 196 - type: 'string', 197 197 - description: 198 198 - "HTTP header name (e.g., 'Cache-Control', 'X-Frame-Options')", 199 199 - maxLength: 100, 200 200 - }, 201 201 - value: { 202 202 - type: 'string', 203 203 - description: 'HTTP header value', 204 204 - maxLength: 1000, 205 205 - }, 206 206 - path: { 207 207 - type: 'string', 208 208 - description: 209 209 - "Optional glob pattern to apply this header to specific paths (e.g., '*.html', '/assets/*'). If not specified, applies to all paths.", 210 210 - maxLength: 500, 211 211 - }, 212 212 - }, 213 213 - }, 214 214 - }, 215 215 - }, 216 216 - PlaceWispSubfs: { 217 217 - lexicon: 1, 218 218 - id: 'place.wisp.subfs', 219 219 - defs: { 220 220 - main: { 221 221 - type: 'record', 222 222 - description: 223 223 - 'Virtual filesystem subtree referenced by place.wisp.fs records. When a subfs entry is expanded, its root entries are merged (flattened) into the parent directory, allowing large directories to be split across multiple records while maintaining a flat structure.', 224 224 - record: { 225 225 - type: 'object', 226 226 - required: ['root', 'createdAt'], 227 227 - properties: { 228 228 - root: { 229 229 - type: 'ref', 230 230 - ref: 'lex:place.wisp.subfs#directory', 231 231 - }, 232 232 - fileCount: { 233 233 - type: 'integer', 234 234 - minimum: 0, 235 235 - maximum: 1000, 236 236 - }, 237 237 - createdAt: { 238 238 - type: 'string', 239 239 - format: 'datetime', 240 240 - }, 241 241 - }, 242 242 - }, 243 243 - }, 244 244 - file: { 245 245 - type: 'object', 246 246 - required: ['type', 'blob'], 247 247 - properties: { 248 248 - type: { 249 249 - type: 'string', 250 250 - const: 'file', 251 251 - }, 252 252 - blob: { 253 253 - type: 'blob', 254 254 - accept: ['*/*'], 255 255 - maxSize: 1000000000, 256 256 - description: 'Content blob ref', 257 257 - }, 258 258 - encoding: { 259 259 - type: 'string', 260 260 - enum: ['gzip'], 261 261 - description: 'Content encoding (e.g., gzip for compressed files)', 262 262 - }, 263 263 - mimeType: { 264 264 - type: 'string', 265 265 - description: 'Original MIME type before compression', 266 266 - }, 267 267 - base64: { 268 268 - type: 'boolean', 269 269 - description: 270 270 - 'True if blob content is base64-encoded (used to bypass PDS content sniffing)', 271 271 - }, 272 272 - }, 273 273 - }, 274 274 - directory: { 275 275 - type: 'object', 276 276 - required: ['type', 'entries'], 277 277 - properties: { 278 278 - type: { 279 279 - type: 'string', 280 280 - const: 'directory', 281 281 - }, 282 282 - entries: { 283 283 - type: 'array', 284 284 - maxLength: 500, 285 285 - items: { 286 286 - type: 'ref', 287 287 - ref: 'lex:place.wisp.subfs#entry', 288 288 - }, 289 289 - }, 290 290 - }, 291 291 - }, 292 292 - entry: { 293 293 - type: 'object', 294 294 - required: ['name', 'node'], 295 295 - properties: { 296 296 - name: { 297 297 - type: 'string', 298 298 - maxLength: 255, 299 299 - }, 300 300 - node: { 301 301 - type: 'union', 302 302 - refs: [ 303 303 - 'lex:place.wisp.subfs#file', 304 304 - 'lex:place.wisp.subfs#directory', 305 305 - 'lex:place.wisp.subfs#subfs', 306 306 - ], 307 307 - }, 308 308 - }, 309 309 - }, 310 310 - subfs: { 311 311 - type: 'object', 312 312 - required: ['type', 'subject'], 313 313 - properties: { 314 314 - type: { 315 315 - type: 'string', 316 316 - const: 'subfs', 317 317 - }, 318 318 - subject: { 319 319 - type: 'string', 320 320 - format: 'at-uri', 321 321 - description: 322 322 - "AT-URI pointing to another place.wisp.subfs record for nested subtrees. When expanded, the referenced record's root entries are merged (flattened) into the parent directory, allowing recursive splitting of large directory structures.", 323 323 - }, 324 324 - }, 325 325 - }, 326 326 - }, 327 327 - }, 328 328 - } as const satisfies Record<string, LexiconDoc> 329 329 - export const schemas = Object.values(schemaDict) satisfies LexiconDoc[] 330 330 - export const lexicons: Lexicons = new Lexicons(schemas) 331 331 - 332 332 - export function validate<T extends { $type: string }>( 333 333 - v: unknown, 334 334 - id: string, 335 335 - hash: string, 336 336 - requiredType: true, 337 337 - ): ValidationResult<T> 338 338 - export function validate<T extends { $type?: string }>( 339 339 - v: unknown, 340 340 - id: string, 341 341 - hash: string, 342 342 - requiredType?: false, 343 343 - ): ValidationResult<T> 344 344 - export function validate( 345 345 - v: unknown, 346 346 - id: string, 347 347 - hash: string, 348 348 - requiredType?: boolean, 349 349 - ): ValidationResult { 350 350 - return (requiredType ? is$typed : maybe$typed)(v, id, hash) 351 351 - ? lexicons.validate(`${id}#${hash}`, v) 352 352 - : { 353 353 - success: false, 354 354 - error: new ValidationError( 355 355 - `Must be an object with "${hash === 'main' ? id : `${id}#${hash}`}" $type property`, 356 356 - ), 357 357 - } 358 358 - } 359 359 - 360 360 - export const ids = { 361 361 - PlaceWispFs: 'place.wisp.fs', 362 362 - PlaceWispSettings: 'place.wisp.settings', 363 363 - PlaceWispSubfs: 'place.wisp.subfs', 364 364 - } as const

hosting-service/src/lexicon/types/place/wisp/fs.ts packages/@wisp/lexicons/src/types/place/wisp/fs.ts

hosting-service/src/lexicon/types/place/wisp/settings.ts packages/@wisp/lexicons/src/types/place/wisp/settings.ts

hosting-service/src/lexicon/types/place/wisp/subfs.ts packages/@wisp/lexicons/src/types/place/wisp/subfs.ts

hosting-service/src/lexicon/util.ts packages/@wisp/lexicons/src/util.ts

+4 -2

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

··· 1 1 import { getAllSites } from './db'; 2 2 import { fetchSiteRecord, getPdsForDid, downloadAndCacheSite, isCached } from './utils'; 3 3 - import { logger } from './observability'; 3 3 + import { createLogger } from '@wisp/observability'; 4 4 import { markSiteAsBeingCached, unmarkSiteAsBeingCached } from './cache'; 5 5 - import { clearRedirectRulesCache } from '../server'; 5 5 + import { clearRedirectRulesCache } from './site-cache'; 6 6 + 7 7 + const logger = createLogger('hosting-service'); 6 8 7 9 export interface BackfillOptions { 8 10 skipExisting?: boolean; // Skip sites already in cache

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

+1 -15

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

··· 1 1 import postgres from 'postgres'; 2 2 import { createHash } from 'crypto'; 3 3 + import type { DomainLookup, CustomDomainLookup } from '@wisp/database'; 3 4 4 5 // Global cache-only mode flag (set by index.ts) 5 6 let cacheOnlyMode = false; ··· 58 59 cleanupInterval = null; 59 60 } 60 61 } 61 61 - 62 62 - export interface DomainLookup { 63 63 - did: string; 64 64 - rkey: string | null; 65 65 - } 66 66 - 67 67 - export interface CustomDomainLookup { 68 68 - id: string; 69 69 - domain: string; 70 70 - did: string; 71 71 - rkey: string | null; 72 72 - verified: boolean; 73 73 - } 74 74 - 75 75 - 76 62 77 63 export async function getWispDomain(domain: string): Promise<DomainLookup | null> { 78 64 const key = domain.toLowerCase();

+3 -4

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

··· 2 2 import { 3 3 getPdsForDid, 4 4 downloadAndCacheSite, 5 5 - extractBlobCid, 6 5 fetchSiteRecord 7 6 } from './utils' 8 7 import { upsertSite, tryAcquireLock, releaseLock } from './db' 9 9 - import { safeFetch } from './safe-fetch' 10 10 - import { isRecord, validateRecord } from '../lexicon/types/place/wisp/fs' 8 8 + import { safeFetch } from '@wisp/safe-fetch' 9 9 + import { isRecord, validateRecord } from '@wisp/lexicons/types/place/wisp/fs' 11 10 import { Firehose } from '@atproto/sync' 12 11 import { IdResolver } from '@atproto/identity' 13 12 import { invalidateSiteCache, markSiteAsBeingCached, unmarkSiteAsBeingCached } from './cache' 14 14 - import { clearRedirectRulesCache } from '../server' 13 13 + import { clearRedirectRulesCache } from './site-cache' 15 14 16 15 const CACHE_DIR = './cache/sites' 17 16

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

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

+103 -61

hosting-service/src/lib/observability.ts packages/@wisp/observability/src/core.ts

··· 1 1 - // DIY Observability for Hosting Service 2 2 - import type { Context } from 'hono' 1 1 + /** 2 2 + * Core observability types and collectors 3 3 + * Framework-agnostic logging, error tracking, and metrics collection 4 4 + */ 3 5 6 6 + // ============================================================================ 4 7 // Types 8 8 + // ============================================================================ 9 9 + 5 10 export interface LogEntry { 6 11 id: string 7 12 timestamp: Date ··· 33 38 service: string 34 39 } 35 40 36 36 - // In-memory storage with rotation 41 41 + export interface LogFilter { 42 42 + level?: string 43 43 + service?: string 44 44 + limit?: number 45 45 + search?: string 46 46 + eventType?: string 47 47 + } 48 48 + 49 49 + export interface ErrorFilter { 50 50 + service?: string 51 51 + limit?: number 52 52 + } 53 53 + 54 54 + export interface MetricFilter { 55 55 + service?: string 56 56 + timeWindow?: number 57 57 + } 58 58 + 59 59 + export interface MetricStats { 60 60 + totalRequests: number 61 61 + avgDuration: number 62 62 + p50Duration: number 63 63 + p95Duration: number 64 64 + p99Duration: number 65 65 + errorRate: number 66 66 + requestsPerMinute: number 67 67 + } 68 68 + 69 69 + // ============================================================================ 70 70 + // Configuration 71 71 + // ============================================================================ 72 72 + 37 73 const MAX_LOGS = 5000 38 74 const MAX_ERRORS = 500 39 75 const MAX_METRICS = 10000 40 76 77 77 + // ============================================================================ 78 78 + // Storage 79 79 + // ============================================================================ 80 80 + 41 81 const logs: LogEntry[] = [] 42 82 const errors: Map<string, ErrorEntry> = new Map() 43 83 const metrics: MetricEntry[] = [] 44 84 45 45 - // Helper to generate unique IDs 85 85 + // ============================================================================ 86 86 + // Helpers 87 87 + // ============================================================================ 88 88 + 46 89 let logCounter = 0 47 90 let errorCounter = 0 48 91 ··· 50 93 return `${prefix}-${Date.now()}-${counter}` 51 94 } 52 95 53 53 - // Helper to extract event type from message 54 96 function extractEventType(message: string): string | undefined { 55 97 const match = message.match(/^\[([^\]]+)\]/) 56 98 return match ? match[1] : undefined 57 99 } 58 100 59 59 - // Log collector 101 101 + // ============================================================================ 102 102 + // Log Collector 103 103 + // ============================================================================ 104 104 + 60 105 export const logCollector = { 61 61 - log(level: LogEntry['level'], message: string, service: string, context?: Record<string, any>, traceId?: string) { 106 106 + log( 107 107 + level: LogEntry['level'], 108 108 + message: string, 109 109 + service: string, 110 110 + context?: Record<string, any>, 111 111 + traceId?: string 112 112 + ) { 62 113 const entry: LogEntry = { 63 114 id: generateId('log', logCounter++), 64 115 timestamp: new Date(), ··· 91 142 this.log('warn', message, service, context, traceId) 92 143 }, 93 144 94 94 - error(message: string, service: string, error?: any, context?: Record<string, any>, traceId?: string) { 145 145 + error( 146 146 + message: string, 147 147 + service: string, 148 148 + error?: any, 149 149 + context?: Record<string, any>, 150 150 + traceId?: string 151 151 + ) { 95 152 const ctx = { ...context } 96 153 if (error instanceof Error) { 97 154 ctx.error = error.message ··· 106 163 }, 107 164 108 165 debug(message: string, service: string, context?: Record<string, any>, traceId?: string) { 109 109 - if (process.env.NODE_ENV !== 'production') { 166 166 + const env = typeof Bun !== 'undefined' ? Bun.env.NODE_ENV : process.env.NODE_ENV; 167 167 + if (env !== 'production') { 110 168 this.log('debug', message, service, context, traceId) 111 169 } 112 170 }, 113 171 114 114 - getLogs(filter?: { level?: string; service?: string; limit?: number; search?: string; eventType?: string }) { 172 172 + getLogs(filter?: LogFilter) { 115 173 let filtered = [...logs] 116 174 117 175 if (filter?.level) { ··· 130 188 const search = filter.search.toLowerCase() 131 189 filtered = filtered.filter(log => 132 190 log.message.toLowerCase().includes(search) || 133 133 - JSON.stringify(log.context).toLowerCase().includes(search) 191 191 + (log.context ? JSON.stringify(log.context).toLowerCase().includes(search) : false) 134 192 ) 135 193 } 136 194 ··· 143 201 } 144 202 } 145 203 146 146 - // Error tracker with deduplication 204 204 + // ============================================================================ 205 205 + // Error Tracker 206 206 + // ============================================================================ 207 207 + 147 208 export const errorTracker = { 148 209 track(message: string, service: string, error?: any, context?: Record<string, any>) { 149 210 const key = `${service}:${message}` ··· 182 243 } 183 244 }, 184 245 185 185 - getErrors(filter?: { service?: string; limit?: number }) { 246 246 + getErrors(filter?: ErrorFilter) { 186 247 let filtered = Array.from(errors.values()) 187 248 188 249 if (filter?.service) { ··· 201 262 } 202 263 } 203 264 204 204 - // Metrics collector 265 265 + // ============================================================================ 266 266 + // Metrics Collector 267 267 + // ============================================================================ 268 268 + 205 269 export const metricsCollector = { 206 206 - recordRequest(path: string, method: string, statusCode: number, duration: number, service: string) { 270 270 + recordRequest( 271 271 + path: string, 272 272 + method: string, 273 273 + statusCode: number, 274 274 + duration: number, 275 275 + service: string 276 276 + ) { 207 277 const entry: MetricEntry = { 208 278 timestamp: new Date(), 209 279 path, ··· 221 291 } 222 292 }, 223 293 224 224 - getMetrics(filter?: { service?: string; timeWindow?: number }) { 294 294 + getMetrics(filter?: MetricFilter) { 225 295 let filtered = [...metrics] 226 296 227 297 if (filter?.service) { ··· 236 306 return filtered 237 307 }, 238 308 239 239 - getStats(service?: string, timeWindow: number = 3600000) { 309 309 + getStats(service?: string, timeWindow: number = 3600000): MetricStats { 240 310 const filtered = this.getMetrics({ service, timeWindow }) 241 311 242 312 if (filtered.length === 0) { ··· 277 347 } 278 348 } 279 349 280 280 - // Hono middleware for request timing 281 281 - export function observabilityMiddleware(service: string) { 282 282 - return async (c: Context, next: () => Promise<void>) => { 283 283 - const startTime = Date.now() 284 284 - 285 285 - await next() 286 286 - 287 287 - const duration = Date.now() - startTime 288 288 - const { pathname } = new URL(c.req.url) 289 289 - 290 290 - metricsCollector.recordRequest( 291 291 - pathname, 292 292 - c.req.method, 293 293 - c.res.status, 294 294 - duration, 295 295 - service 296 296 - ) 297 297 - } 298 298 - } 350 350 + // ============================================================================ 351 351 + // Logger Factory 352 352 + // ============================================================================ 299 353 300 300 - // Hono error handler 301 301 - export function observabilityErrorHandler(service: string) { 302 302 - return (err: Error, c: Context) => { 303 303 - const { pathname } = new URL(c.req.url) 304 304 - 305 305 - logCollector.error( 306 306 - `Request failed: ${c.req.method} ${pathname}`, 307 307 - service, 308 308 - err, 309 309 - { statusCode: c.res.status || 500 } 310 310 - ) 311 311 - 312 312 - return c.text('Internal Server Error', 500) 354 354 + /** 355 355 + * Create a service-specific logger instance 356 356 + */ 357 357 + export function createLogger(service: string) { 358 358 + return { 359 359 + info: (message: string, context?: Record<string, any>) => 360 360 + logCollector.info(message, service, context), 361 361 + warn: (message: string, context?: Record<string, any>) => 362 362 + logCollector.warn(message, service, context), 363 363 + error: (message: string, error?: any, context?: Record<string, any>) => 364 364 + logCollector.error(message, service, error, context), 365 365 + debug: (message: string, context?: Record<string, any>) => 366 366 + logCollector.debug(message, service, context) 313 367 } 314 368 } 315 315 - 316 316 - // Export singleton logger for easy access 317 317 - export const logger = { 318 318 - info: (message: string, context?: Record<string, any>) => 319 319 - logCollector.info(message, 'hosting-service', context), 320 320 - warn: (message: string, context?: Record<string, any>) => 321 321 - logCollector.warn(message, 'hosting-service', context), 322 322 - error: (message: string, error?: any, context?: Record<string, any>) => 323 323 - logCollector.error(message, 'hosting-service', error, context), 324 324 - debug: (message: string, context?: Record<string, any>) => 325 325 - logCollector.debug(message, 'hosting-service', context) 326 326 - }

hosting-service/src/lib/redirects.test.ts apps/hosting-service/src/lib/redirects.test.ts

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

-187

hosting-service/src/lib/safe-fetch.ts

··· 1 1 - /** 2 2 - * SSRF-hardened fetch utility 3 3 - * Prevents requests to private networks, localhost, and enforces timeouts/size limits 4 4 - */ 5 5 - 6 6 - const BLOCKED_IP_RANGES = [ 7 7 - /^127\./, // 127.0.0.0/8 - Loopback 8 8 - /^10\./, // 10.0.0.0/8 - Private 9 9 - /^172\.(1[6-9]|2\d|3[01])\./, // 172.16.0.0/12 - Private 10 10 - /^192\.168\./, // 192.168.0.0/16 - Private 11 11 - /^169\.254\./, // 169.254.0.0/16 - Link-local 12 12 - /^::1$/, // IPv6 loopback 13 13 - /^fe80:/, // IPv6 link-local 14 14 - /^fc00:/, // IPv6 unique local 15 15 - /^fd00:/, // IPv6 unique local 16 16 - ]; 17 17 - 18 18 - const BLOCKED_HOSTS = [ 19 19 - 'localhost', 20 20 - 'metadata.google.internal', 21 21 - '169.254.169.254', 22 22 - ]; 23 23 - 24 24 - const FETCH_TIMEOUT = 120000; // 120 seconds 25 25 - const FETCH_TIMEOUT_BLOB = 120000; // 2 minutes for blob downloads 26 26 - const MAX_RESPONSE_SIZE = 10 * 1024 * 1024; // 10MB 27 27 - const MAX_JSON_SIZE = 1024 * 1024; // 1MB 28 28 - const MAX_BLOB_SIZE = 500 * 1024 * 1024; // 500MB 29 29 - const MAX_REDIRECTS = 10; 30 30 - 31 31 - function isBlockedHost(hostname: string): boolean { 32 32 - const lowerHost = hostname.toLowerCase(); 33 33 - 34 34 - if (BLOCKED_HOSTS.includes(lowerHost)) { 35 35 - return true; 36 36 - } 37 37 - 38 38 - for (const pattern of BLOCKED_IP_RANGES) { 39 39 - if (pattern.test(lowerHost)) { 40 40 - return true; 41 41 - } 42 42 - } 43 43 - 44 44 - return false; 45 45 - } 46 46 - 47 47 - export async function safeFetch( 48 48 - url: string, 49 49 - options?: RequestInit & { maxSize?: number; timeout?: number } 50 50 - ): Promise<Response> { 51 51 - const timeoutMs = options?.timeout ?? FETCH_TIMEOUT; 52 52 - const maxSize = options?.maxSize ?? MAX_RESPONSE_SIZE; 53 53 - 54 54 - // Parse and validate URL 55 55 - let parsedUrl: URL; 56 56 - try { 57 57 - parsedUrl = new URL(url); 58 58 - } catch (err) { 59 59 - throw new Error(`Invalid URL: ${url}`); 60 60 - } 61 61 - 62 62 - if (!['http:', 'https:'].includes(parsedUrl.protocol)) { 63 63 - throw new Error(`Blocked protocol: ${parsedUrl.protocol}`); 64 64 - } 65 65 - 66 66 - const hostname = parsedUrl.hostname; 67 67 - if (isBlockedHost(hostname)) { 68 68 - throw new Error(`Blocked host: ${hostname}`); 69 69 - } 70 70 - 71 71 - const controller = new AbortController(); 72 72 - const timeoutId = setTimeout(() => controller.abort(), timeoutMs); 73 73 - 74 74 - try { 75 75 - const response = await fetch(url, { 76 76 - ...options, 77 77 - signal: controller.signal, 78 78 - redirect: 'follow', 79 79 - }); 80 80 - 81 81 - const contentLength = response.headers.get('content-length'); 82 82 - if (contentLength && parseInt(contentLength, 10) > maxSize) { 83 83 - throw new Error(`Response too large: ${contentLength} bytes`); 84 84 - } 85 85 - 86 86 - return response; 87 87 - } catch (err) { 88 88 - if (err instanceof Error && err.name === 'AbortError') { 89 89 - throw new Error(`Request timeout after ${timeoutMs}ms`); 90 90 - } 91 91 - throw err; 92 92 - } finally { 93 93 - clearTimeout(timeoutId); 94 94 - } 95 95 - } 96 96 - 97 97 - export async function safeFetchJson<T = any>( 98 98 - url: string, 99 99 - options?: RequestInit & { maxSize?: number; timeout?: number } 100 100 - ): Promise<T> { 101 101 - const maxJsonSize = options?.maxSize ?? MAX_JSON_SIZE; 102 102 - const response = await safeFetch(url, { ...options, maxSize: maxJsonSize }); 103 103 - 104 104 - if (!response.ok) { 105 105 - throw new Error(`HTTP ${response.status}: ${response.statusText}`); 106 106 - } 107 107 - 108 108 - const reader = response.body?.getReader(); 109 109 - if (!reader) { 110 110 - throw new Error('No response body'); 111 111 - } 112 112 - 113 113 - const chunks: Uint8Array[] = []; 114 114 - let totalSize = 0; 115 115 - 116 116 - try { 117 117 - while (true) { 118 118 - const { done, value } = await reader.read(); 119 119 - if (done) break; 120 120 - 121 121 - totalSize += value.length; 122 122 - if (totalSize > maxJsonSize) { 123 123 - throw new Error(`Response exceeds max size: ${maxJsonSize} bytes`); 124 124 - } 125 125 - 126 126 - chunks.push(value); 127 127 - } 128 128 - } finally { 129 129 - reader.releaseLock(); 130 130 - } 131 131 - 132 132 - const combined = new Uint8Array(totalSize); 133 133 - let offset = 0; 134 134 - for (const chunk of chunks) { 135 135 - combined.set(chunk, offset); 136 136 - offset += chunk.length; 137 137 - } 138 138 - 139 139 - const text = new TextDecoder().decode(combined); 140 140 - return JSON.parse(text); 141 141 - } 142 142 - 143 143 - export async function safeFetchBlob( 144 144 - url: string, 145 145 - options?: RequestInit & { maxSize?: number; timeout?: number } 146 146 - ): Promise<Uint8Array> { 147 147 - const maxBlobSize = options?.maxSize ?? MAX_BLOB_SIZE; 148 148 - const timeoutMs = options?.timeout ?? FETCH_TIMEOUT_BLOB; 149 149 - const response = await safeFetch(url, { ...options, maxSize: maxBlobSize, timeout: timeoutMs }); 150 150 - 151 151 - if (!response.ok) { 152 152 - throw new Error(`HTTP ${response.status}: ${response.statusText}`); 153 153 - } 154 154 - 155 155 - const reader = response.body?.getReader(); 156 156 - if (!reader) { 157 157 - throw new Error('No response body'); 158 158 - } 159 159 - 160 160 - const chunks: Uint8Array[] = []; 161 161 - let totalSize = 0; 162 162 - 163 163 - try { 164 164 - while (true) { 165 165 - const { done, value } = await reader.read(); 166 166 - if (done) break; 167 167 - 168 168 - totalSize += value.length; 169 169 - if (totalSize > maxBlobSize) { 170 170 - throw new Error(`Blob exceeds max size: ${maxBlobSize} bytes`); 171 171 - } 172 172 - 173 173 - chunks.push(value); 174 174 - } 175 175 - } finally { 176 176 - reader.releaseLock(); 177 177 - } 178 178 - 179 179 - const combined = new Uint8Array(totalSize); 180 180 - let offset = 0; 181 181 - for (const chunk of chunks) { 182 182 - combined.set(chunk, offset); 183 183 - offset += chunk.length; 184 184 - } 185 185 - 186 186 - return combined; 187 187 - }

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

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

+21 -154

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

··· 1 1 import { AtpAgent } from '@atproto/api'; 2 2 - import type { Record as WispFsRecord, Directory, Entry, File } from '../lexicon/types/place/wisp/fs'; 3 3 - import type { Record as SubfsRecord } from '../lexicon/types/place/wisp/subfs'; 4 4 - import type { Record as WispSettings } from '../lexicon/types/place/wisp/settings'; 2 2 + import type { Record as WispFsRecord, Directory, Entry, File } from '@wisp/lexicons/types/place/wisp/fs'; 3 3 + import type { Record as SubfsRecord } from '@wisp/lexicons/types/place/wisp/subfs'; 4 4 + import type { Record as WispSettings } from '@wisp/lexicons/types/place/wisp/settings'; 5 5 import { existsSync, mkdirSync, readFileSync, rmSync } from 'fs'; 6 6 import { writeFile, readFile, rename } from 'fs/promises'; 7 7 - import { safeFetchJson, safeFetchBlob } from './safe-fetch'; 7 7 + import { safeFetchJson, safeFetchBlob } from '@wisp/safe-fetch'; 8 8 import { CID } from 'multiformats'; 9 9 + import { extractBlobCid } from '@wisp/atproto-utils'; 10 10 + import { sanitizePath, collectFileCidsFromEntries } from '@wisp/fs-utils'; 11 11 + import { shouldCompressMimeType } from '@wisp/atproto-utils/compression'; 12 12 + 13 13 + // Re-export shared utilities for local usage and tests 14 14 + export { extractBlobCid, sanitizePath }; 9 15 10 16 const CACHE_DIR = process.env.CACHE_DIR || './cache/sites'; 11 17 const CACHE_TTL = 14 * 24 * 60 * 60 * 1000; // 14 days cache TTL ··· 21 27 settings?: WispSettings; 22 28 } 23 29 24 24 - /** 25 25 - * Determines if a MIME type should benefit from gzip compression. 26 26 - * Returns true for text-based web assets (HTML, CSS, JS, JSON, XML, SVG). 27 27 - * Returns false for already-compressed formats (images, video, audio, PDFs). 28 28 - * 29 29 - */ 30 30 - export function shouldCompressMimeType(mimeType: string | undefined): boolean { 31 31 - if (!mimeType) return false; 32 32 - 33 33 - const mime = mimeType.toLowerCase(); 34 34 - 35 35 - // Text-based web assets and uncompressed audio that benefit from compression 36 36 - const compressibleTypes = [ 37 37 - 'text/html', 38 38 - 'text/css', 39 39 - 'text/javascript', 40 40 - 'application/javascript', 41 41 - 'application/x-javascript', 42 42 - 'text/xml', 43 43 - 'application/xml', 44 44 - 'application/json', 45 45 - 'text/plain', 46 46 - 'image/svg+xml', 47 47 - // Uncompressed audio formats 48 48 - 'audio/wav', 49 49 - 'audio/wave', 50 50 - 'audio/x-wav', 51 51 - 'audio/aiff', 52 52 - 'audio/x-aiff', 53 53 - ]; 54 54 - 55 55 - if (compressibleTypes.some(type => mime === type || mime.startsWith(type))) { 56 56 - return true; 57 57 - } 58 58 - 59 59 - // Already-compressed formats that should NOT be double-compressed 60 60 - const alreadyCompressedPrefixes = [ 61 61 - 'video/', 62 62 - 'audio/', 63 63 - 'image/', 64 64 - 'application/pdf', 65 65 - 'application/zip', 66 66 - 'application/gzip', 67 67 - ]; 68 68 - 69 69 - if (alreadyCompressedPrefixes.some(prefix => mime.startsWith(prefix))) { 70 70 - return false; 71 71 - } 72 72 - 73 73 - // Default to not compressing for unknown types 74 74 - return false; 75 75 - } 76 76 - 77 77 - interface IpldLink { 78 78 - $link: string; 79 79 - } 80 80 - 81 81 - interface TypedBlobRef { 82 82 - ref: CID | IpldLink; 83 83 - } 84 84 - 85 85 - interface UntypedBlobRef { 86 86 - cid: string; 87 87 - } 88 88 - 89 89 - function isIpldLink(obj: unknown): obj is IpldLink { 90 90 - return typeof obj === 'object' && obj !== null && '$link' in obj && typeof (obj as IpldLink).$link === 'string'; 91 91 - } 92 92 - 93 93 - function isTypedBlobRef(obj: unknown): obj is TypedBlobRef { 94 94 - return typeof obj === 'object' && obj !== null && 'ref' in obj; 95 95 - } 96 96 - 97 97 - function isUntypedBlobRef(obj: unknown): obj is UntypedBlobRef { 98 98 - return typeof obj === 'object' && obj !== null && 'cid' in obj && typeof (obj as UntypedBlobRef).cid === 'string'; 99 99 - } 100 30 101 31 export async function resolveDid(identifier: string): Promise<string | null> { 102 32 try { ··· 189 119 } 190 120 } 191 121 192 192 - export function extractBlobCid(blobRef: unknown): string | null { 193 193 - if (isIpldLink(blobRef)) { 194 194 - return blobRef.$link; 195 195 - } 196 196 - 197 197 - if (isTypedBlobRef(blobRef)) { 198 198 - const ref = blobRef.ref; 199 199 - 200 200 - const cid = CID.asCID(ref); 201 201 - if (cid) { 202 202 - return cid.toString(); 203 203 - } 204 204 - 205 205 - if (isIpldLink(ref)) { 206 206 - return ref.$link; 207 207 - } 208 208 - } 209 209 - 210 210 - if (isUntypedBlobRef(blobRef)) { 211 211 - return blobRef.cid; 212 212 - } 213 213 - 214 214 - return null; 215 215 - } 216 216 - 217 122 /** 218 123 * Extract all subfs URIs from a directory tree with their mount paths 219 124 */ ··· 253 158 return null; 254 159 } 255 160 256 256 - const did = parts[0]; 257 257 - const collection = parts[1]; 258 258 - const rkey = parts[2]; 161 161 + const did = parts[0] || ''; 162 162 + const collection = parts[1] || ''; 163 163 + const rkey = parts[2] || ''; 259 164 260 165 // Fetch the record from PDS 261 166 const url = `${pdsEndpoint}/xrpc/com.atproto.repo.getRecord?repo=${encodeURIComponent(did)}&collection=${encodeURIComponent(collection)}&rkey=${encodeURIComponent(rkey)}`; ··· 297 202 ); 298 203 299 204 // Build a map of path -> root entries to merge 205 205 + // Note: SubFS entries are compatible with FS entries at runtime 300 206 const subfsMap = new Map<string, Entry[]>(); 301 207 for (const { record, path } of subfsRecords) { 302 208 if (record && record.root && record.root.entries) { 303 303 - subfsMap.set(path, record.root.entries); 209 209 + subfsMap.set(path, record.root.entries as unknown as Entry[]); 304 210 } 305 211 } 306 212 ··· 328 234 } else { 329 235 // Subdirectory merge: create a directory with the subfs node's name 330 236 const processedEntries = replaceSubfsInEntries(subfsEntries, fullPath); 237 237 + const directoryNode: Directory = { 238 238 + type: 'directory', 239 239 + entries: processedEntries 240 240 + }; 331 241 result.push({ 332 242 name: entry.name, 333 333 - node: { 334 334 - type: 'directory', 335 335 - entries: processedEntries 336 336 - } 243 243 + node: directoryNode as any // Type assertion needed due to lexicon type complexity 337 244 }); 338 245 } 339 246 } else { ··· 363 270 entries: replaceSubfsInEntries(directory.entries) 364 271 }; 365 272 } 273 273 + 366 274 367 275 export async function downloadAndCacheSite(did: string, rkey: string, record: WispFsRecord, pdsEndpoint: string, recordCid: string): Promise<void> { 368 276 console.log('Caching site', did, rkey); ··· 436 344 } 437 345 } 438 346 439 439 - /** 440 440 - * Recursively collect file CIDs from entries for incremental update tracking 441 441 - */ 442 442 - function collectFileCidsFromEntries(entries: Entry[], pathPrefix: string, fileCids: Record<string, string>): void { 443 443 - for (const entry of entries) { 444 444 - const currentPath = pathPrefix ? `${pathPrefix}/${entry.name}` : entry.name; 445 445 - const node = entry.node; 446 446 - 447 447 - if ('type' in node && node.type === 'directory' && 'entries' in node) { 448 448 - collectFileCidsFromEntries(node.entries, currentPath, fileCids); 449 449 - } else if ('type' in node && node.type === 'file' && 'blob' in node) { 450 450 - const fileNode = node as File; 451 451 - const cid = extractBlobCid(fileNode.blob); 452 452 - if (cid) { 453 453 - fileCids[currentPath] = cid; 454 454 - } 455 455 - } 456 456 - } 457 457 - } 458 347 459 348 async function cacheFiles( 460 349 did: string, ··· 661 550 } 662 551 } 663 552 664 664 - /** 665 665 - * Sanitize a file path to prevent directory traversal attacks 666 666 - * Removes any path segments that attempt to go up directories 667 667 - */ 668 668 - export function sanitizePath(filePath: string): string { 669 669 - // Remove leading slashes 670 670 - let cleaned = filePath.replace(/^\/+/, ''); 671 671 - 672 672 - // Split into segments and filter out dangerous ones 673 673 - const segments = cleaned.split('/').filter(segment => { 674 674 - // Remove empty segments 675 675 - if (!segment || segment === '.') return false; 676 676 - // Remove parent directory references 677 677 - if (segment === '..') return false; 678 678 - // Remove segments with null bytes 679 679 - if (segment.includes('\0')) return false; 680 680 - return true; 681 681 - }); 682 682 - 683 683 - // Rejoin the safe segments 684 684 - return segments.join('/'); 685 685 - } 686 553 687 554 export function getCachedFilePath(did: string, site: string, filePath: string): string { 688 555 const sanitizedPath = sanitizePath(filePath);

-1523

hosting-service/src/server.ts

··· 1 1 - import { Hono } from 'hono'; 2 2 - import { cors } from 'hono/cors'; 3 3 - import { getWispDomain, getCustomDomain, getCustomDomainByHash } from './lib/db'; 4 4 - import { resolveDid, getPdsForDid, fetchSiteRecord, downloadAndCacheSite, getCachedFilePath, isCached, sanitizePath, shouldCompressMimeType, getCachedSettings } from './lib/utils'; 5 5 - import type { Record as WispSettings } from './lexicon/types/place/wisp/settings'; 6 6 - import { rewriteHtmlPaths, isHtmlContent } from './lib/html-rewriter'; 7 7 - import { existsSync } from 'fs'; 8 8 - import { readFile, access } from 'fs/promises'; 9 9 - import { lookup } from 'mime-types'; 10 10 - import { logger, observabilityMiddleware, observabilityErrorHandler, logCollector, errorTracker, metricsCollector } from './lib/observability'; 11 11 - import { fileCache, metadataCache, rewrittenHtmlCache, getCacheKey, type FileMetadata, markSiteAsBeingCached, unmarkSiteAsBeingCached, isSiteBeingCached } from './lib/cache'; 12 12 - import { loadRedirectRules, matchRedirectRule, parseCookies, parseQueryString, type RedirectRule } from './lib/redirects'; 13 13 - 14 14 - const BASE_HOST = process.env.BASE_HOST || 'wisp.place'; 15 15 - 16 16 - /** 17 17 - * Default index file names to check for directory requests 18 18 - * Will be checked in order until one is found 19 19 - */ 20 20 - const DEFAULT_INDEX_FILES = ['index.html', 'index.htm']; 21 21 - 22 22 - /** 23 23 - * Get index files list from settings or use defaults 24 24 - */ 25 25 - function getIndexFiles(settings: WispSettings | null): string[] { 26 26 - if (settings?.indexFiles && settings.indexFiles.length > 0) { 27 27 - return settings.indexFiles; 28 28 - } 29 29 - return DEFAULT_INDEX_FILES; 30 30 - } 31 31 - 32 32 - /** 33 33 - * Match a file path against a glob pattern 34 34 - * Supports * wildcard and basic path matching 35 35 - */ 36 36 - function matchGlob(path: string, pattern: string): boolean { 37 37 - // Normalize paths 38 38 - const normalizedPath = path.startsWith('/') ? path : '/' + path; 39 39 - const normalizedPattern = pattern.startsWith('/') ? pattern : '/' + pattern; 40 40 - 41 41 - // Convert glob pattern to regex 42 42 - const regexPattern = normalizedPattern 43 43 - .replace(/\./g, '\\.') 44 44 - .replace(/\*/g, '.*') 45 45 - .replace(/\?/g, '.'); 46 46 - 47 47 - const regex = new RegExp('^' + regexPattern + '$'); 48 48 - return regex.test(normalizedPath); 49 49 - } 50 50 - 51 51 - /** 52 52 - * Apply custom headers from settings to response headers 53 53 - */ 54 54 - function applyCustomHeaders(headers: Record<string, string>, filePath: string, settings: WispSettings | null) { 55 55 - if (!settings?.headers || settings.headers.length === 0) return; 56 56 - 57 57 - for (const customHeader of settings.headers) { 58 58 - // If path glob is specified, check if it matches 59 59 - if (customHeader.path) { 60 60 - if (!matchGlob(filePath, customHeader.path)) { 61 61 - continue; 62 62 - } 63 63 - } 64 64 - // Apply the header 65 65 - headers[customHeader.name] = customHeader.value; 66 66 - } 67 67 - } 68 68 - 69 69 - /** 70 70 - * Generate 404 page HTML 71 71 - */ 72 72 - function generate404Page(): string { 73 73 - const html = `<!DOCTYPE html> 74 74 - <html> 75 75 - <head> 76 76 - <meta charset="utf-8"> 77 77 - <meta name="viewport" content="width=device-width, initial-scale=1"> 78 78 - <title>404 - Not Found</title> 79 79 - <style> 80 80 - @media (prefers-color-scheme: light) { 81 81 - :root { 82 82 - /* Warm beige background */ 83 83 - --background: oklch(0.90 0.012 35); 84 84 - /* Very dark brown text */ 85 85 - --foreground: oklch(0.18 0.01 30); 86 86 - --border: oklch(0.75 0.015 30); 87 87 - /* Bright pink accent for links */ 88 88 - --accent: oklch(0.78 0.15 345); 89 89 - } 90 90 - } 91 91 - @media (prefers-color-scheme: dark) { 92 92 - :root { 93 93 - /* Slate violet background */ 94 94 - --background: oklch(0.23 0.015 285); 95 95 - /* Light gray text */ 96 96 - --foreground: oklch(0.90 0.005 285); 97 97 - /* Subtle borders */ 98 98 - --border: oklch(0.38 0.02 285); 99 99 - /* Soft pink accent */ 100 100 - --accent: oklch(0.85 0.08 5); 101 101 - } 102 102 - } 103 103 - body { 104 104 - font-family: 'SF Mono', Monaco, 'Cascadia Code', 'Roboto Mono', Consolas, 'Courier New', monospace; 105 105 - background: var(--background); 106 106 - color: var(--foreground); 107 107 - padding: 2rem; 108 108 - max-width: 800px; 109 109 - margin: 0 auto; 110 110 - display: flex; 111 111 - flex-direction: column; 112 112 - min-height: 100vh; 113 113 - justify-content: center; 114 114 - align-items: center; 115 115 - text-align: center; 116 116 - } 117 117 - h1 { 118 118 - font-size: 6rem; 119 119 - margin: 0; 120 120 - font-weight: 700; 121 121 - line-height: 1; 122 122 - } 123 123 - h2 { 124 124 - font-size: 1.5rem; 125 125 - margin: 1rem 0 2rem; 126 126 - font-weight: 400; 127 127 - opacity: 0.8; 128 128 - } 129 129 - p { 130 130 - font-size: 1rem; 131 131 - opacity: 0.7; 132 132 - margin-bottom: 2rem; 133 133 - } 134 134 - a { 135 135 - color: var(--accent); 136 136 - text-decoration: none; 137 137 - font-size: 1rem; 138 138 - } 139 139 - a:hover { 140 140 - text-decoration: underline; 141 141 - } 142 142 - footer { 143 143 - margin-top: 2rem; 144 144 - padding-top: 1.5rem; 145 145 - border-top: 1px solid var(--border); 146 146 - text-align: center; 147 147 - font-size: 0.875rem; 148 148 - opacity: 0.7; 149 149 - color: var(--foreground); 150 150 - } 151 151 - footer a { 152 152 - color: var(--accent); 153 153 - text-decoration: none; 154 154 - display: inline; 155 155 - } 156 156 - footer a:hover { 157 157 - text-decoration: underline; 158 158 - } 159 159 - </style> 160 160 - </head> 161 161 - <body> 162 162 - <div> 163 163 - <h1>404</h1> 164 164 - <h2>Page not found</h2> 165 165 - <p>The page you're looking for doesn't exist.</p> 166 166 - <a href="/">← Back to home</a> 167 167 - </div> 168 168 - <footer> 169 169 - Hosted on <a href="https://wisp.place" target="_blank" rel="noopener">wisp.place</a> - Made by <a href="https://bsky.app/profile/nekomimi.pet" target="_blank" rel="noopener">@nekomimi.pet</a> 170 170 - </footer> 171 171 - </body> 172 172 - </html>`; 173 173 - return html; 174 174 - } 175 175 - 176 176 - /** 177 177 - * Generate directory listing HTML 178 178 - */ 179 179 - function generateDirectoryListing(path: string, entries: Array<{name: string, isDirectory: boolean}>): string { 180 180 - const title = path || 'Index'; 181 181 - 182 182 - // Sort: directories first, then files, alphabetically within each group 183 183 - const sortedEntries = [...entries].sort((a, b) => { 184 184 - if (a.isDirectory && !b.isDirectory) return -1; 185 185 - if (!a.isDirectory && b.isDirectory) return 1; 186 186 - return a.name.localeCompare(b.name); 187 187 - }); 188 188 - 189 189 - const html = `<!DOCTYPE html> 190 190 - <html> 191 191 - <head> 192 192 - <meta charset="utf-8"> 193 193 - <meta name="viewport" content="width=device-width, initial-scale=1"> 194 194 - <title>Index of /${path}</title> 195 195 - <style> 196 196 - @media (prefers-color-scheme: light) { 197 197 - :root { 198 198 - /* Warm beige background */ 199 199 - --background: oklch(0.90 0.012 35); 200 200 - /* Very dark brown text */ 201 201 - --foreground: oklch(0.18 0.01 30); 202 202 - --border: oklch(0.75 0.015 30); 203 203 - /* Bright pink accent for links */ 204 204 - --accent: oklch(0.78 0.15 345); 205 205 - /* Lavender for folders */ 206 206 - --folder: oklch(0.60 0.12 295); 207 207 - --icon: oklch(0.28 0.01 30); 208 208 - } 209 209 - } 210 210 - @media (prefers-color-scheme: dark) { 211 211 - :root { 212 212 - /* Slate violet background */ 213 213 - --background: oklch(0.23 0.015 285); 214 214 - /* Light gray text */ 215 215 - --foreground: oklch(0.90 0.005 285); 216 216 - /* Subtle borders */ 217 217 - --border: oklch(0.38 0.02 285); 218 218 - /* Soft pink accent */ 219 219 - --accent: oklch(0.85 0.08 5); 220 220 - /* Lavender for folders */ 221 221 - --folder: oklch(0.70 0.10 295); 222 222 - --icon: oklch(0.85 0.005 285); 223 223 - } 224 224 - } 225 225 - body { 226 226 - font-family: 'SF Mono', Monaco, 'Cascadia Code', 'Roboto Mono', Consolas, 'Courier New', monospace; 227 227 - background: var(--background); 228 228 - color: var(--foreground); 229 229 - padding: 2rem; 230 230 - max-width: 800px; 231 231 - margin: 0 auto; 232 232 - } 233 233 - h1 { 234 234 - font-size: 1.5rem; 235 235 - margin-bottom: 2rem; 236 236 - padding-bottom: 0.5rem; 237 237 - border-bottom: 1px solid var(--border); 238 238 - } 239 239 - ul { 240 240 - list-style: none; 241 241 - padding: 0; 242 242 - } 243 243 - li { 244 244 - padding: 0.5rem 0; 245 245 - border-bottom: 1px solid var(--border); 246 246 - } 247 247 - li:last-child { 248 248 - border-bottom: none; 249 249 - } 250 250 - li a { 251 251 - color: var(--accent); 252 252 - text-decoration: none; 253 253 - display: flex; 254 254 - align-items: center; 255 255 - gap: 0.75rem; 256 256 - } 257 257 - li a:hover { 258 258 - text-decoration: underline; 259 259 - } 260 260 - .folder { 261 261 - color: var(--folder); 262 262 - font-weight: 600; 263 263 - } 264 264 - .file { 265 265 - color: var(--accent); 266 266 - } 267 267 - .folder::before, 268 268 - .file::before, 269 269 - .parent::before { 270 270 - content: ""; 271 271 - display: inline-block; 272 272 - width: 1.25em; 273 273 - height: 1.25em; 274 274 - background-color: var(--icon); 275 275 - flex-shrink: 0; 276 276 - -webkit-mask-size: contain; 277 277 - mask-size: contain; 278 278 - -webkit-mask-repeat: no-repeat; 279 279 - mask-repeat: no-repeat; 280 280 - -webkit-mask-position: center; 281 281 - mask-position: center; 282 282 - } 283 283 - .folder::before { 284 284 - -webkit-mask-image: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><path d="M64 15v37a5.006 5.006 0 0 1-5 5H5a5.006 5.006 0 0 1-5-5V12a5.006 5.006 0 0 1 5-5h14.116a6.966 6.966 0 0 1 5.466 2.627l5 6.247A2.983 2.983 0 0 0 31.922 17H59a1 1 0 0 1 0 2H31.922a4.979 4.979 0 0 1-3.9-1.876l-5-6.247A4.976 4.976 0 0 0 19.116 9H5a3 3 0 0 0-3 3v40a3 3 0 0 0 3 3h54a3 3 0 0 0 3-3V15a3 3 0 0 0-3-3H30a1 1 0 0 1 0-2h29a5.006 5.006 0 0 1 5 5z"/></svg>'); 285 285 - mask-image: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><path d="M64 15v37a5.006 5.006 0 0 1-5 5H5a5.006 5.006 0 0 1-5-5V12a5.006 5.006 0 0 1 5-5h14.116a6.966 6.966 0 0 1 5.466 2.627l5 6.247A2.983 2.983 0 0 0 31.922 17H59a1 1 0 0 1 0 2H31.922a4.979 4.979 0 0 1-3.9-1.876l-5-6.247A4.976 4.976 0 0 0 19.116 9H5a3 3 0 0 0-3 3v40a3 3 0 0 0 3 3h54a3 3 0 0 0 3-3V15a3 3 0 0 0-3-3H30a1 1 0 0 1 0-2h29a5.006 5.006 0 0 1 5 5z"/></svg>'); 286 286 - } 287 287 - .file::before { 288 288 - -webkit-mask-image: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 25 25"><g><path d="M18 8.28a.59.59 0 0 0-.13-.18l-4-3.9h-.05a.41.41 0 0 0-.15-.2.41.41 0 0 0-.19 0h-9a.5.5 0 0 0-.5.5v19a.5.5 0 0 0 .5.5h13a.5.5 0 0 0 .5-.5V8.43a.58.58 0 0 0 .02-.15zM16.3 8H14V5.69zM5 23V5h8v3.5a.49.49 0 0 0 .15.36.5.5 0 0 0 .35.14l3.5-.06V23z"/><path d="M20.5 1h-13a.5.5 0 0 0-.5.5V3a.5.5 0 0 0 1 0V2h12v18h-1a.5.5 0 0 0 0 1h1.5a.5.5 0 0 0 .5-.5v-19a.5.5 0 0 0-.5-.5z"/><path d="M7.5 8h3a.5.5 0 0 0 0-1h-3a.5.5 0 0 0 0 1zM7.5 11h4a.5.5 0 0 0 0-1h-4a.5.5 0 0 0 0 1zM13.5 13h-6a.5.5 0 0 0 0 1h6a.5.5 0 0 0 0-1zM13.5 16h-6a.5.5 0 0 0 0 1h6a.5.5 0 0 0 0-1zM13.5 19h-6a.5.5 0 0 0 0 1h6a.5.5 0 0 0 0-1z"/></g></svg>'); 289 289 - mask-image: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 25 25"><g><path d="M18 8.28a.59.59 0 0 0-.13-.18l-4-3.9h-.05a.41.41 0 0 0-.15-.2.41.41 0 0 0-.19 0h-9a.5.5 0 0 0-.5.5v19a.5.5 0 0 0 .5.5h13a.5.5 0 0 0 .5-.5V8.43a.58.58 0 0 0 .02-.15zM16.3 8H14V5.69zM5 23V5h8v3.5a.49.49 0 0 0 .15.36.5.5 0 0 0 .35.14l3.5-.06V23z"/><path d="M20.5 1h-13a.5.5 0 0 0-.5.5V3a.5.5 0 0 0 1 0V2h12v18h-1a.5.5 0 0 0 0 1h1.5a.5.5 0 0 0 .5-.5v-19a.5.5 0 0 0-.5-.5z"/><path d="M7.5 8h3a.5.5 0 0 0 0-1h-3a.5.5 0 0 0 0 1zM7.5 11h4a.5.5 0 0 0 0-1h-4a.5.5 0 0 0 0 1zM13.5 13h-6a.5.5 0 0 0 0 1h6a.5.5 0 0 0 0-1zM13.5 16h-6a.5.5 0 0 0 0 1h6a.5.5 0 0 0 0-1zM13.5 19h-6a.5.5 0 0 0 0 1h6a.5.5 0 0 0 0-1z"/></g></svg>'); 290 290 - } 291 291 - .parent::before { 292 292 - -webkit-mask-image: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M7.41 15.41L12 10.83l4.59 4.58L18 14l-6-6-6 6z"/></svg>'); 293 293 - mask-image: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M7.41 15.41L12 10.83l4.59 4.58L18 14l-6-6-6 6z"/></svg>'); 294 294 - } 295 295 - footer { 296 296 - margin-top: 2rem; 297 297 - padding-top: 1.5rem; 298 298 - border-top: 1px solid var(--border); 299 299 - text-align: center; 300 300 - font-size: 0.875rem; 301 301 - opacity: 0.7; 302 302 - color: var(--foreground); 303 303 - } 304 304 - footer a { 305 305 - color: var(--accent); 306 306 - text-decoration: none; 307 307 - display: inline; 308 308 - } 309 309 - footer a:hover { 310 310 - text-decoration: underline; 311 311 - } 312 312 - </style> 313 313 - </head> 314 314 - <body> 315 315 - <h1>Index of /${path}</h1> 316 316 - <ul> 317 317 - ${path ? '<li><a href="../" class="parent">../</a></li>' : ''} 318 318 - ${sortedEntries.map(e => 319 319 - `<li><a href="${e.name}${e.isDirectory ? '/' : ''}" class="${e.isDirectory ? 'folder' : 'file'}">${e.name}${e.isDirectory ? '/' : ''}</a></li>` 320 320 - ).join('\n ')} 321 321 - </ul> 322 322 - <footer> 323 323 - Hosted on <a href="https://wisp.place" target="_blank" rel="noopener">wisp.place</a> - Made by <a href="https://bsky.app/profile/nekomimi.pet" target="_blank" rel="noopener">@nekomimi.pet</a> 324 324 - </footer> 325 325 - </body> 326 326 - </html>`; 327 327 - return html; 328 328 - } 329 329 - 330 330 - /** 331 331 - * Validate site name (rkey) to prevent injection attacks 332 332 - * Must match AT Protocol rkey format 333 333 - */ 334 334 - function isValidRkey(rkey: string): boolean { 335 335 - if (!rkey || typeof rkey !== 'string') return false; 336 336 - if (rkey.length < 1 || rkey.length > 512) return false; 337 337 - if (rkey === '.' || rkey === '..') return false; 338 338 - if (rkey.includes('/') || rkey.includes('\\') || rkey.includes('\0')) return false; 339 339 - const validRkeyPattern = /^[a-zA-Z0-9._~:-]+$/; 340 340 - return validRkeyPattern.test(rkey); 341 341 - } 342 342 - 343 343 - /** 344 344 - * Async file existence check 345 345 - */ 346 346 - async function fileExists(path: string): Promise<boolean> { 347 347 - try { 348 348 - await access(path); 349 349 - return true; 350 350 - } catch { 351 351 - return false; 352 352 - } 353 353 - } 354 354 - 355 355 - /** 356 356 - * Return a response indicating the site is being updated 357 357 - */ 358 358 - function siteUpdatingResponse(): Response { 359 359 - const html = `<!DOCTYPE html> 360 360 - <html> 361 361 - <head> 362 362 - <meta charset="utf-8"> 363 363 - <meta name="viewport" content="width=device-width, initial-scale=1"> 364 364 - <title>Site Updating</title> 365 365 - <style> 366 366 - @media (prefers-color-scheme: light) { 367 367 - :root { 368 368 - --background: oklch(0.90 0.012 35); 369 369 - --foreground: oklch(0.18 0.01 30); 370 370 - --primary: oklch(0.35 0.02 35); 371 371 - --accent: oklch(0.78 0.15 345); 372 372 - } 373 373 - } 374 374 - @media (prefers-color-scheme: dark) { 375 375 - :root { 376 376 - --background: oklch(0.23 0.015 285); 377 377 - --foreground: oklch(0.90 0.005 285); 378 378 - --primary: oklch(0.70 0.10 295); 379 379 - --accent: oklch(0.85 0.08 5); 380 380 - } 381 381 - } 382 382 - body { 383 383 - font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; 384 384 - display: flex; 385 385 - align-items: center; 386 386 - justify-content: center; 387 387 - min-height: 100vh; 388 388 - margin: 0; 389 389 - background: var(--background); 390 390 - color: var(--foreground); 391 391 - } 392 392 - .container { 393 393 - text-align: center; 394 394 - padding: 2rem; 395 395 - max-width: 500px; 396 396 - } 397 397 - h1 { 398 398 - font-size: 2.5rem; 399 399 - margin-bottom: 1rem; 400 400 - font-weight: 600; 401 401 - color: var(--primary); 402 402 - } 403 403 - p { 404 404 - font-size: 1.25rem; 405 405 - opacity: 0.8; 406 406 - margin-bottom: 2rem; 407 407 - color: var(--foreground); 408 408 - } 409 409 - .spinner { 410 410 - border: 4px solid var(--accent); 411 411 - border-radius: 50%; 412 412 - border-top: 4px solid var(--primary); 413 413 - width: 40px; 414 414 - height: 40px; 415 415 - animation: spin 1s linear infinite; 416 416 - margin: 0 auto; 417 417 - } 418 418 - @keyframes spin { 419 419 - 0% { transform: rotate(0deg); } 420 420 - 100% { transform: rotate(360deg); } 421 421 - } 422 422 - </style> 423 423 - <meta http-equiv="refresh" content="3"> 424 424 - </head> 425 425 - <body> 426 426 - <div class="container"> 427 427 - <h1>Site Updating</h1> 428 428 - <p>This site is undergoing an update right now. Check back in a moment...</p> 429 429 - <div class="spinner"></div> 430 430 - </div> 431 431 - </body> 432 432 - </html>`; 433 433 - 434 434 - return new Response(html, { 435 435 - status: 503, 436 436 - headers: { 437 437 - 'Content-Type': 'text/html; charset=utf-8', 438 438 - 'Cache-Control': 'no-store, no-cache, must-revalidate', 439 439 - 'Retry-After': '3', 440 440 - }, 441 441 - }); 442 442 - } 443 443 - 444 444 - // Cache for redirect rules (per site) 445 445 - const redirectRulesCache = new Map<string, RedirectRule[]>(); 446 446 - 447 447 - /** 448 448 - * Clear redirect rules cache for a specific site 449 449 - * Should be called when a site is updated/recached 450 450 - */ 451 451 - export function clearRedirectRulesCache(did: string, rkey: string) { 452 452 - const cacheKey = `${did}:${rkey}`; 453 453 - redirectRulesCache.delete(cacheKey); 454 454 - } 455 455 - 456 456 - // Helper to serve files from cache 457 457 - async function serveFromCache( 458 458 - did: string, 459 459 - rkey: string, 460 460 - filePath: string, 461 461 - fullUrl?: string, 462 462 - headers?: Record<string, string> 463 463 - ) { 464 464 - // Load settings for this site 465 465 - const settings = await getCachedSettings(did, rkey); 466 466 - const indexFiles = getIndexFiles(settings); 467 467 - 468 468 - // Check for redirect rules first (_redirects wins over settings) 469 469 - const redirectCacheKey = `${did}:${rkey}`; 470 470 - let redirectRules = redirectRulesCache.get(redirectCacheKey); 471 471 - 472 472 - if (redirectRules === undefined) { 473 473 - // Load rules for the first time 474 474 - redirectRules = await loadRedirectRules(did, rkey); 475 475 - redirectRulesCache.set(redirectCacheKey, redirectRules); 476 476 - } 477 477 - 478 478 - // Apply redirect rules if any exist 479 479 - if (redirectRules.length > 0) { 480 480 - const requestPath = '/' + (filePath || ''); 481 481 - const queryParams = fullUrl ? parseQueryString(fullUrl) : {}; 482 482 - const cookies = parseCookies(headers?.['cookie']); 483 483 - 484 484 - const redirectMatch = matchRedirectRule(requestPath, redirectRules, { 485 485 - queryParams, 486 486 - headers, 487 487 - cookies, 488 488 - }); 489 489 - 490 490 - if (redirectMatch) { 491 491 - const { rule, targetPath, status } = redirectMatch; 492 492 - 493 493 - // If not forced, check if the requested file exists before redirecting 494 494 - if (!rule.force) { 495 495 - // Build the expected file path 496 496 - let checkPath = filePath || indexFiles[0]; 497 497 - if (checkPath.endsWith('/')) { 498 498 - checkPath += indexFiles[0]; 499 499 - } 500 500 - 501 501 - const cachedFile = getCachedFilePath(did, rkey, checkPath); 502 502 - const fileExistsOnDisk = await fileExists(cachedFile); 503 503 - 504 504 - // If file exists and redirect is not forced, serve the file normally 505 505 - if (fileExistsOnDisk) { 506 506 - return serveFileInternal(did, rkey, filePath, settings); 507 507 - } 508 508 - } 509 509 - 510 510 - // Handle different status codes 511 511 - if (status === 200) { 512 512 - // Rewrite: serve different content but keep URL the same 513 513 - // Remove leading slash for internal path resolution 514 514 - const rewritePath = targetPath.startsWith('/') ? targetPath.slice(1) : targetPath; 515 515 - return serveFileInternal(did, rkey, rewritePath, settings); 516 516 - } else if (status === 301 || status === 302) { 517 517 - // External redirect: change the URL 518 518 - return new Response(null, { 519 519 - status, 520 520 - headers: { 521 521 - 'Location': targetPath, 522 522 - 'Cache-Control': status === 301 ? 'public, max-age=31536000' : 'public, max-age=0', 523 523 - }, 524 524 - }); 525 525 - } else if (status === 404) { 526 526 - // Custom 404 page from _redirects (wins over settings.custom404) 527 527 - const custom404Path = targetPath.startsWith('/') ? targetPath.slice(1) : targetPath; 528 528 - const response = await serveFileInternal(did, rkey, custom404Path, settings); 529 529 - // Override status to 404 530 530 - return new Response(response.body, { 531 531 - status: 404, 532 532 - headers: response.headers, 533 533 - }); 534 534 - } 535 535 - } 536 536 - } 537 537 - 538 538 - // No redirect matched, serve normally with settings 539 539 - return serveFileInternal(did, rkey, filePath, settings); 540 540 - } 541 541 - 542 542 - // Internal function to serve a file (used by both normal serving and rewrites) 543 543 - async function serveFileInternal(did: string, rkey: string, filePath: string, settings: WispSettings | null = null) { 544 544 - // Check if site is currently being cached - if so, return updating response 545 545 - if (isSiteBeingCached(did, rkey)) { 546 546 - return siteUpdatingResponse(); 547 547 - } 548 548 - 549 549 - const indexFiles = getIndexFiles(settings); 550 550 - 551 551 - // Normalize the request path (keep empty for root, remove trailing slash for others) 552 552 - let requestPath = filePath || ''; 553 553 - if (requestPath.endsWith('/') && requestPath.length > 1) { 554 554 - requestPath = requestPath.slice(0, -1); 555 555 - } 556 556 - 557 557 - // Check if this path is a directory first 558 558 - const directoryPath = getCachedFilePath(did, rkey, requestPath); 559 559 - if (await fileExists(directoryPath)) { 560 560 - const { stat, readdir } = await import('fs/promises'); 561 561 - try { 562 562 - const stats = await stat(directoryPath); 563 563 - if (stats.isDirectory()) { 564 564 - // It's a directory, try each index file in order 565 565 - for (const indexFile of indexFiles) { 566 566 - const indexPath = requestPath ? `${requestPath}/${indexFile}` : indexFile; 567 567 - const indexFilePath = getCachedFilePath(did, rkey, indexPath); 568 568 - if (await fileExists(indexFilePath)) { 569 569 - return serveFileInternal(did, rkey, indexPath, settings); 570 570 - } 571 571 - } 572 572 - // No index file found - check if directory listing is enabled 573 573 - if (settings?.directoryListing) { 574 574 - const { stat } = await import('fs/promises'); 575 575 - const entries = await readdir(directoryPath); 576 576 - // Filter out .meta files and other hidden files 577 577 - const visibleEntries = entries.filter(entry => !entry.endsWith('.meta') && entry !== '.metadata.json'); 578 578 - 579 579 - // Check which entries are directories 580 580 - const entriesWithType = await Promise.all( 581 581 - visibleEntries.map(async (name) => { 582 582 - try { 583 583 - const entryPath = `${directoryPath}/${name}`; 584 584 - const stats = await stat(entryPath); 585 585 - return { name, isDirectory: stats.isDirectory() }; 586 586 - } catch { 587 587 - return { name, isDirectory: false }; 588 588 - } 589 589 - }) 590 590 - ); 591 591 - 592 592 - const html = generateDirectoryListing(requestPath, entriesWithType); 593 593 - return new Response(html, { 594 594 - headers: { 595 595 - 'Content-Type': 'text/html; charset=utf-8', 596 596 - 'Cache-Control': 'public, max-age=300', 597 597 - }, 598 598 - }); 599 599 - } 600 600 - // Fall through to 404/SPA handling 601 601 - } 602 602 - } catch (err) { 603 603 - // If stat fails, continue with normal flow 604 604 - } 605 605 - } 606 606 - 607 607 - // Not a directory, try to serve as a file 608 608 - const fileRequestPath = requestPath || indexFiles[0]; 609 609 - const cacheKey = getCacheKey(did, rkey, fileRequestPath); 610 610 - const cachedFile = getCachedFilePath(did, rkey, fileRequestPath); 611 611 - 612 612 - // Check in-memory cache first 613 613 - let content = fileCache.get(cacheKey); 614 614 - let meta = metadataCache.get(cacheKey); 615 615 - 616 616 - if (!content && await fileExists(cachedFile)) { 617 617 - // Read from disk and cache 618 618 - content = await readFile(cachedFile); 619 619 - fileCache.set(cacheKey, content, content.length); 620 620 - 621 621 - const metaFile = `${cachedFile}.meta`; 622 622 - if (await fileExists(metaFile)) { 623 623 - const metaJson = await readFile(metaFile, 'utf-8'); 624 624 - meta = JSON.parse(metaJson); 625 625 - metadataCache.set(cacheKey, meta!, JSON.stringify(meta).length); 626 626 - } 627 627 - } 628 628 - 629 629 - if (content) { 630 630 - // Build headers with caching 631 631 - const headers: Record<string, string> = {}; 632 632 - 633 633 - if (meta && meta.encoding === 'gzip' && meta.mimeType) { 634 634 - const shouldServeCompressed = shouldCompressMimeType(meta.mimeType); 635 635 - 636 636 - if (!shouldServeCompressed) { 637 637 - // Verify content is actually gzipped before attempting decompression 638 638 - const isGzipped = content.length >= 2 && content[0] === 0x1f && content[1] === 0x8b; 639 639 - if (isGzipped) { 640 640 - const { gunzipSync } = await import('zlib'); 641 641 - const decompressed = gunzipSync(content); 642 642 - headers['Content-Type'] = meta.mimeType; 643 643 - headers['Cache-Control'] = 'public, max-age=31536000, immutable'; 644 644 - applyCustomHeaders(headers, fileRequestPath, settings); 645 645 - return new Response(decompressed, { headers }); 646 646 - } else { 647 647 - // Meta says gzipped but content isn't - serve as-is 648 648 - console.warn(`File ${filePath} has gzip encoding in meta but content lacks gzip magic bytes`); 649 649 - headers['Content-Type'] = meta.mimeType; 650 650 - headers['Cache-Control'] = 'public, max-age=31536000, immutable'; 651 651 - applyCustomHeaders(headers, fileRequestPath, settings); 652 652 - return new Response(content, { headers }); 653 653 - } 654 654 - } 655 655 - 656 656 - headers['Content-Type'] = meta.mimeType; 657 657 - headers['Content-Encoding'] = 'gzip'; 658 658 - headers['Cache-Control'] = meta.mimeType.startsWith('text/html') 659 659 - ? 'public, max-age=300' 660 660 - : 'public, max-age=31536000, immutable'; 661 661 - applyCustomHeaders(headers, fileRequestPath, settings); 662 662 - return new Response(content, { headers }); 663 663 - } 664 664 - 665 665 - // Non-compressed files 666 666 - const mimeType = lookup(cachedFile) || 'application/octet-stream'; 667 667 - headers['Content-Type'] = mimeType; 668 668 - headers['Cache-Control'] = mimeType.startsWith('text/html') 669 669 - ? 'public, max-age=300' 670 670 - : 'public, max-age=31536000, immutable'; 671 671 - applyCustomHeaders(headers, fileRequestPath, settings); 672 672 - return new Response(content, { headers }); 673 673 - } 674 674 - 675 675 - // Try index files for directory-like paths 676 676 - if (!fileRequestPath.includes('.')) { 677 677 - for (const indexFileName of indexFiles) { 678 678 - const indexPath = fileRequestPath ? `${fileRequestPath}/${indexFileName}` : indexFileName; 679 679 - const indexCacheKey = getCacheKey(did, rkey, indexPath); 680 680 - const indexFile = getCachedFilePath(did, rkey, indexPath); 681 681 - 682 682 - let indexContent = fileCache.get(indexCacheKey); 683 683 - let indexMeta = metadataCache.get(indexCacheKey); 684 684 - 685 685 - if (!indexContent && await fileExists(indexFile)) { 686 686 - indexContent = await readFile(indexFile); 687 687 - fileCache.set(indexCacheKey, indexContent, indexContent.length); 688 688 - 689 689 - const indexMetaFile = `${indexFile}.meta`; 690 690 - if (await fileExists(indexMetaFile)) { 691 691 - const metaJson = await readFile(indexMetaFile, 'utf-8'); 692 692 - indexMeta = JSON.parse(metaJson); 693 693 - metadataCache.set(indexCacheKey, indexMeta!, JSON.stringify(indexMeta).length); 694 694 - } 695 695 - } 696 696 - 697 697 - if (indexContent) { 698 698 - const headers: Record<string, string> = { 699 699 - 'Content-Type': 'text/html; charset=utf-8', 700 700 - 'Cache-Control': 'public, max-age=300', 701 701 - }; 702 702 - 703 703 - if (indexMeta && indexMeta.encoding === 'gzip') { 704 704 - headers['Content-Encoding'] = 'gzip'; 705 705 - } 706 706 - 707 707 - applyCustomHeaders(headers, indexPath, settings); 708 708 - return new Response(indexContent, { headers }); 709 709 - } 710 710 - } 711 711 - } 712 712 - 713 713 - // Try clean URLs: /about -> /about.html 714 714 - if (settings?.cleanUrls && !fileRequestPath.includes('.')) { 715 715 - const htmlPath = `${fileRequestPath}.html`; 716 716 - const htmlFile = getCachedFilePath(did, rkey, htmlPath); 717 717 - if (await fileExists(htmlFile)) { 718 718 - return serveFileInternal(did, rkey, htmlPath, settings); 719 719 - } 720 720 - 721 721 - // Also try /about/index.html 722 722 - for (const indexFileName of indexFiles) { 723 723 - const indexPath = fileRequestPath ? `${fileRequestPath}/${indexFileName}` : indexFileName; 724 724 - const indexFile = getCachedFilePath(did, rkey, indexPath); 725 725 - if (await fileExists(indexFile)) { 726 726 - return serveFileInternal(did, rkey, indexPath, settings); 727 727 - } 728 728 - } 729 729 - } 730 730 - 731 731 - // SPA mode: serve SPA file for all non-existing routes (wins over custom404 but loses to _redirects) 732 732 - if (settings?.spaMode) { 733 733 - const spaFile = settings.spaMode; 734 734 - const spaFilePath = getCachedFilePath(did, rkey, spaFile); 735 735 - if (await fileExists(spaFilePath)) { 736 736 - return serveFileInternal(did, rkey, spaFile, settings); 737 737 - } 738 738 - } 739 739 - 740 740 - // Custom 404: serve custom 404 file if configured (wins conflict battle) 741 741 - if (settings?.custom404) { 742 742 - const custom404File = settings.custom404; 743 743 - const custom404Path = getCachedFilePath(did, rkey, custom404File); 744 744 - if (await fileExists(custom404Path)) { 745 745 - const response = await serveFileInternal(did, rkey, custom404File, settings); 746 746 - // Override status to 404 747 747 - return new Response(response.body, { 748 748 - status: 404, 749 749 - headers: response.headers, 750 750 - }); 751 751 - } 752 752 - } 753 753 - 754 754 - // Autodetect 404 pages (GitHub Pages: 404.html, Neocities/Nekoweb: not_found.html) 755 755 - const auto404Pages = ['404.html', 'not_found.html']; 756 756 - for (const auto404Page of auto404Pages) { 757 757 - const auto404Path = getCachedFilePath(did, rkey, auto404Page); 758 758 - if (await fileExists(auto404Path)) { 759 759 - const response = await serveFileInternal(did, rkey, auto404Page, settings); 760 760 - // Override status to 404 761 761 - return new Response(response.body, { 762 762 - status: 404, 763 763 - headers: response.headers, 764 764 - }); 765 765 - } 766 766 - } 767 767 - 768 768 - // Directory listing fallback: if enabled, show root directory listing on 404 769 769 - if (settings?.directoryListing) { 770 770 - const rootPath = getCachedFilePath(did, rkey, ''); 771 771 - if (await fileExists(rootPath)) { 772 772 - const { stat, readdir } = await import('fs/promises'); 773 773 - try { 774 774 - const stats = await stat(rootPath); 775 775 - if (stats.isDirectory()) { 776 776 - const entries = await readdir(rootPath); 777 777 - // Filter out .meta files and metadata 778 778 - const visibleEntries = entries.filter(entry => 779 779 - !entry.endsWith('.meta') && entry !== '.metadata.json' 780 780 - ); 781 781 - 782 782 - // Check which entries are directories 783 783 - const entriesWithType = await Promise.all( 784 784 - visibleEntries.map(async (name) => { 785 785 - try { 786 786 - const entryPath = `${rootPath}/${name}`; 787 787 - const entryStats = await stat(entryPath); 788 788 - return { name, isDirectory: entryStats.isDirectory() }; 789 789 - } catch { 790 790 - return { name, isDirectory: false }; 791 791 - } 792 792 - }) 793 793 - ); 794 794 - 795 795 - const html = generateDirectoryListing('', entriesWithType); 796 796 - return new Response(html, { 797 797 - status: 404, 798 798 - headers: { 799 799 - 'Content-Type': 'text/html; charset=utf-8', 800 800 - 'Cache-Control': 'public, max-age=300', 801 801 - }, 802 802 - }); 803 803 - } 804 804 - } catch (err) { 805 805 - // If directory listing fails, fall through to 404 806 806 - } 807 807 - } 808 808 - } 809 809 - 810 810 - // Default styled 404 page 811 811 - const html = generate404Page(); 812 812 - return new Response(html, { 813 813 - status: 404, 814 814 - headers: { 815 815 - 'Content-Type': 'text/html; charset=utf-8', 816 816 - 'Cache-Control': 'public, max-age=300', 817 817 - }, 818 818 - }); 819 819 - } 820 820 - 821 821 - // Helper to serve files from cache with HTML path rewriting for sites.wisp.place routes 822 822 - async function serveFromCacheWithRewrite( 823 823 - did: string, 824 824 - rkey: string, 825 825 - filePath: string, 826 826 - basePath: string, 827 827 - fullUrl?: string, 828 828 - headers?: Record<string, string> 829 829 - ) { 830 830 - // Load settings for this site 831 831 - const settings = await getCachedSettings(did, rkey); 832 832 - const indexFiles = getIndexFiles(settings); 833 833 - 834 834 - // Check for redirect rules first (_redirects wins over settings) 835 835 - const redirectCacheKey = `${did}:${rkey}`; 836 836 - let redirectRules = redirectRulesCache.get(redirectCacheKey); 837 837 - 838 838 - if (redirectRules === undefined) { 839 839 - // Load rules for the first time 840 840 - redirectRules = await loadRedirectRules(did, rkey); 841 841 - redirectRulesCache.set(redirectCacheKey, redirectRules); 842 842 - } 843 843 - 844 844 - // Apply redirect rules if any exist 845 845 - if (redirectRules.length > 0) { 846 846 - const requestPath = '/' + (filePath || ''); 847 847 - const queryParams = fullUrl ? parseQueryString(fullUrl) : {}; 848 848 - const cookies = parseCookies(headers?.['cookie']); 849 849 - 850 850 - const redirectMatch = matchRedirectRule(requestPath, redirectRules, { 851 851 - queryParams, 852 852 - headers, 853 853 - cookies, 854 854 - }); 855 855 - 856 856 - if (redirectMatch) { 857 857 - const { rule, targetPath, status } = redirectMatch; 858 858 - 859 859 - // If not forced, check if the requested file exists before redirecting 860 860 - if (!rule.force) { 861 861 - // Build the expected file path 862 862 - let checkPath = filePath || indexFiles[0]; 863 863 - if (checkPath.endsWith('/')) { 864 864 - checkPath += indexFiles[0]; 865 865 - } 866 866 - 867 867 - const cachedFile = getCachedFilePath(did, rkey, checkPath); 868 868 - const fileExistsOnDisk = await fileExists(cachedFile); 869 869 - 870 870 - // If file exists and redirect is not forced, serve the file normally 871 871 - if (fileExistsOnDisk) { 872 872 - return serveFileInternalWithRewrite(did, rkey, filePath, basePath, settings); 873 873 - } 874 874 - } 875 875 - 876 876 - // Handle different status codes 877 877 - if (status === 200) { 878 878 - // Rewrite: serve different content but keep URL the same 879 879 - const rewritePath = targetPath.startsWith('/') ? targetPath.slice(1) : targetPath; 880 880 - return serveFileInternalWithRewrite(did, rkey, rewritePath, basePath, settings); 881 881 - } else if (status === 301 || status === 302) { 882 882 - // External redirect: change the URL 883 883 - // For sites.wisp.place, we need to adjust the target path to include the base path 884 884 - // unless it's an absolute URL 885 885 - let redirectTarget = targetPath; 886 886 - if (!targetPath.startsWith('http://') && !targetPath.startsWith('https://')) { 887 887 - redirectTarget = basePath + (targetPath.startsWith('/') ? targetPath.slice(1) : targetPath); 888 888 - } 889 889 - return new Response(null, { 890 890 - status, 891 891 - headers: { 892 892 - 'Location': redirectTarget, 893 893 - 'Cache-Control': status === 301 ? 'public, max-age=31536000' : 'public, max-age=0', 894 894 - }, 895 895 - }); 896 896 - } else if (status === 404) { 897 897 - // Custom 404 page from _redirects (wins over settings.custom404) 898 898 - const custom404Path = targetPath.startsWith('/') ? targetPath.slice(1) : targetPath; 899 899 - const response = await serveFileInternalWithRewrite(did, rkey, custom404Path, basePath, settings); 900 900 - // Override status to 404 901 901 - return new Response(response.body, { 902 902 - status: 404, 903 903 - headers: response.headers, 904 904 - }); 905 905 - } 906 906 - } 907 907 - } 908 908 - 909 909 - // No redirect matched, serve normally with settings 910 910 - return serveFileInternalWithRewrite(did, rkey, filePath, basePath, settings); 911 911 - } 912 912 - 913 913 - // Internal function to serve a file with rewriting 914 914 - async function serveFileInternalWithRewrite(did: string, rkey: string, filePath: string, basePath: string, settings: WispSettings | null = null) { 915 915 - // Check if site is currently being cached - if so, return updating response 916 916 - if (isSiteBeingCached(did, rkey)) { 917 917 - return siteUpdatingResponse(); 918 918 - } 919 919 - 920 920 - const indexFiles = getIndexFiles(settings); 921 921 - 922 922 - // Normalize the request path (keep empty for root, remove trailing slash for others) 923 923 - let requestPath = filePath || ''; 924 924 - if (requestPath.endsWith('/') && requestPath.length > 1) { 925 925 - requestPath = requestPath.slice(0, -1); 926 926 - } 927 927 - 928 928 - // Check if this path is a directory first 929 929 - const directoryPath = getCachedFilePath(did, rkey, requestPath); 930 930 - if (await fileExists(directoryPath)) { 931 931 - const { stat, readdir } = await import('fs/promises'); 932 932 - try { 933 933 - const stats = await stat(directoryPath); 934 934 - if (stats.isDirectory()) { 935 935 - // It's a directory, try each index file in order 936 936 - for (const indexFile of indexFiles) { 937 937 - const indexPath = requestPath ? `${requestPath}/${indexFile}` : indexFile; 938 938 - const indexFilePath = getCachedFilePath(did, rkey, indexPath); 939 939 - if (await fileExists(indexFilePath)) { 940 940 - return serveFileInternalWithRewrite(did, rkey, indexPath, basePath, settings); 941 941 - } 942 942 - } 943 943 - // No index file found - check if directory listing is enabled 944 944 - if (settings?.directoryListing) { 945 945 - const { stat } = await import('fs/promises'); 946 946 - const entries = await readdir(directoryPath); 947 947 - // Filter out .meta files and other hidden files 948 948 - const visibleEntries = entries.filter(entry => !entry.endsWith('.meta') && entry !== '.metadata.json'); 949 949 - 950 950 - // Check which entries are directories 951 951 - const entriesWithType = await Promise.all( 952 952 - visibleEntries.map(async (name) => { 953 953 - try { 954 954 - const entryPath = `${directoryPath}/${name}`; 955 955 - const stats = await stat(entryPath); 956 956 - return { name, isDirectory: stats.isDirectory() }; 957 957 - } catch { 958 958 - return { name, isDirectory: false }; 959 959 - } 960 960 - }) 961 961 - ); 962 962 - 963 963 - const html = generateDirectoryListing(requestPath, entriesWithType); 964 964 - return new Response(html, { 965 965 - headers: { 966 966 - 'Content-Type': 'text/html; charset=utf-8', 967 967 - 'Cache-Control': 'public, max-age=300', 968 968 - }, 969 969 - }); 970 970 - } 971 971 - // Fall through to 404/SPA handling 972 972 - } 973 973 - } catch (err) { 974 974 - // If stat fails, continue with normal flow 975 975 - } 976 976 - } 977 977 - 978 978 - // Not a directory, try to serve as a file 979 979 - const fileRequestPath = requestPath || indexFiles[0]; 980 980 - const cacheKey = getCacheKey(did, rkey, fileRequestPath); 981 981 - const cachedFile = getCachedFilePath(did, rkey, fileRequestPath); 982 982 - 983 983 - // Check for rewritten HTML in cache first (if it's HTML) 984 984 - const mimeTypeGuess = lookup(fileRequestPath) || 'application/octet-stream'; 985 985 - if (isHtmlContent(fileRequestPath, mimeTypeGuess)) { 986 986 - const rewrittenKey = getCacheKey(did, rkey, fileRequestPath, `rewritten:${basePath}`); 987 987 - const rewrittenContent = rewrittenHtmlCache.get(rewrittenKey); 988 988 - if (rewrittenContent) { 989 989 - const headers: Record<string, string> = { 990 990 - 'Content-Type': 'text/html; charset=utf-8', 991 991 - 'Content-Encoding': 'gzip', 992 992 - 'Cache-Control': 'public, max-age=300', 993 993 - }; 994 994 - applyCustomHeaders(headers, fileRequestPath, settings); 995 995 - return new Response(rewrittenContent, { headers }); 996 996 - } 997 997 - } 998 998 - 999 999 - // Check in-memory file cache 1000 1000 - let content = fileCache.get(cacheKey); 1001 1001 - let meta = metadataCache.get(cacheKey); 1002 1002 - 1003 1003 - if (!content && await fileExists(cachedFile)) { 1004 1004 - // Read from disk and cache 1005 1005 - content = await readFile(cachedFile); 1006 1006 - fileCache.set(cacheKey, content, content.length); 1007 1007 - 1008 1008 - const metaFile = `${cachedFile}.meta`; 1009 1009 - if (await fileExists(metaFile)) { 1010 1010 - const metaJson = await readFile(metaFile, 'utf-8'); 1011 1011 - meta = JSON.parse(metaJson); 1012 1012 - metadataCache.set(cacheKey, meta!, JSON.stringify(meta).length); 1013 1013 - } 1014 1014 - } 1015 1015 - 1016 1016 - if (content) { 1017 1017 - const mimeType = meta?.mimeType || lookup(cachedFile) || 'application/octet-stream'; 1018 1018 - const isGzipped = meta?.encoding === 'gzip'; 1019 1019 - 1020 1020 - // Check if this is HTML content that needs rewriting 1021 1021 - if (isHtmlContent(fileRequestPath, mimeType)) { 1022 1022 - let htmlContent: string; 1023 1023 - if (isGzipped) { 1024 1024 - // Verify content is actually gzipped 1025 1025 - const hasGzipMagic = content.length >= 2 && content[0] === 0x1f && content[1] === 0x8b; 1026 1026 - if (hasGzipMagic) { 1027 1027 - const { gunzipSync } = await import('zlib'); 1028 1028 - htmlContent = gunzipSync(content).toString('utf-8'); 1029 1029 - } else { 1030 1030 - console.warn(`File ${fileRequestPath} marked as gzipped but lacks magic bytes, serving as-is`); 1031 1031 - htmlContent = content.toString('utf-8'); 1032 1032 - } 1033 1033 - } else { 1034 1034 - htmlContent = content.toString('utf-8'); 1035 1035 - } 1036 1036 - const rewritten = rewriteHtmlPaths(htmlContent, basePath, fileRequestPath); 1037 1037 - 1038 1038 - // Recompress and cache the rewritten HTML 1039 1039 - const { gzipSync } = await import('zlib'); 1040 1040 - const recompressed = gzipSync(Buffer.from(rewritten, 'utf-8')); 1041 1041 - 1042 1042 - const rewrittenKey = getCacheKey(did, rkey, fileRequestPath, `rewritten:${basePath}`); 1043 1043 - rewrittenHtmlCache.set(rewrittenKey, recompressed, recompressed.length); 1044 1044 - 1045 1045 - const htmlHeaders: Record<string, string> = { 1046 1046 - 'Content-Type': 'text/html; charset=utf-8', 1047 1047 - 'Content-Encoding': 'gzip', 1048 1048 - 'Cache-Control': 'public, max-age=300', 1049 1049 - }; 1050 1050 - applyCustomHeaders(htmlHeaders, fileRequestPath, settings); 1051 1051 - return new Response(recompressed, { headers: htmlHeaders }); 1052 1052 - } 1053 1053 - 1054 1054 - // Non-HTML files: serve as-is 1055 1055 - const headers: Record<string, string> = { 1056 1056 - 'Content-Type': mimeType, 1057 1057 - 'Cache-Control': 'public, max-age=31536000, immutable', 1058 1058 - }; 1059 1059 - 1060 1060 - if (isGzipped) { 1061 1061 - const shouldServeCompressed = shouldCompressMimeType(mimeType); 1062 1062 - if (!shouldServeCompressed) { 1063 1063 - // Verify content is actually gzipped 1064 1064 - const hasGzipMagic = content.length >= 2 && content[0] === 0x1f && content[1] === 0x8b; 1065 1065 - if (hasGzipMagic) { 1066 1066 - const { gunzipSync } = await import('zlib'); 1067 1067 - const decompressed = gunzipSync(content); 1068 1068 - applyCustomHeaders(headers, fileRequestPath, settings); 1069 1069 - return new Response(decompressed, { headers }); 1070 1070 - } else { 1071 1071 - console.warn(`File ${fileRequestPath} marked as gzipped but lacks magic bytes, serving as-is`); 1072 1072 - applyCustomHeaders(headers, fileRequestPath, settings); 1073 1073 - return new Response(content, { headers }); 1074 1074 - } 1075 1075 - } 1076 1076 - headers['Content-Encoding'] = 'gzip'; 1077 1077 - } 1078 1078 - 1079 1079 - applyCustomHeaders(headers, fileRequestPath, settings); 1080 1080 - return new Response(content, { headers }); 1081 1081 - } 1082 1082 - 1083 1083 - // Try index files for directory-like paths 1084 1084 - if (!fileRequestPath.includes('.')) { 1085 1085 - for (const indexFileName of indexFiles) { 1086 1086 - const indexPath = fileRequestPath ? `${fileRequestPath}/${indexFileName}` : indexFileName; 1087 1087 - const indexCacheKey = getCacheKey(did, rkey, indexPath); 1088 1088 - const indexFile = getCachedFilePath(did, rkey, indexPath); 1089 1089 - 1090 1090 - // Check for rewritten index file in cache 1091 1091 - const rewrittenKey = getCacheKey(did, rkey, indexPath, `rewritten:${basePath}`); 1092 1092 - const rewrittenContent = rewrittenHtmlCache.get(rewrittenKey); 1093 1093 - if (rewrittenContent) { 1094 1094 - const headers: Record<string, string> = { 1095 1095 - 'Content-Type': 'text/html; charset=utf-8', 1096 1096 - 'Content-Encoding': 'gzip', 1097 1097 - 'Cache-Control': 'public, max-age=300', 1098 1098 - }; 1099 1099 - applyCustomHeaders(headers, indexPath, settings); 1100 1100 - return new Response(rewrittenContent, { headers }); 1101 1101 - } 1102 1102 - 1103 1103 - let indexContent = fileCache.get(indexCacheKey); 1104 1104 - let indexMeta = metadataCache.get(indexCacheKey); 1105 1105 - 1106 1106 - if (!indexContent && await fileExists(indexFile)) { 1107 1107 - indexContent = await readFile(indexFile); 1108 1108 - fileCache.set(indexCacheKey, indexContent, indexContent.length); 1109 1109 - 1110 1110 - const indexMetaFile = `${indexFile}.meta`; 1111 1111 - if (await fileExists(indexMetaFile)) { 1112 1112 - const metaJson = await readFile(indexMetaFile, 'utf-8'); 1113 1113 - indexMeta = JSON.parse(metaJson); 1114 1114 - metadataCache.set(indexCacheKey, indexMeta!, JSON.stringify(indexMeta).length); 1115 1115 - } 1116 1116 - } 1117 1117 - 1118 1118 - if (indexContent) { 1119 1119 - const isGzipped = indexMeta?.encoding === 'gzip'; 1120 1120 - 1121 1121 - let htmlContent: string; 1122 1122 - if (isGzipped) { 1123 1123 - // Verify content is actually gzipped 1124 1124 - const hasGzipMagic = indexContent.length >= 2 && indexContent[0] === 0x1f && indexContent[1] === 0x8b; 1125 1125 - if (hasGzipMagic) { 1126 1126 - const { gunzipSync } = await import('zlib'); 1127 1127 - htmlContent = gunzipSync(indexContent).toString('utf-8'); 1128 1128 - } else { 1129 1129 - console.warn(`Index file marked as gzipped but lacks magic bytes, serving as-is`); 1130 1130 - htmlContent = indexContent.toString('utf-8'); 1131 1131 - } 1132 1132 - } else { 1133 1133 - htmlContent = indexContent.toString('utf-8'); 1134 1134 - } 1135 1135 - const rewritten = rewriteHtmlPaths(htmlContent, basePath, indexPath); 1136 1136 - 1137 1137 - const { gzipSync } = await import('zlib'); 1138 1138 - const recompressed = gzipSync(Buffer.from(rewritten, 'utf-8')); 1139 1139 - 1140 1140 - rewrittenHtmlCache.set(rewrittenKey, recompressed, recompressed.length); 1141 1141 - 1142 1142 - const headers: Record<string, string> = { 1143 1143 - 'Content-Type': 'text/html; charset=utf-8', 1144 1144 - 'Content-Encoding': 'gzip', 1145 1145 - 'Cache-Control': 'public, max-age=300', 1146 1146 - }; 1147 1147 - applyCustomHeaders(headers, indexPath, settings); 1148 1148 - return new Response(recompressed, { headers }); 1149 1149 - } 1150 1150 - } 1151 1151 - } 1152 1152 - 1153 1153 - // Try clean URLs: /about -> /about.html 1154 1154 - if (settings?.cleanUrls && !fileRequestPath.includes('.')) { 1155 1155 - const htmlPath = `${fileRequestPath}.html`; 1156 1156 - const htmlFile = getCachedFilePath(did, rkey, htmlPath); 1157 1157 - if (await fileExists(htmlFile)) { 1158 1158 - return serveFileInternalWithRewrite(did, rkey, htmlPath, basePath, settings); 1159 1159 - } 1160 1160 - 1161 1161 - // Also try /about/index.html 1162 1162 - for (const indexFileName of indexFiles) { 1163 1163 - const indexPath = fileRequestPath ? `${fileRequestPath}/${indexFileName}` : indexFileName; 1164 1164 - const indexFile = getCachedFilePath(did, rkey, indexPath); 1165 1165 - if (await fileExists(indexFile)) { 1166 1166 - return serveFileInternalWithRewrite(did, rkey, indexPath, basePath, settings); 1167 1167 - } 1168 1168 - } 1169 1169 - } 1170 1170 - 1171 1171 - // SPA mode: serve SPA file for all non-existing routes 1172 1172 - if (settings?.spaMode) { 1173 1173 - const spaFile = settings.spaMode; 1174 1174 - const spaFilePath = getCachedFilePath(did, rkey, spaFile); 1175 1175 - if (await fileExists(spaFilePath)) { 1176 1176 - return serveFileInternalWithRewrite(did, rkey, spaFile, basePath, settings); 1177 1177 - } 1178 1178 - } 1179 1179 - 1180 1180 - // Custom 404: serve custom 404 file if configured (wins conflict battle) 1181 1181 - if (settings?.custom404) { 1182 1182 - const custom404File = settings.custom404; 1183 1183 - const custom404Path = getCachedFilePath(did, rkey, custom404File); 1184 1184 - if (await fileExists(custom404Path)) { 1185 1185 - const response = await serveFileInternalWithRewrite(did, rkey, custom404File, basePath, settings); 1186 1186 - // Override status to 404 1187 1187 - return new Response(response.body, { 1188 1188 - status: 404, 1189 1189 - headers: response.headers, 1190 1190 - }); 1191 1191 - } 1192 1192 - } 1193 1193 - 1194 1194 - // Autodetect 404 pages (GitHub Pages: 404.html, Neocities/Nekoweb: not_found.html) 1195 1195 - const auto404Pages = ['404.html', 'not_found.html']; 1196 1196 - for (const auto404Page of auto404Pages) { 1197 1197 - const auto404Path = getCachedFilePath(did, rkey, auto404Page); 1198 1198 - if (await fileExists(auto404Path)) { 1199 1199 - const response = await serveFileInternalWithRewrite(did, rkey, auto404Page, basePath, settings); 1200 1200 - // Override status to 404 1201 1201 - return new Response(response.body, { 1202 1202 - status: 404, 1203 1203 - headers: response.headers, 1204 1204 - }); 1205 1205 - } 1206 1206 - } 1207 1207 - 1208 1208 - // Directory listing fallback: if enabled, show root directory listing on 404 1209 1209 - if (settings?.directoryListing) { 1210 1210 - const rootPath = getCachedFilePath(did, rkey, ''); 1211 1211 - if (await fileExists(rootPath)) { 1212 1212 - const { stat, readdir } = await import('fs/promises'); 1213 1213 - try { 1214 1214 - const stats = await stat(rootPath); 1215 1215 - if (stats.isDirectory()) { 1216 1216 - const entries = await readdir(rootPath); 1217 1217 - // Filter out .meta files and metadata 1218 1218 - const visibleEntries = entries.filter(entry => 1219 1219 - !entry.endsWith('.meta') && entry !== '.metadata.json' 1220 1220 - ); 1221 1221 - 1222 1222 - // Check which entries are directories 1223 1223 - const entriesWithType = await Promise.all( 1224 1224 - visibleEntries.map(async (name) => { 1225 1225 - try { 1226 1226 - const entryPath = `${rootPath}/${name}`; 1227 1227 - const entryStats = await stat(entryPath); 1228 1228 - return { name, isDirectory: entryStats.isDirectory() }; 1229 1229 - } catch { 1230 1230 - return { name, isDirectory: false }; 1231 1231 - } 1232 1232 - }) 1233 1233 - ); 1234 1234 - 1235 1235 - const html = generateDirectoryListing('', entriesWithType); 1236 1236 - return new Response(html, { 1237 1237 - status: 404, 1238 1238 - headers: { 1239 1239 - 'Content-Type': 'text/html; charset=utf-8', 1240 1240 - 'Cache-Control': 'public, max-age=300', 1241 1241 - }, 1242 1242 - }); 1243 1243 - } 1244 1244 - } catch (err) { 1245 1245 - // If directory listing fails, fall through to 404 1246 1246 - } 1247 1247 - } 1248 1248 - } 1249 1249 - 1250 1250 - // Default styled 404 page 1251 1251 - const html = generate404Page(); 1252 1252 - return new Response(html, { 1253 1253 - status: 404, 1254 1254 - headers: { 1255 1255 - 'Content-Type': 'text/html; charset=utf-8', 1256 1256 - 'Cache-Control': 'public, max-age=300', 1257 1257 - }, 1258 1258 - }); 1259 1259 - } 1260 1260 - 1261 1261 - // Helper to ensure site is cached 1262 1262 - async function ensureSiteCached(did: string, rkey: string): Promise<boolean> { 1263 1263 - if (isCached(did, rkey)) { 1264 1264 - return true; 1265 1265 - } 1266 1266 - 1267 1267 - // Fetch and cache the site 1268 1268 - const siteData = await fetchSiteRecord(did, rkey); 1269 1269 - if (!siteData) { 1270 1270 - logger.error('Site record not found', null, { did, rkey }); 1271 1271 - return false; 1272 1272 - } 1273 1273 - 1274 1274 - const pdsEndpoint = await getPdsForDid(did); 1275 1275 - if (!pdsEndpoint) { 1276 1276 - logger.error('PDS not found for DID', null, { did }); 1277 1277 - return false; 1278 1278 - } 1279 1279 - 1280 1280 - // Mark site as being cached to prevent serving stale content during update 1281 1281 - markSiteAsBeingCached(did, rkey); 1282 1282 - 1283 1283 - try { 1284 1284 - await downloadAndCacheSite(did, rkey, siteData.record, pdsEndpoint, siteData.cid); 1285 1285 - // Clear redirect rules cache since the site was updated 1286 1286 - clearRedirectRulesCache(did, rkey); 1287 1287 - logger.info('Site cached successfully', { did, rkey }); 1288 1288 - return true; 1289 1289 - } catch (err) { 1290 1290 - logger.error('Failed to cache site', err, { did, rkey }); 1291 1291 - return false; 1292 1292 - } finally { 1293 1293 - // Always unmark, even if caching fails 1294 1294 - unmarkSiteAsBeingCached(did, rkey); 1295 1295 - } 1296 1296 - } 1297 1297 - 1298 1298 - const app = new Hono(); 1299 1299 - 1300 1300 - // Add CORS middleware - allow all origins for static site hosting 1301 1301 - app.use('*', cors({ 1302 1302 - origin: '*', 1303 1303 - allowMethods: ['GET', 'HEAD', 'OPTIONS'], 1304 1304 - allowHeaders: ['Content-Type', 'Authorization'], 1305 1305 - exposeHeaders: ['Content-Length', 'Content-Type', 'Content-Encoding', 'Cache-Control'], 1306 1306 - maxAge: 86400, // 24 hours 1307 1307 - credentials: false, 1308 1308 - })); 1309 1309 - 1310 1310 - // Add observability middleware 1311 1311 - app.use('*', observabilityMiddleware('hosting-service')); 1312 1312 - 1313 1313 - // Error handler 1314 1314 - app.onError(observabilityErrorHandler('hosting-service')); 1315 1315 - 1316 1316 - // Main site serving route 1317 1317 - app.get('/*', async (c) => { 1318 1318 - const url = new URL(c.req.url); 1319 1319 - const hostname = c.req.header('host') || ''; 1320 1320 - const rawPath = url.pathname.replace(/^\//, ''); 1321 1321 - const path = sanitizePath(rawPath); 1322 1322 - 1323 1323 - // Check if this is sites.wisp.place subdomain (strip port for comparison) 1324 1324 - const hostnameWithoutPort = hostname.split(':')[0]; 1325 1325 - if (hostnameWithoutPort === `sites.${BASE_HOST}`) { 1326 1326 - // Sanitize the path FIRST to prevent path traversal 1327 1327 - const sanitizedFullPath = sanitizePath(rawPath); 1328 1328 - 1329 1329 - // Extract identifier and site from sanitized path: did:plc:123abc/sitename/file.html 1330 1330 - const pathParts = sanitizedFullPath.split('/'); 1331 1331 - if (pathParts.length < 2) { 1332 1332 - return c.text('Invalid path format. Expected: /identifier/sitename/path', 400); 1333 1333 - } 1334 1334 - 1335 1335 - const identifier = pathParts[0]; 1336 1336 - const site = pathParts[1]; 1337 1337 - const filePath = pathParts.slice(2).join('/'); 1338 1338 - 1339 1339 - // Additional validation: identifier must be a valid DID or handle format 1340 1340 - if (!identifier || identifier.length < 3 || identifier.includes('..') || identifier.includes('\0')) { 1341 1341 - return c.text('Invalid identifier', 400); 1342 1342 - } 1343 1343 - 1344 1344 - // Validate site parameter exists 1345 1345 - if (!site) { 1346 1346 - return c.text('Site name required', 400); 1347 1347 - } 1348 1348 - 1349 1349 - // Validate site name (rkey) 1350 1350 - if (!isValidRkey(site)) { 1351 1351 - return c.text('Invalid site name', 400); 1352 1352 - } 1353 1353 - 1354 1354 - // Resolve identifier to DID 1355 1355 - const did = await resolveDid(identifier); 1356 1356 - if (!did) { 1357 1357 - return c.text('Invalid identifier', 400); 1358 1358 - } 1359 1359 - 1360 1360 - // Check if site is currently being cached - return updating response early 1361 1361 - if (isSiteBeingCached(did, site)) { 1362 1362 - return siteUpdatingResponse(); 1363 1363 - } 1364 1364 - 1365 1365 - // Ensure site is cached 1366 1366 - const cached = await ensureSiteCached(did, site); 1367 1367 - if (!cached) { 1368 1368 - return c.text('Site not found', 404); 1369 1369 - } 1370 1370 - 1371 1371 - // Serve with HTML path rewriting to handle absolute paths 1372 1372 - const basePath = `/${identifier}/${site}/`; 1373 1373 - const headers: Record<string, string> = {}; 1374 1374 - c.req.raw.headers.forEach((value, key) => { 1375 1375 - headers[key.toLowerCase()] = value; 1376 1376 - }); 1377 1377 - return serveFromCacheWithRewrite(did, site, filePath, basePath, c.req.url, headers); 1378 1378 - } 1379 1379 - 1380 1380 - // Check if this is a DNS hash subdomain 1381 1381 - const dnsMatch = hostname.match(/^([a-f0-9]{16})\.dns\.(.+)$/); 1382 1382 - if (dnsMatch) { 1383 1383 - const hash = dnsMatch[1]; 1384 1384 - const baseDomain = dnsMatch[2]; 1385 1385 - 1386 1386 - if (!hash) { 1387 1387 - return c.text('Invalid DNS hash', 400); 1388 1388 - } 1389 1389 - 1390 1390 - if (baseDomain !== BASE_HOST) { 1391 1391 - return c.text('Invalid base domain', 400); 1392 1392 - } 1393 1393 - 1394 1394 - const customDomain = await getCustomDomainByHash(hash); 1395 1395 - if (!customDomain) { 1396 1396 - return c.text('Custom domain not found or not verified', 404); 1397 1397 - } 1398 1398 - 1399 1399 - if (!customDomain.rkey) { 1400 1400 - return c.text('Domain not mapped to a site', 404); 1401 1401 - } 1402 1402 - 1403 1403 - const rkey = customDomain.rkey; 1404 1404 - if (!isValidRkey(rkey)) { 1405 1405 - return c.text('Invalid site configuration', 500); 1406 1406 - } 1407 1407 - 1408 1408 - // Check if site is currently being cached - return updating response early 1409 1409 - if (isSiteBeingCached(customDomain.did, rkey)) { 1410 1410 - return siteUpdatingResponse(); 1411 1411 - } 1412 1412 - 1413 1413 - const cached = await ensureSiteCached(customDomain.did, rkey); 1414 1414 - if (!cached) { 1415 1415 - return c.text('Site not found', 404); 1416 1416 - } 1417 1417 - 1418 1418 - const headers: Record<string, string> = {}; 1419 1419 - c.req.raw.headers.forEach((value, key) => { 1420 1420 - headers[key.toLowerCase()] = value; 1421 1421 - }); 1422 1422 - return serveFromCache(customDomain.did, rkey, path, c.req.url, headers); 1423 1423 - } 1424 1424 - 1425 1425 - // Route 2: Registered subdomains - /*.wisp.place/* 1426 1426 - if (hostname.endsWith(`.${BASE_HOST}`)) { 1427 1427 - const domainInfo = await getWispDomain(hostname); 1428 1428 - if (!domainInfo) { 1429 1429 - return c.text('Subdomain not registered', 404); 1430 1430 - } 1431 1431 - 1432 1432 - if (!domainInfo.rkey) { 1433 1433 - return c.text('Domain not mapped to a site', 404); 1434 1434 - } 1435 1435 - 1436 1436 - const rkey = domainInfo.rkey; 1437 1437 - if (!isValidRkey(rkey)) { 1438 1438 - return c.text('Invalid site configuration', 500); 1439 1439 - } 1440 1440 - 1441 1441 - // Check if site is currently being cached - return updating response early 1442 1442 - if (isSiteBeingCached(domainInfo.did, rkey)) { 1443 1443 - return siteUpdatingResponse(); 1444 1444 - } 1445 1445 - 1446 1446 - const cached = await ensureSiteCached(domainInfo.did, rkey); 1447 1447 - if (!cached) { 1448 1448 - return c.text('Site not found', 404); 1449 1449 - } 1450 1450 - 1451 1451 - const headers: Record<string, string> = {}; 1452 1452 - c.req.raw.headers.forEach((value, key) => { 1453 1453 - headers[key.toLowerCase()] = value; 1454 1454 - }); 1455 1455 - return serveFromCache(domainInfo.did, rkey, path, c.req.url, headers); 1456 1456 - } 1457 1457 - 1458 1458 - // Route 1: Custom domains - /* 1459 1459 - const customDomain = await getCustomDomain(hostname); 1460 1460 - if (!customDomain) { 1461 1461 - return c.text('Custom domain not found or not verified', 404); 1462 1462 - } 1463 1463 - 1464 1464 - if (!customDomain.rkey) { 1465 1465 - return c.text('Domain not mapped to a site', 404); 1466 1466 - } 1467 1467 - 1468 1468 - const rkey = customDomain.rkey; 1469 1469 - if (!isValidRkey(rkey)) { 1470 1470 - return c.text('Invalid site configuration', 500); 1471 1471 - } 1472 1472 - 1473 1473 - // Check if site is currently being cached - return updating response early 1474 1474 - if (isSiteBeingCached(customDomain.did, rkey)) { 1475 1475 - return siteUpdatingResponse(); 1476 1476 - } 1477 1477 - 1478 1478 - const cached = await ensureSiteCached(customDomain.did, rkey); 1479 1479 - if (!cached) { 1480 1480 - return c.text('Site not found', 404); 1481 1481 - } 1482 1482 - 1483 1483 - const headers: Record<string, string> = {}; 1484 1484 - c.req.raw.headers.forEach((value, key) => { 1485 1485 - headers[key.toLowerCase()] = value; 1486 1486 - }); 1487 1487 - return serveFromCache(customDomain.did, rkey, path, c.req.url, headers); 1488 1488 - }); 1489 1489 - 1490 1490 - // Internal observability endpoints (for admin panel) 1491 1491 - app.get('/__internal__/observability/logs', (c) => { 1492 1492 - const query = c.req.query(); 1493 1493 - const filter: any = {}; 1494 1494 - if (query.level) filter.level = query.level; 1495 1495 - if (query.service) filter.service = query.service; 1496 1496 - if (query.search) filter.search = query.search; 1497 1497 - if (query.eventType) filter.eventType = query.eventType; 1498 1498 - if (query.limit) filter.limit = parseInt(query.limit as string); 1499 1499 - return c.json({ logs: logCollector.getLogs(filter) }); 1500 1500 - }); 1501 1501 - 1502 1502 - app.get('/__internal__/observability/errors', (c) => { 1503 1503 - const query = c.req.query(); 1504 1504 - const filter: any = {}; 1505 1505 - if (query.service) filter.service = query.service; 1506 1506 - if (query.limit) filter.limit = parseInt(query.limit as string); 1507 1507 - return c.json({ errors: errorTracker.getErrors(filter) }); 1508 1508 - }); 1509 1509 - 1510 1510 - app.get('/__internal__/observability/metrics', (c) => { 1511 1511 - const query = c.req.query(); 1512 1512 - const timeWindow = query.timeWindow ? parseInt(query.timeWindow as string) : 3600000; 1513 1513 - const stats = metricsCollector.getStats('hosting-service', timeWindow); 1514 1514 - return c.json({ stats, timeWindow }); 1515 1515 - }); 1516 1516 - 1517 1517 - app.get('/__internal__/observability/cache', async (c) => { 1518 1518 - const { getCacheStats } = await import('./lib/cache'); 1519 1519 - const stats = getCacheStats(); 1520 1520 - return c.json({ cache: stats }); 1521 1521 - }); 1522 1522 - 1523 1523 - export default app;

+6

hosting-service/tsconfig.json apps/hosting-service/tsconfig.json

··· 24 24 25 25 /* Code doesn't run in DOM */ 26 26 "lib": ["es2022"], 27 27 + 28 28 + /* Workspace Paths */ 29 29 + "baseUrl": ".", 30 30 + "paths": { 31 31 + "@wisp/*": ["../../packages/@wisp/*/src"] 32 32 + } 27 33 }, 28 34 "include": ["src/**/*"], 29 35 "exclude": ["node_modules", "cache", "dist"]

lexicons/fs.json packages/@wisp/lexicons/lexicons/fs.json

lexicons/settings.json packages/@wisp/lexicons/lexicons/settings.json

lexicons/subfs.json packages/@wisp/lexicons/lexicons/subfs.json

+15 -55

package.json

··· 1 1 { 2 2 - "name": "elysia-static", 2 2 + "name": "@wisp/monorepo", 3 3 "version": "1.0.50", 4 4 + "private": true, 5 5 + "workspaces": [ 6 6 + "packages/@wisp/*", 7 7 + "apps/main-app", 8 8 + "apps/hosting-service" 9 9 + ], 4 10 "scripts": { 5 11 "test": "bun test", 6 6 - "dev": "bun run --watch src/index.ts", 7 7 - "start": "bun run src/index.ts", 8 8 - "build": "bun build --compile --target bun --outfile server src/index.ts", 9 9 - "screenshot": "bun run scripts/screenshot-sites.ts" 10 10 - }, 11 11 - "dependencies": { 12 12 - "@atproto/api": "^0.17.3", 13 13 - "@atproto/lex-cli": "^0.9.5", 14 14 - "@atproto/oauth-client-node": "^0.3.9", 15 15 - "@atproto/xrpc-server": "^0.9.5", 16 16 - "@elysiajs/cors": "^1.4.0", 17 17 - "@elysiajs/eden": "^1.4.3", 18 18 - "@elysiajs/openapi": "^1.4.11", 19 19 - "@elysiajs/opentelemetry": "^1.4.6", 20 20 - "@elysiajs/static": "^1.4.2", 21 21 - "@radix-ui/react-checkbox": "^1.3.3", 22 22 - "@radix-ui/react-dialog": "^1.1.15", 23 23 - "@radix-ui/react-label": "^2.1.7", 24 24 - "@radix-ui/react-radio-group": "^1.3.8", 25 25 - "@radix-ui/react-slot": "^1.2.3", 26 26 - "@radix-ui/react-tabs": "^1.1.13", 27 27 - "@tanstack/react-query": "^5.90.2", 28 28 - "actor-typeahead": "^0.1.1", 29 29 - "atproto-ui": "^0.11.3", 30 30 - "class-variance-authority": "^0.7.1", 31 31 - "clsx": "^2.1.1", 32 32 - "elysia": "latest", 33 33 - "iron-session": "^8.0.4", 34 34 - "lucide-react": "^0.546.0", 35 35 - "multiformats": "^13.4.1", 36 36 - "prismjs": "^1.30.0", 37 37 - "react": "^19.2.0", 38 38 - "react-dom": "^19.2.0", 39 39 - "tailwind-merge": "^3.3.1", 40 40 - "tailwindcss": "4", 41 41 - "tw-animate-css": "^1.4.0", 42 42 - "typescript": "^5.9.3", 43 43 - "zlib": "^1.0.5" 44 44 - }, 45 45 - "devDependencies": { 46 46 - "@types/react": "^19.2.2", 47 47 - "@types/react-dom": "^19.2.1", 48 48 - "bun-plugin-tailwind": "^0.1.2", 49 49 - "bun-types": "latest", 50 50 - "esbuild": "0.26.0", 51 51 - "playwright": "^1.49.0" 52 52 - }, 53 53 - "module": "src/index.js", 54 54 - "trustedDependencies": [ 55 55 - "bun", 56 56 - "cbor-extract", 57 57 - "core-js", 58 58 - "protobufjs" 59 59 - ] 12 12 + "dev": "bun run --watch apps/main-app/src/index.ts", 13 13 + "start": "bun run apps/main-app/src/index.ts", 14 14 + "build": "bun build --compile --target bun --outfile server apps/main-app/src/index.ts", 15 15 + "screenshot": "bun run apps/main-app/scripts/screenshot-sites.ts", 16 16 + "hosting:dev": "cd apps/hosting-service && npm run dev", 17 17 + "hosting:build": "cd apps/hosting-service && npm run build", 18 18 + "hosting:start": "cd apps/hosting-service && npm run start" 19 19 + } 60 20 }

+31

packages/@wisp/atproto-utils/package.json

··· 1 1 + { 2 2 + "name": "@wisp/atproto-utils", 3 3 + "version": "1.0.0", 4 4 + "private": true, 5 5 + "type": "module", 6 6 + "main": "./src/index.ts", 7 7 + "types": "./src/index.ts", 8 8 + "exports": { 9 9 + ".": { 10 10 + "types": "./src/index.ts", 11 11 + "default": "./src/index.ts" 12 12 + }, 13 13 + "./blob": { 14 14 + "types": "./src/blob.ts", 15 15 + "default": "./src/blob.ts" 16 16 + }, 17 17 + "./compression": { 18 18 + "types": "./src/compression.ts", 19 19 + "default": "./src/compression.ts" 20 20 + }, 21 21 + "./subfs": { 22 22 + "types": "./src/subfs.ts", 23 23 + "default": "./src/subfs.ts" 24 24 + } 25 25 + }, 26 26 + "dependencies": { 27 27 + "@atproto/api": "^0.14.1", 28 28 + "@wisp/lexicons": "workspace:*", 29 29 + "multiformats": "^13.3.1" 30 30 + } 31 31 + }

+108

packages/@wisp/atproto-utils/src/blob.ts

··· 1 1 + import type { BlobRef } from "@atproto/lexicon"; 2 2 + import type { Directory, File } from "@wisp/lexicons/types/place/wisp/fs"; 3 3 + import { CID } from 'multiformats/cid'; 4 4 + import { sha256 } from 'multiformats/hashes/sha2'; 5 5 + import * as raw from 'multiformats/codecs/raw'; 6 6 + import { createHash } from 'crypto'; 7 7 + import * as mf from 'multiformats'; 8 8 + 9 9 + /** 10 10 + * Compute CID (Content Identifier) for blob content 11 11 + * Uses the same algorithm as AT Protocol: CIDv1 with raw codec and SHA-256 12 12 + * Based on @atproto/common/src/ipld.ts sha256RawToCid implementation 13 13 + */ 14 14 + export function computeCID(content: Buffer): string { 15 15 + // Use node crypto to compute sha256 hash (same as AT Protocol) 16 16 + const hash = createHash('sha256').update(content).digest(); 17 17 + // Create digest object from hash bytes 18 18 + const digest = mf.digest.create(sha256.code, hash); 19 19 + // Create CIDv1 with raw codec 20 20 + const cid = CID.createV1(raw.code, digest); 21 21 + return cid.toString(); 22 22 + } 23 23 + 24 24 + /** 25 25 + * Extract blob information from a directory tree 26 26 + * Returns a map of file paths to their blob refs and CIDs 27 27 + */ 28 28 + export function extractBlobMap( 29 29 + directory: Directory, 30 30 + currentPath: string = '' 31 31 + ): Map<string, { blobRef: BlobRef; cid: string }> { 32 32 + const blobMap = new Map<string, { blobRef: BlobRef; cid: string }>(); 33 33 + 34 34 + for (const entry of directory.entries) { 35 35 + const fullPath = currentPath ? `${currentPath}/${entry.name}` : entry.name; 36 36 + 37 37 + if ('type' in entry.node && entry.node.type === 'file') { 38 38 + const fileNode = entry.node as File; 39 39 + // AT Protocol SDK returns BlobRef class instances, not plain objects 40 40 + // The ref is a CID instance that can be converted to string 41 41 + if (fileNode.blob && fileNode.blob.ref) { 42 42 + const cidString = fileNode.blob.ref.toString(); 43 43 + blobMap.set(fullPath, { 44 44 + blobRef: fileNode.blob, 45 45 + cid: cidString 46 46 + }); 47 47 + } 48 48 + } else if ('type' in entry.node && entry.node.type === 'directory') { 49 49 + const subMap = extractBlobMap(entry.node as Directory, fullPath); 50 50 + subMap.forEach((value, key) => blobMap.set(key, value)); 51 51 + } 52 52 + // Skip subfs nodes - they don't contain blobs in the main tree 53 53 + } 54 54 + 55 55 + return blobMap; 56 56 + } 57 57 + 58 58 + interface IpldLink { 59 59 + $link: string; 60 60 + } 61 61 + 62 62 + interface TypedBlobRef { 63 63 + ref: CID | IpldLink; 64 64 + } 65 65 + 66 66 + interface UntypedBlobRef { 67 67 + cid: string; 68 68 + } 69 69 + 70 70 + function isIpldLink(obj: unknown): obj is IpldLink { 71 71 + return typeof obj === 'object' && obj !== null && '$link' in obj && typeof (obj as IpldLink).$link === 'string'; 72 72 + } 73 73 + 74 74 + function isTypedBlobRef(obj: unknown): obj is TypedBlobRef { 75 75 + return typeof obj === 'object' && obj !== null && 'ref' in obj; 76 76 + } 77 77 + 78 78 + function isUntypedBlobRef(obj: unknown): obj is UntypedBlobRef { 79 79 + return typeof obj === 'object' && obj !== null && 'cid' in obj && typeof (obj as UntypedBlobRef).cid === 'string'; 80 80 + } 81 81 + 82 82 + /** 83 83 + * Extract CID from a blob reference (handles multiple blob ref formats) 84 84 + */ 85 85 + export function extractBlobCid(blobRef: unknown): string | null { 86 86 + if (isIpldLink(blobRef)) { 87 87 + return blobRef.$link; 88 88 + } 89 89 + 90 90 + if (isTypedBlobRef(blobRef)) { 91 91 + const ref = blobRef.ref; 92 92 + 93 93 + const cid = CID.asCID(ref); 94 94 + if (cid) { 95 95 + return cid.toString(); 96 96 + } 97 97 + 98 98 + if (isIpldLink(ref)) { 99 99 + return ref.$link; 100 100 + } 101 101 + } 102 102 + 103 103 + if (isUntypedBlobRef(blobRef)) { 104 104 + return blobRef.cid; 105 105 + } 106 106 + 107 107 + return null; 108 108 + }

+95

packages/@wisp/atproto-utils/src/compression.ts

··· 1 1 + import { gzipSync } from 'zlib'; 2 2 + 3 3 + /** 4 4 + * Determine if a file should be gzip compressed based on its MIME type and filename 5 5 + */ 6 6 + export function shouldCompressFile(mimeType: string, fileName?: string): boolean { 7 7 + // Never compress _redirects file - it needs to be plain text for the hosting service 8 8 + if (fileName && (fileName.endsWith('/_redirects') || fileName === '_redirects')) { 9 9 + return false; 10 10 + } 11 11 + 12 12 + // Compress text-based files and uncompressed audio formats 13 13 + const compressibleTypes = [ 14 14 + 'text/html', 15 15 + 'text/css', 16 16 + 'text/javascript', 17 17 + 'application/javascript', 18 18 + 'application/json', 19 19 + 'image/svg+xml', 20 20 + 'text/xml', 21 21 + 'application/xml', 22 22 + 'text/plain', 23 23 + 'application/x-javascript', 24 24 + // Uncompressed audio formats (WAV, AIFF, etc.) 25 25 + 'audio/wav', 26 26 + 'audio/wave', 27 27 + 'audio/x-wav', 28 28 + 'audio/aiff', 29 29 + 'audio/x-aiff' 30 30 + ]; 31 31 + 32 32 + // Check if mime type starts with any compressible type 33 33 + return compressibleTypes.some(type => mimeType.startsWith(type)); 34 34 + } 35 35 + 36 36 + /** 37 37 + * Determines if a MIME type should benefit from gzip compression. 38 38 + * Returns true for text-based web assets (HTML, CSS, JS, JSON, XML, SVG). 39 39 + * Returns false for already-compressed formats (images, video, audio, PDFs). 40 40 + */ 41 41 + export function shouldCompressMimeType(mimeType: string | undefined): boolean { 42 42 + if (!mimeType) return false; 43 43 + 44 44 + const mime = mimeType.toLowerCase(); 45 45 + 46 46 + // Text-based web assets and uncompressed audio that benefit from compression 47 47 + const compressibleTypes = [ 48 48 + 'text/html', 49 49 + 'text/css', 50 50 + 'text/javascript', 51 51 + 'application/javascript', 52 52 + 'application/x-javascript', 53 53 + 'text/xml', 54 54 + 'application/xml', 55 55 + 'application/json', 56 56 + 'text/plain', 57 57 + 'image/svg+xml', 58 58 + // Uncompressed audio formats 59 59 + 'audio/wav', 60 60 + 'audio/wave', 61 61 + 'audio/x-wav', 62 62 + 'audio/aiff', 63 63 + 'audio/x-aiff', 64 64 + ]; 65 65 + 66 66 + if (compressibleTypes.some(type => mime === type || mime.startsWith(type))) { 67 67 + return true; 68 68 + } 69 69 + 70 70 + // Already-compressed formats that should NOT be double-compressed 71 71 + const alreadyCompressedPrefixes = [ 72 72 + 'video/', 73 73 + 'audio/', 74 74 + 'image/', 75 75 + 'application/pdf', 76 76 + 'application/zip', 77 77 + 'application/gzip', 78 78 + ]; 79 79 + 80 80 + if (alreadyCompressedPrefixes.some(prefix => mime.startsWith(prefix))) { 81 81 + return false; 82 82 + } 83 83 + 84 84 + // Default to not compressing for unknown types 85 85 + return false; 86 86 + } 87 87 + 88 88 + /** 89 89 + * Compress a file using gzip with deterministic output 90 90 + */ 91 91 + export function compressFile(content: Buffer): Buffer { 92 92 + return gzipSync(content, { 93 93 + level: 9 94 94 + }); 95 95 + }

+8

packages/@wisp/atproto-utils/src/index.ts

··· 1 1 + // Blob utilities 2 2 + export { computeCID, extractBlobMap, extractBlobCid } from './blob'; 3 3 + 4 4 + // Compression utilities 5 5 + export { shouldCompressFile, shouldCompressMimeType, compressFile } from './compression'; 6 6 + 7 7 + // Subfs utilities 8 8 + export { extractSubfsUris } from './subfs';

+31

packages/@wisp/atproto-utils/src/subfs.ts

··· 1 1 + import type { Directory } from "@wisp/lexicons/types/place/wisp/fs"; 2 2 + 3 3 + /** 4 4 + * Extract all subfs URIs from a directory tree with their mount paths 5 5 + */ 6 6 + export function extractSubfsUris( 7 7 + directory: Directory, 8 8 + currentPath: string = '' 9 9 + ): Array<{ uri: string; path: string }> { 10 10 + const uris: Array<{ uri: string; path: string }> = []; 11 11 + 12 12 + for (const entry of directory.entries) { 13 13 + const fullPath = currentPath ? `${currentPath}/${entry.name}` : entry.name; 14 14 + 15 15 + if ('type' in entry.node) { 16 16 + if (entry.node.type === 'subfs') { 17 17 + // Subfs node with subject URI 18 18 + const subfsNode = entry.node as any; 19 19 + if (subfsNode.subject) { 20 20 + uris.push({ uri: subfsNode.subject, path: fullPath }); 21 21 + } 22 22 + } else if (entry.node.type === 'directory') { 23 23 + // Recursively search subdirectories 24 24 + const subUris = extractSubfsUris(entry.node as Directory, fullPath); 25 25 + uris.push(...subUris); 26 26 + } 27 27 + } 28 28 + } 29 29 + 30 30 + return uris; 31 31 + }

+9

packages/@wisp/atproto-utils/tsconfig.json

··· 1 1 + { 2 2 + "extends": "../../../tsconfig.json", 3 3 + "compilerOptions": { 4 4 + "outDir": "./dist", 5 5 + "rootDir": "./src" 6 6 + }, 7 7 + "include": ["src/**/*"], 8 8 + "exclude": ["node_modules", "dist"] 9 9 + }

+14

packages/@wisp/constants/package.json

··· 1 1 + { 2 2 + "name": "@wisp/constants", 3 3 + "version": "1.0.0", 4 4 + "private": true, 5 5 + "type": "module", 6 6 + "main": "./src/index.ts", 7 7 + "types": "./src/index.ts", 8 8 + "exports": { 9 9 + ".": { 10 10 + "types": "./src/index.ts", 11 11 + "default": "./src/index.ts" 12 12 + } 13 13 + } 14 14 + }

+32

packages/@wisp/constants/src/index.ts

··· 1 1 + /** 2 2 + * Shared constants for wisp.place 3 3 + */ 4 4 + 5 5 + // Domain configuration 6 6 + export const getBaseHost = () => { 7 7 + if (typeof Bun !== 'undefined') { 8 8 + return Bun.env.BASE_DOMAIN || "wisp.place"; 9 9 + } 10 10 + return process.env.BASE_DOMAIN || "wisp.place"; 11 11 + }; 12 12 + 13 13 + export const BASE_HOST = getBaseHost(); 14 14 + 15 15 + // File size limits 16 16 + export const MAX_SITE_SIZE = 300 * 1024 * 1024; // 300MB 17 17 + export const MAX_FILE_SIZE = 100 * 1024 * 1024; // 100MB 18 18 + export const MAX_FILE_COUNT = 1000; 19 19 + 20 20 + // Cache configuration 21 21 + export const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes 22 22 + 23 23 + // Fetch timeouts and limits 24 24 + export const FETCH_TIMEOUT_MS = 30000; // 30 seconds 25 25 + export const MAX_JSON_SIZE = 10 * 1024 * 1024; // 10MB 26 26 + export const MAX_BLOB_SIZE = MAX_FILE_SIZE; // Use file size limit 27 27 + 28 28 + // Directory limits (AT Protocol lexicon constraints) 29 29 + export const MAX_ENTRIES_PER_DIRECTORY = 500; 30 30 + 31 31 + // Compression settings 32 32 + export const GZIP_COMPRESSION_LEVEL = 9;

+9

packages/@wisp/constants/tsconfig.json

··· 1 1 + { 2 2 + "extends": "../../../tsconfig.json", 3 3 + "compilerOptions": { 4 4 + "outDir": "./dist", 5 5 + "rootDir": "./src" 6 6 + }, 7 7 + "include": ["src/**/*"], 8 8 + "exclude": ["node_modules", "dist"] 9 9 + }

+29

packages/@wisp/database/package.json

··· 1 1 + { 2 2 + "name": "@wisp/database", 3 3 + "version": "1.0.0", 4 4 + "private": true, 5 5 + "type": "module", 6 6 + "main": "./src/index.ts", 7 7 + "types": "./src/index.ts", 8 8 + "exports": { 9 9 + ".": { 10 10 + "types": "./src/index.ts", 11 11 + "default": "./src/index.ts" 12 12 + }, 13 13 + "./types": { 14 14 + "types": "./src/types.ts", 15 15 + "default": "./src/types.ts" 16 16 + } 17 17 + }, 18 18 + "dependencies": { 19 19 + "postgres": "^3.4.5" 20 20 + }, 21 21 + "peerDependencies": { 22 22 + "bun": "^1.0.0" 23 23 + }, 24 24 + "peerDependenciesMeta": { 25 25 + "bun": { 26 26 + "optional": true 27 27 + } 28 28 + } 29 29 + }

+22

packages/@wisp/database/src/index.ts

··· 1 1 + /** 2 2 + * Shared database utilities for wisp.place 3 3 + * 4 4 + * This package provides database query functions that work across both 5 5 + * main-app (Bun SQL) and hosting-service (postgres) environments. 6 6 + * 7 7 + * The actual database client is passed in by the consuming application. 8 8 + */ 9 9 + 10 10 + export * from './types'; 11 11 + 12 12 + // Re-export types 13 13 + export type { 14 14 + DomainLookup, 15 15 + CustomDomainLookup, 16 16 + SiteRecord, 17 17 + OAuthState, 18 18 + OAuthSession, 19 19 + OAuthKey, 20 20 + CookieSecret, 21 21 + AdminUser 22 22 + } from './types';

+56

packages/@wisp/database/src/types.ts

··· 1 1 + /** 2 2 + * Shared database types used across main-app and hosting-service 3 3 + */ 4 4 + 5 5 + export interface DomainLookup { 6 6 + did: string; 7 7 + rkey: string | null; 8 8 + } 9 9 + 10 10 + export interface CustomDomainLookup { 11 11 + id: string; 12 12 + domain: string; 13 13 + did: string; 14 14 + rkey: string | null; 15 15 + verified: boolean; 16 16 + } 17 17 + 18 18 + export interface SiteRecord { 19 19 + did: string; 20 20 + rkey: string; 21 21 + display_name?: string; 22 22 + created_at?: number; 23 23 + updated_at?: number; 24 24 + } 25 25 + 26 26 + export interface OAuthState { 27 27 + key: string; 28 28 + data: string; 29 29 + created_at?: number; 30 30 + expires_at?: number; 31 31 + } 32 32 + 33 33 + export interface OAuthSession { 34 34 + sub: string; 35 35 + data: string; 36 36 + updated_at?: number; 37 37 + expires_at?: number; 38 38 + } 39 39 + 40 40 + export interface OAuthKey { 41 41 + kid: string; 42 42 + jwk: string; 43 43 + created_at?: number; 44 44 + } 45 45 + 46 46 + export interface CookieSecret { 47 47 + id: string; 48 48 + secret: string; 49 49 + created_at?: number; 50 50 + } 51 51 + 52 52 + export interface AdminUser { 53 53 + username: string; 54 54 + password_hash: string; 55 55 + created_at?: number; 56 56 + }

+9

packages/@wisp/database/tsconfig.json

··· 1 1 + { 2 2 + "extends": "../../../tsconfig.json", 3 3 + "compilerOptions": { 4 4 + "outDir": "./dist", 5 5 + "rootDir": "./src" 6 6 + }, 7 7 + "include": ["src/**/*"], 8 8 + "exclude": ["node_modules", "dist"] 9 9 + }

+34

packages/@wisp/fs-utils/package.json

··· 1 1 + { 2 2 + "name": "@wisp/fs-utils", 3 3 + "version": "1.0.0", 4 4 + "private": true, 5 5 + "type": "module", 6 6 + "main": "./src/index.ts", 7 7 + "types": "./src/index.ts", 8 8 + "exports": { 9 9 + ".": { 10 10 + "types": "./src/index.ts", 11 11 + "default": "./src/index.ts" 12 12 + }, 13 13 + "./path": { 14 14 + "types": "./src/path.ts", 15 15 + "default": "./src/path.ts" 16 16 + }, 17 17 + "./tree": { 18 18 + "types": "./src/tree.ts", 19 19 + "default": "./src/tree.ts" 20 20 + }, 21 21 + "./manifest": { 22 22 + "types": "./src/manifest.ts", 23 23 + "default": "./src/manifest.ts" 24 24 + }, 25 25 + "./subfs-split": { 26 26 + "types": "./src/subfs-split.ts", 27 27 + "default": "./src/subfs-split.ts" 28 28 + } 29 29 + }, 30 30 + "dependencies": { 31 31 + "@atproto/api": "^0.14.1", 32 32 + "@wisp/lexicons": "workspace:*" 33 33 + } 34 34 + }

+12

packages/@wisp/fs-utils/src/index.ts

··· 1 1 + // Path utilities 2 2 + export { sanitizePath, normalizePath } from './path'; 3 3 + 4 4 + // Tree processing 5 5 + export type { UploadedFile, FileUploadResult, ProcessedDirectory } from './tree'; 6 6 + export { processUploadedFiles, updateFileBlobs, countFilesInDirectory, collectFileCidsFromEntries } from './tree'; 7 7 + 8 8 + // Manifest creation 9 9 + export { createManifest } from './manifest'; 10 10 + 11 11 + // Subfs splitting utilities 12 12 + export { estimateDirectorySize, findLargeDirectories, replaceDirectoryWithSubfs } from './subfs-split';

+27

packages/@wisp/fs-utils/src/manifest.ts

··· 1 1 + import type { Record, Directory } from "@wisp/lexicons/types/place/wisp/fs"; 2 2 + import { validateRecord } from "@wisp/lexicons/types/place/wisp/fs"; 3 3 + 4 4 + /** 5 5 + * Create the manifest record for a site 6 6 + */ 7 7 + export function createManifest( 8 8 + siteName: string, 9 9 + root: Directory, 10 10 + fileCount: number 11 11 + ): Record { 12 12 + const manifest = { 13 13 + $type: 'place.wisp.fs' as const, 14 14 + site: siteName, 15 15 + root, 16 16 + fileCount, 17 17 + createdAt: new Date().toISOString() 18 18 + }; 19 19 + 20 20 + // Validate the manifest before returning 21 21 + const validationResult = validateRecord(manifest); 22 22 + if (!validationResult.success) { 23 23 + throw new Error(`Invalid manifest: ${validationResult.error?.message || 'Validation failed'}`); 24 24 + } 25 25 + 26 26 + return manifest; 27 27 + }

+29

packages/@wisp/fs-utils/src/path.ts

··· 1 1 + /** 2 2 + * Sanitize a file path to prevent directory traversal attacks 3 3 + * Removes any path segments that attempt to go up directories 4 4 + */ 5 5 + export function sanitizePath(filePath: string): string { 6 6 + // Remove leading slashes 7 7 + let cleaned = filePath.replace(/^\/+/, ''); 8 8 + 9 9 + // Split into segments and filter out dangerous ones 10 10 + const segments = cleaned.split('/').filter(segment => { 11 11 + // Remove empty segments 12 12 + if (!segment || segment === '.') return false; 13 13 + // Remove parent directory references 14 14 + if (segment === '..') return false; 15 15 + // Remove segments with null bytes 16 16 + if (segment.includes('\0')) return false; 17 17 + return true; 18 18 + }); 19 19 + 20 20 + // Rejoin the safe segments 21 21 + return segments.join('/'); 22 22 + } 23 23 + 24 24 + /** 25 25 + * Normalize a path by removing leading base folder names 26 26 + */ 27 27 + export function normalizePath(path: string): string { 28 28 + return path.replace(/^[^\/]*\//, ''); 29 29 + }

+113

packages/@wisp/fs-utils/src/subfs-split.ts

··· 1 1 + import type { Directory } from "@wisp/lexicons/types/place/wisp/fs"; 2 2 + 3 3 + /** 4 4 + * Estimate the JSON size of a directory tree 5 5 + */ 6 6 + export function estimateDirectorySize(directory: Directory): number { 7 7 + return JSON.stringify(directory).length; 8 8 + } 9 9 + 10 10 + /** 11 11 + * Count files in a directory tree 12 12 + */ 13 13 + export function countFilesInDirectory(directory: Directory): number { 14 14 + let count = 0; 15 15 + for (const entry of directory.entries) { 16 16 + if ('type' in entry.node && entry.node.type === 'file') { 17 17 + count++; 18 18 + } else if ('type' in entry.node && entry.node.type === 'directory') { 19 19 + count += countFilesInDirectory(entry.node as Directory); 20 20 + } 21 21 + } 22 22 + return count; 23 23 + } 24 24 + 25 25 + /** 26 26 + * Find all directories in a tree with their paths and sizes 27 27 + */ 28 28 + export function findLargeDirectories(directory: Directory, currentPath: string = ''): Array<{ 29 29 + path: string; 30 30 + directory: Directory; 31 31 + size: number; 32 32 + fileCount: number; 33 33 + }> { 34 34 + const result: Array<{ path: string; directory: Directory; size: number; fileCount: number }> = []; 35 35 + 36 36 + for (const entry of directory.entries) { 37 37 + if ('type' in entry.node && entry.node.type === 'directory') { 38 38 + const dirPath = currentPath ? `${currentPath}/${entry.name}` : entry.name; 39 39 + const dir = entry.node as Directory; 40 40 + const size = estimateDirectorySize(dir); 41 41 + const fileCount = countFilesInDirectory(dir); 42 42 + 43 43 + result.push({ path: dirPath, directory: dir, size, fileCount }); 44 44 + 45 45 + // Recursively find subdirectories 46 46 + const subdirs = findLargeDirectories(dir, dirPath); 47 47 + result.push(...subdirs); 48 48 + } 49 49 + } 50 50 + 51 51 + return result; 52 52 + } 53 53 + 54 54 + /** 55 55 + * Replace a directory with a subfs node in the tree 56 56 + */ 57 57 + export function replaceDirectoryWithSubfs( 58 58 + directory: Directory, 59 59 + targetPath: string, 60 60 + subfsUri: string 61 61 + ): Directory { 62 62 + const pathParts = targetPath.split('/'); 63 63 + const targetName = pathParts[pathParts.length - 1]; 64 64 + const parentPath = pathParts.slice(0, -1).join('/'); 65 65 + 66 66 + // If this is a root-level directory 67 67 + if (pathParts.length === 1) { 68 68 + const newEntries = directory.entries.map(entry => { 69 69 + if (entry.name === targetName && 'type' in entry.node && entry.node.type === 'directory') { 70 70 + return { 71 71 + name: entry.name, 72 72 + node: { 73 73 + $type: 'place.wisp.fs#subfs' as const, 74 74 + type: 'subfs' as const, 75 75 + subject: subfsUri, 76 76 + flat: false // Preserve directory structure 77 77 + } 78 78 + }; 79 79 + } 80 80 + return entry; 81 81 + }); 82 82 + 83 83 + return { 84 84 + $type: 'place.wisp.fs#directory' as const, 85 85 + type: 'directory' as const, 86 86 + entries: newEntries 87 87 + }; 88 88 + } 89 89 + 90 90 + // Recursively navigate to parent directory 91 91 + const newEntries = directory.entries.map(entry => { 92 92 + if ('type' in entry.node && entry.node.type === 'directory') { 93 93 + const entryPath = entry.name; 94 94 + if (parentPath.startsWith(entryPath) || parentPath === entry.name) { 95 95 + const remainingPath = pathParts.slice(1).join('/'); 96 96 + return { 97 97 + name: entry.name, 98 98 + node: { 99 99 + ...replaceDirectoryWithSubfs(entry.node as Directory, remainingPath, subfsUri), 100 100 + $type: 'place.wisp.fs#directory' as const 101 101 + } 102 102 + }; 103 103 + } 104 104 + } 105 105 + return entry; 106 106 + }); 107 107 + 108 108 + return { 109 109 + $type: 'place.wisp.fs#directory' as const, 110 110 + type: 'directory' as const, 111 111 + entries: newEntries 112 112 + }; 113 113 + }

+241

packages/@wisp/fs-utils/src/tree.ts

··· 1 1 + import type { BlobRef } from "@atproto/api"; 2 2 + import type { Directory, Entry, File } from "@wisp/lexicons/types/place/wisp/fs"; 3 3 + 4 4 + export interface UploadedFile { 5 5 + name: string; 6 6 + content: Buffer; 7 7 + mimeType: string; 8 8 + size: number; 9 9 + compressed?: boolean; 10 10 + base64Encoded?: boolean; 11 11 + originalMimeType?: string; 12 12 + } 13 13 + 14 14 + export interface FileUploadResult { 15 15 + hash: string; 16 16 + blobRef: BlobRef; 17 17 + encoding?: 'gzip'; 18 18 + mimeType?: string; 19 19 + base64?: boolean; 20 20 + } 21 21 + 22 22 + export interface ProcessedDirectory { 23 23 + directory: Directory; 24 24 + fileCount: number; 25 25 + } 26 26 + 27 27 + /** 28 28 + * Process uploaded files into a directory structure 29 29 + */ 30 30 + export function processUploadedFiles(files: UploadedFile[]): ProcessedDirectory { 31 31 + const entries: Entry[] = []; 32 32 + let fileCount = 0; 33 33 + 34 34 + // Group files by directory 35 35 + const directoryMap = new Map<string, UploadedFile[]>(); 36 36 + 37 37 + for (const file of files) { 38 38 + // Skip undefined/null files (defensive) 39 39 + if (!file || !file.name) { 40 40 + console.error('Skipping undefined or invalid file in processUploadedFiles'); 41 41 + continue; 42 42 + } 43 43 + 44 44 + // Remove any base folder name from the path 45 45 + const normalizedPath = file.name.replace(/^[^\/]*\//, ''); 46 46 + 47 47 + // Skip files in .git directories 48 48 + if (normalizedPath.startsWith('.git/') || normalizedPath === '.git') { 49 49 + continue; 50 50 + } 51 51 + 52 52 + const parts = normalizedPath.split('/'); 53 53 + 54 54 + if (parts.length === 1) { 55 55 + // Root level file 56 56 + entries.push({ 57 57 + name: parts[0], 58 58 + node: { 59 59 + $type: 'place.wisp.fs#file' as const, 60 60 + type: 'file' as const, 61 61 + blob: undefined as any // Will be filled after upload 62 62 + } 63 63 + }); 64 64 + fileCount++; 65 65 + } else { 66 66 + // File in subdirectory 67 67 + const dirPath = parts.slice(0, -1).join('/'); 68 68 + if (!directoryMap.has(dirPath)) { 69 69 + directoryMap.set(dirPath, []); 70 70 + } 71 71 + directoryMap.get(dirPath)!.push({ 72 72 + ...file, 73 73 + name: normalizedPath 74 74 + }); 75 75 + } 76 76 + } 77 77 + 78 78 + // Process subdirectories 79 79 + for (const [dirPath, dirFiles] of directoryMap) { 80 80 + const dirEntries: Entry[] = []; 81 81 + 82 82 + for (const file of dirFiles) { 83 83 + const fileName = file.name.split('/').pop()!; 84 84 + dirEntries.push({ 85 85 + name: fileName, 86 86 + node: { 87 87 + $type: 'place.wisp.fs#file' as const, 88 88 + type: 'file' as const, 89 89 + blob: undefined as any // Will be filled after upload 90 90 + } 91 91 + }); 92 92 + fileCount++; 93 93 + } 94 94 + 95 95 + // Build nested directory structure 96 96 + const pathParts = dirPath.split('/'); 97 97 + let currentEntries = entries; 98 98 + 99 99 + for (let i = 0; i < pathParts.length; i++) { 100 100 + const part = pathParts[i]; 101 101 + const isLast = i === pathParts.length - 1; 102 102 + 103 103 + let existingEntry = currentEntries.find(e => e.name === part); 104 104 + 105 105 + if (!existingEntry) { 106 106 + const newDir = { 107 107 + $type: 'place.wisp.fs#directory' as const, 108 108 + type: 'directory' as const, 109 109 + entries: isLast ? dirEntries : [] 110 110 + }; 111 111 + 112 112 + existingEntry = { 113 113 + name: part, 114 114 + node: newDir 115 115 + }; 116 116 + currentEntries.push(existingEntry); 117 117 + } else if ('entries' in existingEntry.node && isLast) { 118 118 + (existingEntry.node as any).entries.push(...dirEntries); 119 119 + } 120 120 + 121 121 + if (existingEntry && 'entries' in existingEntry.node) { 122 122 + currentEntries = (existingEntry.node as any).entries; 123 123 + } 124 124 + } 125 125 + } 126 126 + 127 127 + const result = { 128 128 + directory: { 129 129 + $type: 'place.wisp.fs#directory' as const, 130 130 + type: 'directory' as const, 131 131 + entries 132 132 + }, 133 133 + fileCount 134 134 + }; 135 135 + 136 136 + return result; 137 137 + } 138 138 + 139 139 + /** 140 140 + * Update file blobs in directory structure after upload 141 141 + * Uses path-based matching to correctly match files in nested directories 142 142 + * Filters out files that were not successfully uploaded 143 143 + */ 144 144 + export function updateFileBlobs( 145 145 + directory: Directory, 146 146 + uploadResults: FileUploadResult[], 147 147 + filePaths: string[], 148 148 + currentPath: string = '', 149 149 + successfulPaths?: Set<string> 150 150 + ): Directory { 151 151 + const updatedEntries = directory.entries.map(entry => { 152 152 + if ('type' in entry.node && entry.node.type === 'file') { 153 153 + // Build the full path for this file 154 154 + const fullPath = currentPath ? `${currentPath}/${entry.name}` : entry.name; 155 155 + 156 156 + // If successfulPaths is provided, skip files that weren't successfully uploaded 157 157 + if (successfulPaths && !successfulPaths.has(fullPath)) { 158 158 + return null; // Filter out failed files 159 159 + } 160 160 + 161 161 + // Find exact match in filePaths (need to handle normalized paths) 162 162 + const fileIndex = filePaths.findIndex((path) => { 163 163 + // Normalize both paths by removing leading base folder 164 164 + const normalizedUploadPath = path.replace(/^[^\/]*\//, ''); 165 165 + const normalizedEntryPath = fullPath; 166 166 + return normalizedUploadPath === normalizedEntryPath || path === fullPath; 167 167 + }); 168 168 + 169 169 + if (fileIndex !== -1 && uploadResults[fileIndex]) { 170 170 + const result = uploadResults[fileIndex]; 171 171 + const blobRef = result.blobRef; 172 172 + 173 173 + return { 174 174 + ...entry, 175 175 + node: { 176 176 + $type: 'place.wisp.fs#file' as const, 177 177 + type: 'file' as const, 178 178 + blob: blobRef, 179 179 + ...(result.encoding && { encoding: result.encoding }), 180 180 + ...(result.mimeType && { mimeType: result.mimeType }), 181 181 + ...(result.base64 && { base64: result.base64 }) 182 182 + } 183 183 + }; 184 184 + } else { 185 185 + console.error(`Could not find blob for file: ${fullPath}`); 186 186 + return null; // Filter out files without blobs 187 187 + } 188 188 + } else if ('type' in entry.node && entry.node.type === 'directory') { 189 189 + const dirPath = currentPath ? `${currentPath}/${entry.name}` : entry.name; 190 190 + return { 191 191 + ...entry, 192 192 + node: updateFileBlobs(entry.node as Directory, uploadResults, filePaths, dirPath, successfulPaths) 193 193 + }; 194 194 + } 195 195 + return entry; 196 196 + }).filter(entry => entry !== null) as Entry[]; // Remove null entries (failed files) 197 197 + 198 198 + const result = { 199 199 + $type: 'place.wisp.fs#directory' as const, 200 200 + type: 'directory' as const, 201 201 + entries: updatedEntries 202 202 + }; 203 203 + 204 204 + return result; 205 205 + } 206 206 + 207 207 + /** 208 208 + * Count files in a directory tree 209 209 + */ 210 210 + export function countFilesInDirectory(directory: Directory): number { 211 211 + let count = 0; 212 212 + for (const entry of directory.entries) { 213 213 + if ('type' in entry.node && entry.node.type === 'file') { 214 214 + count++; 215 215 + } else if ('type' in entry.node && entry.node.type === 'directory') { 216 216 + count += countFilesInDirectory(entry.node as Directory); 217 217 + } 218 218 + } 219 219 + return count; 220 220 + } 221 221 + 222 222 + /** 223 223 + * Recursively collect file CIDs from entries for incremental update tracking 224 224 + */ 225 225 + export function collectFileCidsFromEntries(entries: Entry[], pathPrefix: string, fileCids: Record<string, string>): void { 226 226 + for (const entry of entries) { 227 227 + const currentPath = pathPrefix ? `${pathPrefix}/${entry.name}` : entry.name; 228 228 + const node = entry.node; 229 229 + 230 230 + if ('type' in node && node.type === 'directory' && 'entries' in node) { 231 231 + collectFileCidsFromEntries(node.entries, currentPath, fileCids); 232 232 + } else if ('type' in node && node.type === 'file' && 'blob' in node) { 233 233 + const fileNode = node as File; 234 234 + // Extract CID from blob ref 235 235 + if (fileNode.blob && fileNode.blob.ref) { 236 236 + const cid = fileNode.blob.ref.toString(); 237 237 + fileCids[currentPath] = cid; 238 238 + } 239 239 + } 240 240 + } 241 241 + }

+9

packages/@wisp/fs-utils/tsconfig.json

··· 1 1 + { 2 2 + "extends": "../../../tsconfig.json", 3 3 + "compilerOptions": { 4 4 + "outDir": "./dist", 5 5 + "rootDir": "./src" 6 6 + }, 7 7 + "include": ["src/**/*"], 8 8 + "exclude": ["node_modules", "dist"] 9 9 + }

+25

packages/@wisp/lexicons/README.md

··· 1 1 + # @wisp/lexicons 2 2 + 3 3 + Shared AT Protocol lexicon definitions and generated TypeScript types for the wisp.place project. 4 4 + 5 5 + ## Contents 6 6 + 7 7 + - `/lexicons` - Source lexicon JSON definitions 8 8 + - `/src` - Generated TypeScript types and validation functions 9 9 + 10 10 + ## Usage 11 11 + 12 12 + ```typescript 13 13 + import { ids, lexicons } from '@wisp/lexicons'; 14 14 + import type { PlaceWispFs } from '@wisp/lexicons/types/place/wisp/fs'; 15 15 + ``` 16 16 + 17 17 + ## Code Generation 18 18 + 19 19 + To regenerate types from lexicon definitions: 20 20 + 21 21 + ```bash 22 22 + npm run codegen 23 23 + ``` 24 24 + 25 25 + This uses `@atproto/lex-cli` to generate TypeScript types from the JSON schemas in `/lexicons`.

+44

packages/@wisp/lexicons/package.json

··· 1 1 + { 2 2 + "name": "@wisp/lexicons", 3 3 + "version": "1.0.0", 4 4 + "private": true, 5 5 + "type": "module", 6 6 + "main": "./src/index.ts", 7 7 + "types": "./src/index.ts", 8 8 + "exports": { 9 9 + ".": { 10 10 + "types": "./src/index.ts", 11 11 + "default": "./src/index.ts" 12 12 + }, 13 13 + "./types/place/wisp/fs": { 14 14 + "types": "./src/types/place/wisp/fs.ts", 15 15 + "default": "./src/types/place/wisp/fs.ts" 16 16 + }, 17 17 + "./types/place/wisp/settings": { 18 18 + "types": "./src/types/place/wisp/settings.ts", 19 19 + "default": "./src/types/place/wisp/settings.ts" 20 20 + }, 21 21 + "./types/place/wisp/subfs": { 22 22 + "types": "./src/types/place/wisp/subfs.ts", 23 23 + "default": "./src/types/place/wisp/subfs.ts" 24 24 + }, 25 25 + "./lexicons": { 26 26 + "types": "./src/lexicons.ts", 27 27 + "default": "./src/lexicons.ts" 28 28 + }, 29 29 + "./util": { 30 30 + "types": "./src/util.ts", 31 31 + "default": "./src/util.ts" 32 32 + } 33 33 + }, 34 34 + "scripts": { 35 35 + "codegen": "lex gen-server ./src ./lexicons" 36 36 + }, 37 37 + "dependencies": { 38 38 + "@atproto/lexicon": "^0.5.1", 39 39 + "@atproto/xrpc-server": "^0.9.5" 40 40 + }, 41 41 + "devDependencies": { 42 42 + "@atproto/lex-cli": "^0.9.5" 43 43 + } 44 44 + }

+11

packages/@wisp/lexicons/tsconfig.json

··· 1 1 + { 2 2 + "extends": "../../../tsconfig.json", 3 3 + "compilerOptions": { 4 4 + "outDir": "./dist", 5 5 + "rootDir": "./src", 6 6 + "declaration": true, 7 7 + "declarationMap": true 8 8 + }, 9 9 + "include": ["src/**/*"], 10 10 + "exclude": ["node_modules", "dist"] 11 11 + }

+34

packages/@wisp/observability/package.json

··· 1 1 + { 2 2 + "name": "@wisp/observability", 3 3 + "version": "1.0.0", 4 4 + "private": true, 5 5 + "type": "module", 6 6 + "main": "./src/index.ts", 7 7 + "types": "./src/index.ts", 8 8 + "exports": { 9 9 + ".": { 10 10 + "types": "./src/index.ts", 11 11 + "default": "./src/index.ts" 12 12 + }, 13 13 + "./core": { 14 14 + "types": "./src/core.ts", 15 15 + "default": "./src/core.ts" 16 16 + }, 17 17 + "./middleware/elysia": { 18 18 + "types": "./src/middleware/elysia.ts", 19 19 + "default": "./src/middleware/elysia.ts" 20 20 + }, 21 21 + "./middleware/hono": { 22 22 + "types": "./src/middleware/hono.ts", 23 23 + "default": "./src/middleware/hono.ts" 24 24 + } 25 25 + }, 26 26 + "peerDependencies": { 27 27 + "hono": "^4.0.0" 28 28 + }, 29 29 + "peerDependenciesMeta": { 30 30 + "hono": { 31 31 + "optional": true 32 32 + } 33 33 + } 34 34 + }

+11

packages/@wisp/observability/src/index.ts

··· 1 1 + /** 2 2 + * @wisp/observability 3 3 + * Framework-agnostic observability package with Elysia and Hono middleware 4 4 + */ 5 5 + 6 6 + // Export everything from core 7 7 + export * from './core' 8 8 + 9 9 + // Note: Middleware should be imported from specific subpaths: 10 10 + // - import { observabilityMiddleware } from '@wisp/observability/middleware/elysia' 11 11 + // - import { observabilityMiddleware, observabilityErrorHandler } from '@wisp/observability/middleware/hono'

+49

packages/@wisp/observability/src/middleware/elysia.ts

··· 1 1 + import { metricsCollector, logCollector } from '../core' 2 2 + 3 3 + /** 4 4 + * Elysia middleware for observability 5 5 + * Tracks request metrics and logs errors 6 6 + */ 7 7 + export function observabilityMiddleware(service: string) { 8 8 + return { 9 9 + beforeHandle: ({ request }: any) => { 10 10 + // Store start time on request object 11 11 + (request as any).__startTime = Date.now() 12 12 + }, 13 13 + afterHandle: ({ request, set }: any) => { 14 14 + const duration = Date.now() - ((request as any).__startTime || Date.now()) 15 15 + const url = new URL(request.url) 16 16 + 17 17 + metricsCollector.recordRequest( 18 18 + url.pathname, 19 19 + request.method, 20 20 + set.status || 200, 21 21 + duration, 22 22 + service 23 23 + ) 24 24 + }, 25 25 + onError: ({ request, error, set }: any) => { 26 26 + const duration = Date.now() - ((request as any).__startTime || Date.now()) 27 27 + const url = new URL(request.url) 28 28 + 29 29 + metricsCollector.recordRequest( 30 30 + url.pathname, 31 31 + request.method, 32 32 + set.status || 500, 33 33 + duration, 34 34 + service 35 35 + ) 36 36 + 37 37 + // Don't log 404 errors 38 38 + const statusCode = set.status || 500 39 39 + if (statusCode !== 404) { 40 40 + logCollector.error( 41 41 + `Request failed: ${request.method} ${url.pathname}`, 42 42 + service, 43 43 + error, 44 44 + { statusCode } 45 45 + ) 46 46 + } 47 47 + } 48 48 + } 49 49 + }

+44

packages/@wisp/observability/src/middleware/hono.ts

··· 1 1 + import type { Context } from 'hono' 2 2 + import { metricsCollector, logCollector } from '../core' 3 3 + 4 4 + /** 5 5 + * Hono middleware for observability 6 6 + * Tracks request metrics 7 7 + */ 8 8 + export function observabilityMiddleware(service: string) { 9 9 + return async (c: Context, next: () => Promise<void>) => { 10 10 + const startTime = Date.now() 11 11 + 12 12 + await next() 13 13 + 14 14 + const duration = Date.now() - startTime 15 15 + const { pathname } = new URL(c.req.url) 16 16 + 17 17 + metricsCollector.recordRequest( 18 18 + pathname, 19 19 + c.req.method, 20 20 + c.res.status, 21 21 + duration, 22 22 + service 23 23 + ) 24 24 + } 25 25 + } 26 26 + 27 27 + /** 28 28 + * Hono error handler for observability 29 29 + * Logs errors with context 30 30 + */ 31 31 + export function observabilityErrorHandler(service: string) { 32 32 + return (err: Error, c: Context) => { 33 33 + const { pathname } = new URL(c.req.url) 34 34 + 35 35 + logCollector.error( 36 36 + `Request failed: ${c.req.method} ${pathname}`, 37 37 + service, 38 38 + err, 39 39 + { statusCode: c.res.status || 500 } 40 40 + ) 41 41 + 42 42 + return c.text('Internal Server Error', 500) 43 43 + } 44 44 + }

+9

packages/@wisp/observability/tsconfig.json

··· 1 1 + { 2 2 + "extends": "../../../tsconfig.json", 3 3 + "compilerOptions": { 4 4 + "outDir": "./dist", 5 5 + "rootDir": "./src" 6 6 + }, 7 7 + "include": ["src/**/*"], 8 8 + "exclude": ["node_modules", "dist"] 9 9 + }

+14

packages/@wisp/safe-fetch/package.json

··· 1 1 + { 2 2 + "name": "@wisp/safe-fetch", 3 3 + "version": "1.0.0", 4 4 + "private": true, 5 5 + "type": "module", 6 6 + "main": "./src/index.ts", 7 7 + "types": "./src/index.ts", 8 8 + "exports": { 9 9 + ".": { 10 10 + "types": "./src/index.ts", 11 11 + "default": "./src/index.ts" 12 12 + } 13 13 + } 14 14 + }

+187

packages/@wisp/safe-fetch/src/index.ts

··· 1 1 + /** 2 2 + * SSRF-hardened fetch utility 3 3 + * Prevents requests to private networks, localhost, and enforces timeouts/size limits 4 4 + */ 5 5 + 6 6 + const BLOCKED_IP_RANGES = [ 7 7 + /^127\./, // 127.0.0.0/8 - Loopback 8 8 + /^10\./, // 10.0.0.0/8 - Private 9 9 + /^172\.(1[6-9]|2\d|3[01])\./, // 172.16.0.0/12 - Private 10 10 + /^192\.168\./, // 192.168.0.0/16 - Private 11 11 + /^169\.254\./, // 169.254.0.0/16 - Link-local 12 12 + /^::1$/, // IPv6 loopback 13 13 + /^fe80:/, // IPv6 link-local 14 14 + /^fc00:/, // IPv6 unique local 15 15 + /^fd00:/, // IPv6 unique local 16 16 + ]; 17 17 + 18 18 + const BLOCKED_HOSTS = [ 19 19 + 'localhost', 20 20 + 'metadata.google.internal', 21 21 + '169.254.169.254', 22 22 + ]; 23 23 + 24 24 + const FETCH_TIMEOUT = 120000; // 120 seconds 25 25 + const FETCH_TIMEOUT_BLOB = 120000; // 2 minutes for blob downloads 26 26 + const MAX_RESPONSE_SIZE = 10 * 1024 * 1024; // 10MB 27 27 + const MAX_JSON_SIZE = 1024 * 1024; // 1MB 28 28 + const MAX_BLOB_SIZE = 500 * 1024 * 1024; // 500MB 29 29 + const MAX_REDIRECTS = 10; 30 30 + 31 31 + function isBlockedHost(hostname: string): boolean { 32 32 + const lowerHost = hostname.toLowerCase(); 33 33 + 34 34 + if (BLOCKED_HOSTS.includes(lowerHost)) { 35 35 + return true; 36 36 + } 37 37 + 38 38 + for (const pattern of BLOCKED_IP_RANGES) { 39 39 + if (pattern.test(lowerHost)) { 40 40 + return true; 41 41 + } 42 42 + } 43 43 + 44 44 + return false; 45 45 + } 46 46 + 47 47 + export async function safeFetch( 48 48 + url: string, 49 49 + options?: RequestInit & { maxSize?: number; timeout?: number } 50 50 + ): Promise<Response> { 51 51 + const timeoutMs = options?.timeout ?? FETCH_TIMEOUT; 52 52 + const maxSize = options?.maxSize ?? MAX_RESPONSE_SIZE; 53 53 + 54 54 + // Parse and validate URL 55 55 + let parsedUrl: URL; 56 56 + try { 57 57 + parsedUrl = new URL(url); 58 58 + } catch (err) { 59 59 + throw new Error(`Invalid URL: ${url}`); 60 60 + } 61 61 + 62 62 + if (!['http:', 'https:'].includes(parsedUrl.protocol)) { 63 63 + throw new Error(`Blocked protocol: ${parsedUrl.protocol}`); 64 64 + } 65 65 + 66 66 + const hostname = parsedUrl.hostname; 67 67 + if (isBlockedHost(hostname)) { 68 68 + throw new Error(`Blocked host: ${hostname}`); 69 69 + } 70 70 + 71 71 + const controller = new AbortController(); 72 72 + const timeoutId = setTimeout(() => controller.abort(), timeoutMs); 73 73 + 74 74 + try { 75 75 + const response = await fetch(url, { 76 76 + ...options, 77 77 + signal: controller.signal, 78 78 + redirect: 'follow', 79 79 + }); 80 80 + 81 81 + const contentLength = response.headers.get('content-length'); 82 82 + if (contentLength && parseInt(contentLength, 10) > maxSize) { 83 83 + throw new Error(`Response too large: ${contentLength} bytes`); 84 84 + } 85 85 + 86 86 + return response; 87 87 + } catch (err) { 88 88 + if (err instanceof Error && err.name === 'AbortError') { 89 89 + throw new Error(`Request timeout after ${timeoutMs}ms`); 90 90 + } 91 91 + throw err; 92 92 + } finally { 93 93 + clearTimeout(timeoutId); 94 94 + } 95 95 + } 96 96 + 97 97 + export async function safeFetchJson<T = any>( 98 98 + url: string, 99 99 + options?: RequestInit & { maxSize?: number; timeout?: number } 100 100 + ): Promise<T> { 101 101 + const maxJsonSize = options?.maxSize ?? MAX_JSON_SIZE; 102 102 + const response = await safeFetch(url, { ...options, maxSize: maxJsonSize }); 103 103 + 104 104 + if (!response.ok) { 105 105 + throw new Error(`HTTP ${response.status}: ${response.statusText}`); 106 106 + } 107 107 + 108 108 + const reader = response.body?.getReader(); 109 109 + if (!reader) { 110 110 + throw new Error('No response body'); 111 111 + } 112 112 + 113 113 + const chunks: Uint8Array[] = []; 114 114 + let totalSize = 0; 115 115 + 116 116 + try { 117 117 + while (true) { 118 118 + const { done, value } = await reader.read(); 119 119 + if (done) break; 120 120 + 121 121 + totalSize += value.length; 122 122 + if (totalSize > maxJsonSize) { 123 123 + throw new Error(`Response exceeds max size: ${maxJsonSize} bytes`); 124 124 + } 125 125 + 126 126 + chunks.push(value); 127 127 + } 128 128 + } finally { 129 129 + reader.releaseLock(); 130 130 + } 131 131 + 132 132 + const combined = new Uint8Array(totalSize); 133 133 + let offset = 0; 134 134 + for (const chunk of chunks) { 135 135 + combined.set(chunk, offset); 136 136 + offset += chunk.length; 137 137 + } 138 138 + 139 139 + const text = new TextDecoder().decode(combined); 140 140 + return JSON.parse(text); 141 141 + } 142 142 + 143 143 + export async function safeFetchBlob( 144 144 + url: string, 145 145 + options?: RequestInit & { maxSize?: number; timeout?: number } 146 146 + ): Promise<Uint8Array> { 147 147 + const maxBlobSize = options?.maxSize ?? MAX_BLOB_SIZE; 148 148 + const timeoutMs = options?.timeout ?? FETCH_TIMEOUT_BLOB; 149 149 + const response = await safeFetch(url, { ...options, maxSize: maxBlobSize, timeout: timeoutMs }); 150 150 + 151 151 + if (!response.ok) { 152 152 + throw new Error(`HTTP ${response.status}: ${response.statusText}`); 153 153 + } 154 154 + 155 155 + const reader = response.body?.getReader(); 156 156 + if (!reader) { 157 157 + throw new Error('No response body'); 158 158 + } 159 159 + 160 160 + const chunks: Uint8Array[] = []; 161 161 + let totalSize = 0; 162 162 + 163 163 + try { 164 164 + while (true) { 165 165 + const { done, value } = await reader.read(); 166 166 + if (done) break; 167 167 + 168 168 + totalSize += value.length; 169 169 + if (totalSize > maxBlobSize) { 170 170 + throw new Error(`Blob exceeds max size: ${maxBlobSize} bytes`); 171 171 + } 172 172 + 173 173 + chunks.push(value); 174 174 + } 175 175 + } finally { 176 176 + reader.releaseLock(); 177 177 + } 178 178 + 179 179 + const combined = new Uint8Array(totalSize); 180 180 + let offset = 0; 181 181 + for (const chunk of chunks) { 182 182 + combined.set(chunk, offset); 183 183 + offset += chunk.length; 184 184 + } 185 185 + 186 186 + return combined; 187 187 + }

+9

packages/@wisp/safe-fetch/tsconfig.json

··· 1 1 + { 2 2 + "extends": "../../../tsconfig.json", 3 3 + "compilerOptions": { 4 4 + "outDir": "./dist", 5 5 + "rootDir": "./src" 6 6 + }, 7 7 + "include": ["src/**/*"], 8 8 + "exclude": ["node_modules", "dist"] 9 9 + }

public/acceptable-use/acceptable-use.tsx apps/main-app/public/acceptable-use/acceptable-use.tsx

public/acceptable-use/index.html apps/main-app/public/acceptable-use/index.html

public/admin/admin.tsx apps/main-app/public/admin/admin.tsx

public/admin/index.html apps/main-app/public/admin/index.html

public/admin/styles.css apps/main-app/public/admin/styles.css

public/android-chrome-192x192.png apps/main-app/public/android-chrome-192x192.png

public/android-chrome-512x512.png apps/main-app/public/android-chrome-512x512.png

public/apple-touch-icon.png apps/main-app/public/apple-touch-icon.png

public/components/ui/badge.tsx apps/main-app/public/components/ui/badge.tsx

public/components/ui/button.tsx apps/main-app/public/components/ui/button.tsx

public/components/ui/card.tsx apps/main-app/public/components/ui/card.tsx

public/components/ui/checkbox.tsx apps/main-app/public/components/ui/checkbox.tsx

public/components/ui/code-block.tsx apps/main-app/public/components/ui/code-block.tsx

public/components/ui/dialog.tsx apps/main-app/public/components/ui/dialog.tsx

public/components/ui/input.tsx apps/main-app/public/components/ui/input.tsx

public/components/ui/label.tsx apps/main-app/public/components/ui/label.tsx

public/components/ui/radio-group.tsx apps/main-app/public/components/ui/radio-group.tsx

public/components/ui/skeleton.tsx apps/main-app/public/components/ui/skeleton.tsx

public/components/ui/tabs.tsx apps/main-app/public/components/ui/tabs.tsx

public/editor/components/TabSkeleton.tsx apps/main-app/public/editor/components/TabSkeleton.tsx

public/editor/editor.tsx apps/main-app/public/editor/editor.tsx

public/editor/hooks/useDomainData.ts apps/main-app/public/editor/hooks/useDomainData.ts

public/editor/hooks/useSiteData.ts apps/main-app/public/editor/hooks/useSiteData.ts

public/editor/hooks/useUserInfo.ts apps/main-app/public/editor/hooks/useUserInfo.ts

public/editor/index.html apps/main-app/public/editor/index.html

public/editor/tabs/CLITab.tsx apps/main-app/public/editor/tabs/CLITab.tsx

public/editor/tabs/DomainsTab.tsx apps/main-app/public/editor/tabs/DomainsTab.tsx

public/editor/tabs/SitesTab.tsx apps/main-app/public/editor/tabs/SitesTab.tsx

public/editor/tabs/UploadTab.tsx apps/main-app/public/editor/tabs/UploadTab.tsx

public/favicon-16x16.png apps/main-app/public/favicon-16x16.png

public/favicon-32x32.png apps/main-app/public/favicon-32x32.png

public/favicon.ico apps/main-app/public/favicon.ico

public/index.html apps/main-app/public/index.html

public/index.tsx apps/main-app/public/index.tsx

public/layouts/index.tsx apps/main-app/public/layouts/index.tsx

public/lib/api.ts apps/main-app/public/lib/api.ts

public/lib/utils.ts apps/main-app/public/lib/utils.ts

public/onboarding/index.html apps/main-app/public/onboarding/index.html

public/onboarding/onboarding.tsx apps/main-app/public/onboarding/onboarding.tsx

public/robots.txt apps/main-app/public/robots.txt

public/screenshots/atproto-ui_wisp_place.png apps/main-app/public/screenshots/atproto-ui_wisp_place.png

public/screenshots/avalanche_moe.png apps/main-app/public/screenshots/avalanche_moe.png

public/screenshots/brotosolar_wisp_place.png apps/main-app/public/screenshots/brotosolar_wisp_place.png

public/screenshots/erisa_wisp_place.png apps/main-app/public/screenshots/erisa_wisp_place.png

public/screenshots/hayden_moe.png apps/main-app/public/screenshots/hayden_moe.png

public/screenshots/kot_pink.png apps/main-app/public/screenshots/kot_pink.png

public/screenshots/moover_wisp_place.png apps/main-app/public/screenshots/moover_wisp_place.png

public/screenshots/nekomimi_pet.png apps/main-app/public/screenshots/nekomimi_pet.png

public/screenshots/pdsls_wisp_place.png apps/main-app/public/screenshots/pdsls_wisp_place.png

public/screenshots/plc-bench_wisp_place.png apps/main-app/public/screenshots/plc-bench_wisp_place.png

public/screenshots/rainygoo_se.png apps/main-app/public/screenshots/rainygoo_se.png

public/screenshots/rd_jbcrn_dev.png apps/main-app/public/screenshots/rd_jbcrn_dev.png

public/screenshots/sites_wisp_place_did_plc_3whdb534faiczugsz5fnohh6_rafa.png apps/main-app/public/screenshots/sites_wisp_place_did_plc_3whdb534faiczugsz5fnohh6_rafa.png

public/screenshots/sites_wisp_place_did_plc_524tuhdhh3m7li5gycdn6boe_plcbundle-watch.png apps/main-app/public/screenshots/sites_wisp_place_did_plc_524tuhdhh3m7li5gycdn6boe_plcbundle-watch.png

public/screenshots/system_grdnsys_no.png apps/main-app/public/screenshots/system_grdnsys_no.png

public/screenshots/tealfm_indexx_dev.png apps/main-app/public/screenshots/tealfm_indexx_dev.png

public/screenshots/tigwyk_wisp_place.png apps/main-app/public/screenshots/tigwyk_wisp_place.png

public/screenshots/wfr_jbc_lol.png apps/main-app/public/screenshots/wfr_jbc_lol.png

public/screenshots/wisp_jbc_lol.png apps/main-app/public/screenshots/wisp_jbc_lol.png

public/screenshots/wisp_soverth_f5_si.png apps/main-app/public/screenshots/wisp_soverth_f5_si.png

public/screenshots/www_miriscient_org.png apps/main-app/public/screenshots/www_miriscient_org.png

public/screenshots/www_wlo_moe.png apps/main-app/public/screenshots/www_wlo_moe.png

public/site.webmanifest apps/main-app/public/site.webmanifest

public/styles/global.css apps/main-app/public/styles/global.css

public/transparent-full-size-ico.png apps/main-app/public/transparent-full-size-ico.png

scripts/change-admin-password.ts apps/main-app/scripts/change-admin-password.ts

+1 -1

scripts/create-admin.ts apps/main-app/scripts/create-admin.ts

··· 1 1 // Quick script to create admin user with randomly generated password 2 2 - import { adminAuth } from './src/lib/admin-auth' 2 2 + import { adminAuth } from '../src/lib/admin-auth' 3 3 import { randomBytes } from 'crypto' 4 4 5 5 // Generate a secure random password

scripts/screenshot-sites.ts apps/main-app/scripts/screenshot-sites.ts

+7 -3

src/index.ts apps/main-app/src/index.ts

··· 4 4 import { staticPlugin } from '@elysiajs/static' 5 5 6 6 import type { Config } from './lib/types' 7 7 - import { BASE_HOST } from './lib/constants' 7 7 + import { BASE_HOST } from '@wisp/constants' 8 8 import { 9 9 createClientMetadata, 10 10 getOAuthClient, ··· 20 20 import { siteRoutes } from './routes/site' 21 21 import { csrfProtection } from './lib/csrf' 22 22 import { DNSVerificationWorker } from './lib/dns-verification-worker' 23 23 - import { logger, logCollector, observabilityMiddleware } from './lib/observability' 23 23 + import { createLogger, logCollector } from '@wisp/observability' 24 24 + import { observabilityMiddleware } from '@wisp/observability/middleware/elysia' 24 25 import { promptAdminSetup } from './lib/admin-auth' 25 26 import { adminRoutes } from './routes/admin' 27 27 + 28 28 + const logger = createLogger('main-app') 26 29 27 30 const config: Config = { 28 31 domain: (Bun.env.DOMAIN ?? `https://${BASE_HOST}`) as Config['domain'], ··· 112 115 .use(adminRoutes(cookieSecret)) 113 116 .use( 114 117 await staticPlugin({ 118 118 + assets: 'apps/main-app/public', 115 119 prefix: '/' 116 120 }) 117 121 ) ··· 148 152 const glob = new Glob('*.png') 149 153 const screenshots: string[] = [] 150 154 151 151 - for await (const file of glob.scan('./public/screenshots')) { 155 155 + for await (const file of glob.scan('./apps/main-app/public/screenshots')) { 152 156 screenshots.push(file) 153 157 } 154 158

+1 -1

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

··· 9 9 type MethodConfigOrHandler, 10 10 createServer as createXrpcServer, 11 11 } from '@atproto/xrpc-server' 12 12 - import { schemas } from './lexicons.js' 12 12 + import { schemas } from './lexicons' 13 13 14 14 export function createServer(options?: XrpcOptions): Server { 15 15 return new Server(options)

+1 -1

src/lexicons/lexicons.ts packages/@wisp/lexicons/src/lexicons.ts

··· 7 7 ValidationError, 8 8 type ValidationResult, 9 9 } from '@atproto/lexicon' 10 10 - import { type $Typed, is$typed, maybe$typed } from './util.js' 10 10 + import { type $Typed, is$typed, maybe$typed } from './util' 11 11 12 12 export const schemaDict = { 13 13 PlaceWispFs: {

-110

src/lexicons/types/place/wisp/fs.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 { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util' 8 8 - 9 9 - const is$typed = _is$typed, 10 10 - validate = _validate 11 11 - const id = 'place.wisp.fs' 12 12 - 13 13 - export interface Main { 14 14 - $type: 'place.wisp.fs' 15 15 - site: string 16 16 - root: Directory 17 17 - fileCount?: number 18 18 - createdAt: string 19 19 - [k: string]: unknown 20 20 - } 21 21 - 22 22 - const hashMain = 'main' 23 23 - 24 24 - export function isMain<V>(v: V) { 25 25 - return is$typed(v, id, hashMain) 26 26 - } 27 27 - 28 28 - export function validateMain<V>(v: V) { 29 29 - return validate<Main & V>(v, id, hashMain, true) 30 30 - } 31 31 - 32 32 - export { 33 33 - type Main as Record, 34 34 - isMain as isRecord, 35 35 - validateMain as validateRecord, 36 36 - } 37 37 - 38 38 - export interface File { 39 39 - $type?: 'place.wisp.fs#file' 40 40 - type: 'file' 41 41 - /** Content blob ref */ 42 42 - blob: BlobRef 43 43 - /** Content encoding (e.g., gzip for compressed files) */ 44 44 - encoding?: 'gzip' 45 45 - /** Original MIME type before compression */ 46 46 - mimeType?: string 47 47 - /** True if blob content is base64-encoded (used to bypass PDS content sniffing) */ 48 48 - base64?: boolean 49 49 - } 50 50 - 51 51 - const hashFile = 'file' 52 52 - 53 53 - export function isFile<V>(v: V) { 54 54 - return is$typed(v, id, hashFile) 55 55 - } 56 56 - 57 57 - export function validateFile<V>(v: V) { 58 58 - return validate<File & V>(v, id, hashFile) 59 59 - } 60 60 - 61 61 - export interface Directory { 62 62 - $type?: 'place.wisp.fs#directory' 63 63 - type: 'directory' 64 64 - entries: Entry[] 65 65 - } 66 66 - 67 67 - const hashDirectory = 'directory' 68 68 - 69 69 - export function isDirectory<V>(v: V) { 70 70 - return is$typed(v, id, hashDirectory) 71 71 - } 72 72 - 73 73 - export function validateDirectory<V>(v: V) { 74 74 - return validate<Directory & V>(v, id, hashDirectory) 75 75 - } 76 76 - 77 77 - export interface Entry { 78 78 - $type?: 'place.wisp.fs#entry' 79 79 - name: string 80 80 - node: $Typed<File> | $Typed<Directory> | $Typed<Subfs> | { $type: string } 81 81 - } 82 82 - 83 83 - const hashEntry = 'entry' 84 84 - 85 85 - export function isEntry<V>(v: V) { 86 86 - return is$typed(v, id, hashEntry) 87 87 - } 88 88 - 89 89 - export function validateEntry<V>(v: V) { 90 90 - return validate<Entry & V>(v, id, hashEntry) 91 91 - } 92 92 - 93 93 - export interface Subfs { 94 94 - $type?: 'place.wisp.fs#subfs' 95 95 - type: 'subfs' 96 96 - /** AT-URI pointing to a place.wisp.subfs record containing this subtree. */ 97 97 - subject: string 98 98 - /** If true (default), the subfs record's root entries are merged (flattened) into the parent directory, replacing the subfs entry. If false, the subfs entries are placed in a subdirectory with the subfs entry's name. Flat merging is useful for splitting large directories across multiple records while maintaining a flat structure. */ 99 99 - flat?: boolean 100 100 - } 101 101 - 102 102 - const hashSubfs = 'subfs' 103 103 - 104 104 - export function isSubfs<V>(v: V) { 105 105 - return is$typed(v, id, hashSubfs) 106 106 - } 107 107 - 108 108 - export function validateSubfs<V>(v: V) { 109 109 - return validate<Subfs & V>(v, id, hashSubfs) 110 110 - }

-65

src/lexicons/types/place/wisp/settings.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 { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util' 8 8 - 9 9 - const is$typed = _is$typed, 10 10 - validate = _validate 11 11 - const id = 'place.wisp.settings' 12 12 - 13 13 - export interface Main { 14 14 - $type: 'place.wisp.settings' 15 15 - /** Enable directory listing mode for paths that resolve to directories without an index file. Incompatible with spaMode. */ 16 16 - directoryListing: boolean 17 17 - /** File to serve for all routes (e.g., 'index.html'). When set, enables SPA mode where all non-file requests are routed to this file. Incompatible with directoryListing and custom404. */ 18 18 - spaMode?: string 19 19 - /** Custom 404 error page file path. Incompatible with directoryListing and spaMode. */ 20 20 - custom404?: string 21 21 - /** Ordered list of files to try when serving a directory. Defaults to ['index.html'] if not specified. */ 22 22 - indexFiles?: string[] 23 23 - /** Enable clean URL routing. When enabled, '/about' will attempt to serve '/about.html' or '/about/index.html' automatically. */ 24 24 - cleanUrls: boolean 25 25 - /** Custom HTTP headers to set on responses */ 26 26 - headers?: CustomHeader[] 27 27 - [k: string]: unknown 28 28 - } 29 29 - 30 30 - const hashMain = 'main' 31 31 - 32 32 - export function isMain<V>(v: V) { 33 33 - return is$typed(v, id, hashMain) 34 34 - } 35 35 - 36 36 - export function validateMain<V>(v: V) { 37 37 - return validate<Main & V>(v, id, hashMain, true) 38 38 - } 39 39 - 40 40 - export { 41 41 - type Main as Record, 42 42 - isMain as isRecord, 43 43 - validateMain as validateRecord, 44 44 - } 45 45 - 46 46 - /** Custom HTTP header configuration */ 47 47 - export interface CustomHeader { 48 48 - $type?: 'place.wisp.settings#customHeader' 49 49 - /** HTTP header name (e.g., 'Cache-Control', 'X-Frame-Options') */ 50 50 - name: string 51 51 - /** HTTP header value */ 52 52 - value: string 53 53 - /** Optional glob pattern to apply this header to specific paths (e.g., '*.html', '/assets/*'). If not specified, applies to all paths. */ 54 54 - path?: string 55 55 - } 56 56 - 57 57 - const hashCustomHeader = 'customHeader' 58 58 - 59 59 - export function isCustomHeader<V>(v: V) { 60 60 - return is$typed(v, id, hashCustomHeader) 61 61 - } 62 62 - 63 63 - export function validateCustomHeader<V>(v: V) { 64 64 - return validate<CustomHeader & V>(v, id, hashCustomHeader) 65 65 - }

-107

src/lexicons/types/place/wisp/subfs.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 { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util' 8 8 - 9 9 - const is$typed = _is$typed, 10 10 - validate = _validate 11 11 - const id = 'place.wisp.subfs' 12 12 - 13 13 - export interface Main { 14 14 - $type: 'place.wisp.subfs' 15 15 - root: Directory 16 16 - fileCount?: number 17 17 - createdAt: string 18 18 - [k: string]: unknown 19 19 - } 20 20 - 21 21 - const hashMain = 'main' 22 22 - 23 23 - export function isMain<V>(v: V) { 24 24 - return is$typed(v, id, hashMain) 25 25 - } 26 26 - 27 27 - export function validateMain<V>(v: V) { 28 28 - return validate<Main & V>(v, id, hashMain, true) 29 29 - } 30 30 - 31 31 - export { 32 32 - type Main as Record, 33 33 - isMain as isRecord, 34 34 - validateMain as validateRecord, 35 35 - } 36 36 - 37 37 - export interface File { 38 38 - $type?: 'place.wisp.subfs#file' 39 39 - type: 'file' 40 40 - /** Content blob ref */ 41 41 - blob: BlobRef 42 42 - /** Content encoding (e.g., gzip for compressed files) */ 43 43 - encoding?: 'gzip' 44 44 - /** Original MIME type before compression */ 45 45 - mimeType?: string 46 46 - /** True if blob content is base64-encoded (used to bypass PDS content sniffing) */ 47 47 - base64?: boolean 48 48 - } 49 49 - 50 50 - const hashFile = 'file' 51 51 - 52 52 - export function isFile<V>(v: V) { 53 53 - return is$typed(v, id, hashFile) 54 54 - } 55 55 - 56 56 - export function validateFile<V>(v: V) { 57 57 - return validate<File & V>(v, id, hashFile) 58 58 - } 59 59 - 60 60 - export interface Directory { 61 61 - $type?: 'place.wisp.subfs#directory' 62 62 - type: 'directory' 63 63 - entries: Entry[] 64 64 - } 65 65 - 66 66 - const hashDirectory = 'directory' 67 67 - 68 68 - export function isDirectory<V>(v: V) { 69 69 - return is$typed(v, id, hashDirectory) 70 70 - } 71 71 - 72 72 - export function validateDirectory<V>(v: V) { 73 73 - return validate<Directory & V>(v, id, hashDirectory) 74 74 - } 75 75 - 76 76 - export interface Entry { 77 77 - $type?: 'place.wisp.subfs#entry' 78 78 - name: string 79 79 - node: $Typed<File> | $Typed<Directory> | $Typed<Subfs> | { $type: string } 80 80 - } 81 81 - 82 82 - const hashEntry = 'entry' 83 83 - 84 84 - export function isEntry<V>(v: V) { 85 85 - return is$typed(v, id, hashEntry) 86 86 - } 87 87 - 88 88 - export function validateEntry<V>(v: V) { 89 89 - return validate<Entry & V>(v, id, hashEntry) 90 90 - } 91 91 - 92 92 - export interface Subfs { 93 93 - $type?: 'place.wisp.subfs#subfs' 94 94 - type: 'subfs' 95 95 - /** AT-URI pointing to another place.wisp.subfs record for nested subtrees. When expanded, the referenced record's root entries are merged (flattened) into the parent directory, allowing recursive splitting of large directory structures. */ 96 96 - subject: string 97 97 - } 98 98 - 99 99 - const hashSubfs = 'subfs' 100 100 - 101 101 - export function isSubfs<V>(v: V) { 102 102 - return is$typed(v, id, hashSubfs) 103 103 - } 104 104 - 105 105 - export function validateSubfs<V>(v: V) { 106 106 - return validate<Subfs & V>(v, id, hashSubfs) 107 107 - }

-82

src/lexicons/util.ts

··· 1 1 - /** 2 2 - * GENERATED CODE - DO NOT MODIFY 3 3 - */ 4 4 - 5 5 - import { type ValidationResult } from '@atproto/lexicon' 6 6 - 7 7 - export type OmitKey<T, K extends keyof T> = { 8 8 - [K2 in keyof T as K2 extends K ? never : K2]: T[K2] 9 9 - } 10 10 - 11 11 - export type $Typed<V, T extends string = string> = V & { $type: T } 12 12 - export type Un$Typed<V extends { $type?: string }> = OmitKey<V, '$type'> 13 13 - 14 14 - export type $Type<Id extends string, Hash extends string> = Hash extends 'main' 15 15 - ? Id 16 16 - : `${Id}#${Hash}` 17 17 - 18 18 - function isObject<V>(v: V): v is V & object { 19 19 - return v != null && typeof v === 'object' 20 20 - } 21 21 - 22 22 - function is$type<Id extends string, Hash extends string>( 23 23 - $type: unknown, 24 24 - id: Id, 25 25 - hash: Hash, 26 26 - ): $type is $Type<Id, Hash> { 27 27 - return hash === 'main' 28 28 - ? $type === id 29 29 - : // $type === `${id}#${hash}` 30 30 - typeof $type === 'string' && 31 31 - $type.length === id.length + 1 + hash.length && 32 32 - $type.charCodeAt(id.length) === 35 /* '#' */ && 33 33 - $type.startsWith(id) && 34 34 - $type.endsWith(hash) 35 35 - } 36 36 - 37 37 - export type $TypedObject< 38 38 - V, 39 39 - Id extends string, 40 40 - Hash extends string, 41 41 - > = V extends { 42 42 - $type: $Type<Id, Hash> 43 43 - } 44 44 - ? V 45 45 - : V extends { $type?: string } 46 46 - ? V extends { $type?: infer T extends $Type<Id, Hash> } 47 47 - ? V & { $type: T } 48 48 - : never 49 49 - : V & { $type: $Type<Id, Hash> } 50 50 - 51 51 - export function is$typed<V, Id extends string, Hash extends string>( 52 52 - v: V, 53 53 - id: Id, 54 54 - hash: Hash, 55 55 - ): v is $TypedObject<V, Id, Hash> { 56 56 - return isObject(v) && '$type' in v && is$type(v.$type, id, hash) 57 57 - } 58 58 - 59 59 - export function maybe$typed<V, Id extends string, Hash extends string>( 60 60 - v: V, 61 61 - id: Id, 62 62 - hash: Hash, 63 63 - ): v is V & object & { $type?: $Type<Id, Hash> } { 64 64 - return ( 65 65 - isObject(v) && 66 66 - ('$type' in v ? v.$type === undefined || is$type(v.$type, id, hash) : true) 67 67 - ) 68 68 - } 69 69 - 70 70 - export type Validator<R = unknown> = (v: unknown) => ValidationResult<R> 71 71 - export type ValidatorParam<V extends Validator> = 72 72 - V extends Validator<infer R> ? R : never 73 73 - 74 74 - /** 75 75 - * Utility function that allows to convert a "validate*" utility function into a 76 76 - * type predicate. 77 77 - */ 78 78 - export function asPredicate<V extends Validator>(validate: V) { 79 79 - return function <T>(v: T): v is T & ValidatorParam<V> { 80 80 - return validate(v).success 81 81 - } 82 82 - }

src/lib/admin-auth.ts apps/main-app/src/lib/admin-auth.ts

-4

src/lib/constants.ts

··· 1 1 - export const BASE_HOST = Bun.env.BASE_DOMAIN || "wisp.place"; 2 2 - export const MAX_SITE_SIZE = 300 * 1024 * 1024; //300MB 3 3 - export const MAX_FILE_SIZE = 100 * 1024 * 1024; //100MB 4 4 - export const MAX_FILE_COUNT = 1000;

src/lib/csrf.test.ts apps/main-app/src/lib/csrf.test.ts

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

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

+1 -1

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

··· 1 1 import { SQL } from "bun"; 2 2 - import { BASE_HOST } from "./constants"; 2 2 + import { BASE_HOST } from "@wisp/constants"; 3 3 4 4 export const db = new SQL( 5 5 process.env.NODE_ENV === 'production'

src/lib/dns-verification-worker.ts apps/main-app/src/lib/dns-verification-worker.ts

src/lib/dns-verify.ts apps/main-app/src/lib/dns-verify.ts

-46

src/lib/logger.ts

··· 1 1 - // Secure logging utility - only verbose in development mode 2 2 - const isDev = process.env.NODE_ENV !== 'production'; 3 3 - 4 4 - export const logger = { 5 5 - // Always log these (safe for production) 6 6 - info: (...args: any[]) => { 7 7 - console.log(...args); 8 8 - }, 9 9 - 10 10 - // Only log in development (may contain sensitive info) 11 11 - debug: (...args: any[]) => { 12 12 - if (isDev) { 13 13 - console.debug(...args); 14 14 - } 15 15 - }, 16 16 - 17 17 - // Warning logging (always logged but may be sanitized in production) 18 18 - warn: (message: string, context?: Record<string, any>) => { 19 19 - if (isDev) { 20 20 - console.warn(message, context); 21 21 - } else { 22 22 - console.warn(message); 23 23 - } 24 24 - }, 25 25 - 26 26 - // Safe error logging - sanitizes in production 27 27 - error: (message: string, error?: any) => { 28 28 - if (isDev) { 29 29 - // Development: log full error details 30 30 - console.error(message, error); 31 31 - } else { 32 32 - // Production: log only the message, not error details 33 33 - console.error(message); 34 34 - } 35 35 - }, 36 36 - 37 37 - // Log error with context but sanitize sensitive data in production 38 38 - errorWithContext: (message: string, context?: Record<string, any>, error?: any) => { 39 39 - if (isDev) { 40 40 - console.error(message, context, error); 41 41 - } else { 42 42 - // In production, only log the message 43 43 - console.error(message); 44 44 - } 45 45 - } 46 46 - };

+1 -1

src/lib/oauth-client.ts apps/main-app/src/lib/oauth-client.ts

··· 70 70 // Check if expired 71 71 const expiresAt = Number(result[0].expires_at); 72 72 if (expiresAt && now > expiresAt) { 73 73 - logger.debug('[sessionStore] Session expired, deleting', sub); 73 73 + logger.debug('[sessionStore] Session expired, deleting', { sub }); 74 74 await db`DELETE FROM oauth_sessions WHERE sub = ${sub}`; 75 75 return undefined; 76 76 }

-339

src/lib/observability.ts

··· 1 1 - // DIY Observability - Logs, Metrics, and Error Tracking 2 2 - // Types 3 3 - export interface LogEntry { 4 4 - id: string 5 5 - timestamp: Date 6 6 - level: 'info' | 'warn' | 'error' | 'debug' 7 7 - message: string 8 8 - service: string 9 9 - context?: Record<string, any> 10 10 - traceId?: string 11 11 - eventType?: string 12 12 - } 13 13 - 14 14 - export interface ErrorEntry { 15 15 - id: string 16 16 - timestamp: Date 17 17 - message: string 18 18 - stack?: string 19 19 - service: string 20 20 - context?: Record<string, any> 21 21 - count: number // How many times this error occurred 22 22 - lastSeen: Date 23 23 - } 24 24 - 25 25 - export interface MetricEntry { 26 26 - timestamp: Date 27 27 - path: string 28 28 - method: string 29 29 - statusCode: number 30 30 - duration: number // in milliseconds 31 31 - service: string 32 32 - } 33 33 - 34 34 - export interface DatabaseStats { 35 35 - totalSites: number 36 36 - totalDomains: number 37 37 - totalCustomDomains: number 38 38 - recentSites: any[] 39 39 - recentDomains: any[] 40 40 - } 41 41 - 42 42 - // In-memory storage with rotation 43 43 - const MAX_LOGS = 5000 44 44 - const MAX_ERRORS = 500 45 45 - const MAX_METRICS = 10000 46 46 - 47 47 - const logs: LogEntry[] = [] 48 48 - const errors: Map<string, ErrorEntry> = new Map() 49 49 - const metrics: MetricEntry[] = [] 50 50 - 51 51 - // Helper to generate unique IDs 52 52 - let logCounter = 0 53 53 - let errorCounter = 0 54 54 - 55 55 - function generateId(prefix: string, counter: number): string { 56 56 - return `${prefix}-${Date.now()}-${counter}` 57 57 - } 58 58 - 59 59 - // Helper to extract event type from message 60 60 - function extractEventType(message: string): string | undefined { 61 61 - const match = message.match(/^\[([^\]]+)\]/) 62 62 - return match ? match[1] : undefined 63 63 - } 64 64 - 65 65 - // Log collector 66 66 - export const logCollector = { 67 67 - log(level: LogEntry['level'], message: string, service: string, context?: Record<string, any>, traceId?: string) { 68 68 - const entry: LogEntry = { 69 69 - id: generateId('log', logCounter++), 70 70 - timestamp: new Date(), 71 71 - level, 72 72 - message, 73 73 - service, 74 74 - context, 75 75 - traceId, 76 76 - eventType: extractEventType(message) 77 77 - } 78 78 - 79 79 - logs.unshift(entry) 80 80 - 81 81 - // Rotate if needed 82 82 - if (logs.length > MAX_LOGS) { 83 83 - logs.splice(MAX_LOGS) 84 84 - } 85 85 - 86 86 - // Also log to console for compatibility 87 87 - const contextStr = context ? ` ${JSON.stringify(context)}` : '' 88 88 - const traceStr = traceId ? ` [trace:${traceId}]` : '' 89 89 - console[level === 'debug' ? 'log' : level](`[${service}] ${message}${contextStr}${traceStr}`) 90 90 - }, 91 91 - 92 92 - info(message: string, service: string, context?: Record<string, any>, traceId?: string) { 93 93 - this.log('info', message, service, context, traceId) 94 94 - }, 95 95 - 96 96 - warn(message: string, service: string, context?: Record<string, any>, traceId?: string) { 97 97 - this.log('warn', message, service, context, traceId) 98 98 - }, 99 99 - 100 100 - error(message: string, service: string, error?: any, context?: Record<string, any>, traceId?: string) { 101 101 - const ctx = { ...context } 102 102 - if (error instanceof Error) { 103 103 - ctx.error = error.message 104 104 - ctx.stack = error.stack 105 105 - } else if (error) { 106 106 - ctx.error = String(error) 107 107 - } 108 108 - this.log('error', message, service, ctx, traceId) 109 109 - 110 110 - // Also track in errors 111 111 - errorTracker.track(message, service, error, context) 112 112 - }, 113 113 - 114 114 - debug(message: string, service: string, context?: Record<string, any>, traceId?: string) { 115 115 - if (process.env.NODE_ENV !== 'production') { 116 116 - this.log('debug', message, service, context, traceId) 117 117 - } 118 118 - }, 119 119 - 120 120 - getLogs(filter?: { level?: string; service?: string; limit?: number; search?: string; eventType?: string }) { 121 121 - let filtered = [...logs] 122 122 - 123 123 - if (filter?.level) { 124 124 - filtered = filtered.filter(log => log.level === filter.level) 125 125 - } 126 126 - 127 127 - if (filter?.service) { 128 128 - filtered = filtered.filter(log => log.service === filter.service) 129 129 - } 130 130 - 131 131 - if (filter?.eventType) { 132 132 - filtered = filtered.filter(log => log.eventType === filter.eventType) 133 133 - } 134 134 - 135 135 - if (filter?.search) { 136 136 - const search = filter.search.toLowerCase() 137 137 - filtered = filtered.filter(log => 138 138 - log.message.toLowerCase().includes(search) || 139 139 - (log.context ? JSON.stringify(log.context).toLowerCase().includes(search) : false) 140 140 - ) 141 141 - } 142 142 - 143 143 - const limit = filter?.limit || 100 144 144 - return filtered.slice(0, limit) 145 145 - }, 146 146 - 147 147 - clear() { 148 148 - logs.length = 0 149 149 - } 150 150 - } 151 151 - 152 152 - // Error tracker with deduplication 153 153 - export const errorTracker = { 154 154 - track(message: string, service: string, error?: any, context?: Record<string, any>) { 155 155 - const key = `${service}:${message}` 156 156 - 157 157 - const existing = errors.get(key) 158 158 - if (existing) { 159 159 - existing.count++ 160 160 - existing.lastSeen = new Date() 161 161 - if (context) { 162 162 - existing.context = { ...existing.context, ...context } 163 163 - } 164 164 - } else { 165 165 - const entry: ErrorEntry = { 166 166 - id: generateId('error', errorCounter++), 167 167 - timestamp: new Date(), 168 168 - message, 169 169 - service, 170 170 - context, 171 171 - count: 1, 172 172 - lastSeen: new Date() 173 173 - } 174 174 - 175 175 - if (error instanceof Error) { 176 176 - entry.stack = error.stack 177 177 - } 178 178 - 179 179 - errors.set(key, entry) 180 180 - 181 181 - // Rotate if needed 182 182 - if (errors.size > MAX_ERRORS) { 183 183 - const oldest = Array.from(errors.keys())[0] 184 184 - errors.delete(oldest) 185 185 - } 186 186 - } 187 187 - }, 188 188 - 189 189 - getErrors(filter?: { service?: string; limit?: number }) { 190 190 - let filtered = Array.from(errors.values()) 191 191 - 192 192 - if (filter?.service) { 193 193 - filtered = filtered.filter(err => err.service === filter.service) 194 194 - } 195 195 - 196 196 - // Sort by last seen (most recent first) 197 197 - filtered.sort((a, b) => b.lastSeen.getTime() - a.lastSeen.getTime()) 198 198 - 199 199 - const limit = filter?.limit || 100 200 200 - return filtered.slice(0, limit) 201 201 - }, 202 202 - 203 203 - clear() { 204 204 - errors.clear() 205 205 - } 206 206 - } 207 207 - 208 208 - // Metrics collector 209 209 - export const metricsCollector = { 210 210 - recordRequest(path: string, method: string, statusCode: number, duration: number, service: string) { 211 211 - const entry: MetricEntry = { 212 212 - timestamp: new Date(), 213 213 - path, 214 214 - method, 215 215 - statusCode, 216 216 - duration, 217 217 - service 218 218 - } 219 219 - 220 220 - metrics.unshift(entry) 221 221 - 222 222 - // Rotate if needed 223 223 - if (metrics.length > MAX_METRICS) { 224 224 - metrics.splice(MAX_METRICS) 225 225 - } 226 226 - }, 227 227 - 228 228 - getMetrics(filter?: { service?: string; timeWindow?: number }) { 229 229 - let filtered = [...metrics] 230 230 - 231 231 - if (filter?.service) { 232 232 - filtered = filtered.filter(m => m.service === filter.service) 233 233 - } 234 234 - 235 235 - if (filter?.timeWindow) { 236 236 - const cutoff = Date.now() - filter.timeWindow 237 237 - filtered = filtered.filter(m => m.timestamp.getTime() > cutoff) 238 238 - } 239 239 - 240 240 - return filtered 241 241 - }, 242 242 - 243 243 - getStats(service?: string, timeWindow: number = 3600000) { 244 244 - const filtered = this.getMetrics({ service, timeWindow }) 245 245 - 246 246 - if (filtered.length === 0) { 247 247 - return { 248 248 - totalRequests: 0, 249 249 - avgDuration: 0, 250 250 - p50Duration: 0, 251 251 - p95Duration: 0, 252 252 - p99Duration: 0, 253 253 - errorRate: 0, 254 254 - requestsPerMinute: 0 255 255 - } 256 256 - } 257 257 - 258 258 - const durations = filtered.map(m => m.duration).sort((a, b) => a - b) 259 259 - const totalDuration = durations.reduce((sum, d) => sum + d, 0) 260 260 - const errors = filtered.filter(m => m.statusCode >= 400).length 261 261 - 262 262 - const p50 = durations[Math.floor(durations.length * 0.5)] 263 263 - const p95 = durations[Math.floor(durations.length * 0.95)] 264 264 - const p99 = durations[Math.floor(durations.length * 0.99)] 265 265 - 266 266 - const timeWindowMinutes = timeWindow / 60000 267 267 - 268 268 - return { 269 269 - totalRequests: filtered.length, 270 270 - avgDuration: Math.round(totalDuration / filtered.length), 271 271 - p50Duration: Math.round(p50), 272 272 - p95Duration: Math.round(p95), 273 273 - p99Duration: Math.round(p99), 274 274 - errorRate: (errors / filtered.length) * 100, 275 275 - requestsPerMinute: Math.round(filtered.length / timeWindowMinutes) 276 276 - } 277 277 - }, 278 278 - 279 279 - clear() { 280 280 - metrics.length = 0 281 281 - } 282 282 - } 283 283 - 284 284 - // Elysia middleware for request timing 285 285 - export function observabilityMiddleware(service: string) { 286 286 - return { 287 287 - beforeHandle: ({ request }: any) => { 288 288 - // Store start time on request object 289 289 - (request as any).__startTime = Date.now() 290 290 - }, 291 291 - afterHandle: ({ request, set }: any) => { 292 292 - const duration = Date.now() - ((request as any).__startTime || Date.now()) 293 293 - const url = new URL(request.url) 294 294 - 295 295 - metricsCollector.recordRequest( 296 296 - url.pathname, 297 297 - request.method, 298 298 - set.status || 200, 299 299 - duration, 300 300 - service 301 301 - ) 302 302 - }, 303 303 - onError: ({ request, error, set }: any) => { 304 304 - const duration = Date.now() - ((request as any).__startTime || Date.now()) 305 305 - const url = new URL(request.url) 306 306 - 307 307 - metricsCollector.recordRequest( 308 308 - url.pathname, 309 309 - request.method, 310 310 - set.status || 500, 311 311 - duration, 312 312 - service 313 313 - ) 314 314 - 315 315 - // Don't log 404 errors 316 316 - const statusCode = set.status || 500 317 317 - if (statusCode !== 404) { 318 318 - logCollector.error( 319 319 - `Request failed: ${request.method} ${url.pathname}`, 320 320 - service, 321 321 - error, 322 322 - { statusCode } 323 323 - ) 324 324 - } 325 325 - } 326 326 - } 327 327 - } 328 328 - 329 329 - // Export singleton logger for easy access 330 330 - export const logger = { 331 331 - info: (message: string, context?: Record<string, any>) => 332 332 - logCollector.info(message, 'main-app', context), 333 333 - warn: (message: string, context?: Record<string, any>) => 334 334 - logCollector.warn(message, 'main-app', context), 335 335 - error: (message: string, error?: any, context?: Record<string, any>) => 336 336 - logCollector.error(message, 'main-app', error, context), 337 337 - debug: (message: string, context?: Record<string, any>) => 338 338 - logCollector.debug(message, 'main-app', context) 339 339 - }

+2 -2

src/lib/slingshot-handle-resolver.ts apps/main-app/src/lib/slingshot-handle-resolver.ts

··· 7 7 * to work around bugs in atproto-oauth-node when handles have redirects 8 8 * in their well-known configuration. 9 9 * 10 10 - * Uses: https://slingshot.microcosm.blue/xrpc/com.atproto.identity.resolveHandle 10 10 + * Uses: https://slingshot.wisp.place/xrpc/com.atproto.identity.resolveHandle 11 11 */ 12 12 export class SlingshotHandleResolver implements HandleResolver { 13 13 - private readonly endpoint = 'https://slingshot.microcosm.blue/xrpc/com.atproto.identity.resolveHandle'; 13 13 + private readonly endpoint = 'https://slingshot.wisp.place/xrpc/com.atproto.identity.resolveHandle'; 14 14 15 15 async resolve(handle: string, options?: ResolveHandleOptions): Promise<ResolvedHandle> { 16 16 try {

src/lib/sync-sites.ts apps/main-app/src/lib/sync-sites.ts

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

+3 -1

src/lib/upload-jobs.ts apps/main-app/src/lib/upload-jobs.ts

··· 1 1 - import { logger } from './observability'; 1 1 + import { createLogger } from '@wisp/observability'; 2 2 + 3 3 + const logger = createLogger('main-app'); 2 4 3 5 export type UploadJobStatus = 'pending' | 'processing' | 'uploading' | 'completed' | 'failed'; 4 6

src/lib/wisp-auth.ts apps/main-app/src/lib/wisp-auth.ts

-1005

src/lib/wisp-utils.test.ts

··· 1 1 - import { describe, test, expect } from 'bun:test' 2 2 - import { 3 3 - shouldCompressFile, 4 4 - compressFile, 5 5 - processUploadedFiles, 6 6 - createManifest, 7 7 - updateFileBlobs, 8 8 - computeCID, 9 9 - extractBlobMap, 10 10 - type UploadedFile, 11 11 - type FileUploadResult, 12 12 - } from './wisp-utils' 13 13 - import type { Directory } from '../lexicons/types/place/wisp/fs' 14 14 - import { gunzipSync } from 'zlib' 15 15 - import { BlobRef } from '@atproto/api' 16 16 - import { CID } from 'multiformats/cid' 17 17 - 18 18 - // Helper function to create a valid CID for testing 19 19 - // Using a real valid CID from actual AT Protocol usage 20 20 - const TEST_CID_STRING = 'bafkreid7ybejd5s2vv2j7d4aajjlmdgazguemcnuliiyfn6coxpwp2mi6y' 21 21 - 22 22 - function createMockBlobRef(mimeType: string, size: number): BlobRef { 23 23 - // Create a properly formatted CID 24 24 - const cid = CID.parse(TEST_CID_STRING) 25 25 - return new BlobRef(cid as any, mimeType, size) 26 26 - } 27 27 - 28 28 - describe('shouldCompressFile', () => { 29 29 - test('should compress HTML files', () => { 30 30 - expect(shouldCompressFile('text/html')).toBe(true) 31 31 - expect(shouldCompressFile('text/html; charset=utf-8')).toBe(true) 32 32 - }) 33 33 - 34 34 - test('should compress CSS files', () => { 35 35 - expect(shouldCompressFile('text/css')).toBe(true) 36 36 - }) 37 37 - 38 38 - test('should compress JavaScript files', () => { 39 39 - expect(shouldCompressFile('text/javascript')).toBe(true) 40 40 - expect(shouldCompressFile('application/javascript')).toBe(true) 41 41 - expect(shouldCompressFile('application/x-javascript')).toBe(true) 42 42 - }) 43 43 - 44 44 - test('should compress JSON files', () => { 45 45 - expect(shouldCompressFile('application/json')).toBe(true) 46 46 - }) 47 47 - 48 48 - test('should compress SVG files', () => { 49 49 - expect(shouldCompressFile('image/svg+xml')).toBe(true) 50 50 - }) 51 51 - 52 52 - test('should compress XML files', () => { 53 53 - expect(shouldCompressFile('text/xml')).toBe(true) 54 54 - expect(shouldCompressFile('application/xml')).toBe(true) 55 55 - }) 56 56 - 57 57 - test('should compress plain text files', () => { 58 58 - expect(shouldCompressFile('text/plain')).toBe(true) 59 59 - }) 60 60 - 61 61 - test('should NOT compress _redirects file', () => { 62 62 - expect(shouldCompressFile('text/plain', '_redirects')).toBe(false) 63 63 - expect(shouldCompressFile('text/plain', 'folder/_redirects')).toBe(false) 64 64 - expect(shouldCompressFile('application/octet-stream', '_redirects')).toBe(false) 65 65 - }) 66 66 - 67 67 - test('should NOT compress images', () => { 68 68 - expect(shouldCompressFile('image/png')).toBe(false) 69 69 - expect(shouldCompressFile('image/jpeg')).toBe(false) 70 70 - expect(shouldCompressFile('image/jpg')).toBe(false) 71 71 - expect(shouldCompressFile('image/gif')).toBe(false) 72 72 - expect(shouldCompressFile('image/webp')).toBe(false) 73 73 - }) 74 74 - 75 75 - test('should NOT compress videos', () => { 76 76 - expect(shouldCompressFile('video/mp4')).toBe(false) 77 77 - expect(shouldCompressFile('video/webm')).toBe(false) 78 78 - }) 79 79 - 80 80 - test('should NOT compress already compressed formats', () => { 81 81 - expect(shouldCompressFile('application/zip')).toBe(false) 82 82 - expect(shouldCompressFile('application/gzip')).toBe(false) 83 83 - expect(shouldCompressFile('application/pdf')).toBe(false) 84 84 - }) 85 85 - 86 86 - test('should NOT compress fonts', () => { 87 87 - expect(shouldCompressFile('font/woff')).toBe(false) 88 88 - expect(shouldCompressFile('font/woff2')).toBe(false) 89 89 - expect(shouldCompressFile('font/ttf')).toBe(false) 90 90 - }) 91 91 - }) 92 92 - 93 93 - describe('compressFile', () => { 94 94 - test('should compress text content', () => { 95 95 - const content = Buffer.from('Hello, World! '.repeat(100)) 96 96 - const compressed = compressFile(content) 97 97 - 98 98 - expect(compressed.length).toBeLessThan(content.length) 99 99 - 100 100 - // Verify we can decompress it back 101 101 - const decompressed = gunzipSync(compressed) 102 102 - expect(decompressed.toString()).toBe(content.toString()) 103 103 - }) 104 104 - 105 105 - test('should compress HTML content significantly', () => { 106 106 - const html = ` 107 107 - <!DOCTYPE html> 108 108 - <html> 109 109 - <head><title>Test</title></head> 110 110 - <body> 111 111 - ${'<p>Hello World!</p>\n'.repeat(50)} 112 112 - </body> 113 113 - </html> 114 114 - ` 115 115 - const content = Buffer.from(html) 116 116 - const compressed = compressFile(content) 117 117 - 118 118 - expect(compressed.length).toBeLessThan(content.length) 119 119 - 120 120 - // Verify decompression 121 121 - const decompressed = gunzipSync(compressed) 122 122 - expect(decompressed.toString()).toBe(html) 123 123 - }) 124 124 - 125 125 - test('should handle empty content', () => { 126 126 - const content = Buffer.from('') 127 127 - const compressed = compressFile(content) 128 128 - const decompressed = gunzipSync(compressed) 129 129 - expect(decompressed.toString()).toBe('') 130 130 - }) 131 131 - 132 132 - test('should produce deterministic compression', () => { 133 133 - const content = Buffer.from('Test content') 134 134 - const compressed1 = compressFile(content) 135 135 - const compressed2 = compressFile(content) 136 136 - 137 137 - expect(compressed1.toString('base64')).toBe(compressed2.toString('base64')) 138 138 - }) 139 139 - }) 140 140 - 141 141 - describe('processUploadedFiles', () => { 142 142 - test('should process single root-level file', () => { 143 143 - const files: UploadedFile[] = [ 144 144 - { 145 145 - name: 'index.html', 146 146 - content: Buffer.from('<html></html>'), 147 147 - mimeType: 'text/html', 148 148 - size: 13, 149 149 - }, 150 150 - ] 151 151 - 152 152 - const result = processUploadedFiles(files) 153 153 - 154 154 - expect(result.fileCount).toBe(1) 155 155 - expect(result.directory.type).toBe('directory') 156 156 - expect(result.directory.entries).toHaveLength(1) 157 157 - expect(result.directory.entries[0].name).toBe('index.html') 158 158 - 159 159 - const node = result.directory.entries[0].node 160 160 - expect('blob' in node).toBe(true) // It's a file node 161 161 - }) 162 162 - 163 163 - test('should process multiple root-level files', () => { 164 164 - const files: UploadedFile[] = [ 165 165 - { 166 166 - name: 'index.html', 167 167 - content: Buffer.from('<html></html>'), 168 168 - mimeType: 'text/html', 169 169 - size: 13, 170 170 - }, 171 171 - { 172 172 - name: 'styles.css', 173 173 - content: Buffer.from('body {}'), 174 174 - mimeType: 'text/css', 175 175 - size: 7, 176 176 - }, 177 177 - { 178 178 - name: 'script.js', 179 179 - content: Buffer.from('console.log("hi")'), 180 180 - mimeType: 'application/javascript', 181 181 - size: 17, 182 182 - }, 183 183 - ] 184 184 - 185 185 - const result = processUploadedFiles(files) 186 186 - 187 187 - expect(result.fileCount).toBe(3) 188 188 - expect(result.directory.entries).toHaveLength(3) 189 189 - 190 190 - const names = result.directory.entries.map(e => e.name) 191 191 - expect(names).toContain('index.html') 192 192 - expect(names).toContain('styles.css') 193 193 - expect(names).toContain('script.js') 194 194 - }) 195 195 - 196 196 - test('should process files with subdirectories', () => { 197 197 - const files: UploadedFile[] = [ 198 198 - { 199 199 - name: 'dist/index.html', 200 200 - content: Buffer.from('<html></html>'), 201 201 - mimeType: 'text/html', 202 202 - size: 13, 203 203 - }, 204 204 - { 205 205 - name: 'dist/css/styles.css', 206 206 - content: Buffer.from('body {}'), 207 207 - mimeType: 'text/css', 208 208 - size: 7, 209 209 - }, 210 210 - { 211 211 - name: 'dist/js/app.js', 212 212 - content: Buffer.from('console.log()'), 213 213 - mimeType: 'application/javascript', 214 214 - size: 13, 215 215 - }, 216 216 - ] 217 217 - 218 218 - const result = processUploadedFiles(files) 219 219 - 220 220 - expect(result.fileCount).toBe(3) 221 221 - expect(result.directory.entries).toHaveLength(3) // index.html, css/, js/ 222 222 - 223 223 - // Check root has index.html (after base folder removal) 224 224 - const indexEntry = result.directory.entries.find(e => e.name === 'index.html') 225 225 - expect(indexEntry).toBeDefined() 226 226 - 227 227 - // Check css directory exists 228 228 - const cssDir = result.directory.entries.find(e => e.name === 'css') 229 229 - expect(cssDir).toBeDefined() 230 230 - expect('entries' in cssDir!.node).toBe(true) 231 231 - 232 232 - if ('entries' in cssDir!.node) { 233 233 - expect(cssDir!.node.entries).toHaveLength(1) 234 234 - expect(cssDir!.node.entries[0].name).toBe('styles.css') 235 235 - } 236 236 - 237 237 - // Check js directory exists 238 238 - const jsDir = result.directory.entries.find(e => e.name === 'js') 239 239 - expect(jsDir).toBeDefined() 240 240 - expect('entries' in jsDir!.node).toBe(true) 241 241 - }) 242 242 - 243 243 - test('should handle deeply nested subdirectories', () => { 244 244 - const files: UploadedFile[] = [ 245 245 - { 246 246 - name: 'dist/deep/nested/folder/file.txt', 247 247 - content: Buffer.from('content'), 248 248 - mimeType: 'text/plain', 249 249 - size: 7, 250 250 - }, 251 251 - ] 252 252 - 253 253 - const result = processUploadedFiles(files) 254 254 - 255 255 - expect(result.fileCount).toBe(1) 256 256 - 257 257 - // Navigate through the directory structure (base folder removed) 258 258 - const deepDir = result.directory.entries.find(e => e.name === 'deep') 259 259 - expect(deepDir).toBeDefined() 260 260 - expect('entries' in deepDir!.node).toBe(true) 261 261 - 262 262 - if ('entries' in deepDir!.node) { 263 263 - const nestedDir = deepDir!.node.entries.find(e => e.name === 'nested') 264 264 - expect(nestedDir).toBeDefined() 265 265 - 266 266 - if (nestedDir && 'entries' in nestedDir.node) { 267 267 - const folderDir = nestedDir.node.entries.find(e => e.name === 'folder') 268 268 - expect(folderDir).toBeDefined() 269 269 - 270 270 - if (folderDir && 'entries' in folderDir.node) { 271 271 - expect(folderDir.node.entries).toHaveLength(1) 272 272 - expect(folderDir.node.entries[0].name).toBe('file.txt') 273 273 - } 274 274 - } 275 275 - } 276 276 - }) 277 277 - 278 278 - test('should remove base folder name from paths', () => { 279 279 - const files: UploadedFile[] = [ 280 280 - { 281 281 - name: 'dist/index.html', 282 282 - content: Buffer.from('<html></html>'), 283 283 - mimeType: 'text/html', 284 284 - size: 13, 285 285 - }, 286 286 - { 287 287 - name: 'dist/css/styles.css', 288 288 - content: Buffer.from('body {}'), 289 289 - mimeType: 'text/css', 290 290 - size: 7, 291 291 - }, 292 292 - ] 293 293 - 294 294 - const result = processUploadedFiles(files) 295 295 - 296 296 - // After removing 'dist/', we should have index.html and css/ at root 297 297 - expect(result.directory.entries.find(e => e.name === 'index.html')).toBeDefined() 298 298 - expect(result.directory.entries.find(e => e.name === 'css')).toBeDefined() 299 299 - expect(result.directory.entries.find(e => e.name === 'dist')).toBeUndefined() 300 300 - }) 301 301 - 302 302 - test('should handle empty file list', () => { 303 303 - const files: UploadedFile[] = [] 304 304 - const result = processUploadedFiles(files) 305 305 - 306 306 - expect(result.fileCount).toBe(0) 307 307 - expect(result.directory.entries).toHaveLength(0) 308 308 - }) 309 309 - 310 310 - test('should handle multiple files in same subdirectory', () => { 311 311 - const files: UploadedFile[] = [ 312 312 - { 313 313 - name: 'dist/assets/image1.png', 314 314 - content: Buffer.from('png1'), 315 315 - mimeType: 'image/png', 316 316 - size: 4, 317 317 - }, 318 318 - { 319 319 - name: 'dist/assets/image2.png', 320 320 - content: Buffer.from('png2'), 321 321 - mimeType: 'image/png', 322 322 - size: 4, 323 323 - }, 324 324 - ] 325 325 - 326 326 - const result = processUploadedFiles(files) 327 327 - 328 328 - expect(result.fileCount).toBe(2) 329 329 - 330 330 - const assetsDir = result.directory.entries.find(e => e.name === 'assets') 331 331 - expect(assetsDir).toBeDefined() 332 332 - 333 333 - if ('entries' in assetsDir!.node) { 334 334 - expect(assetsDir!.node.entries).toHaveLength(2) 335 335 - const names = assetsDir!.node.entries.map(e => e.name) 336 336 - expect(names).toContain('image1.png') 337 337 - expect(names).toContain('image2.png') 338 338 - } 339 339 - }) 340 340 - }) 341 341 - 342 342 - describe('createManifest', () => { 343 343 - test('should create valid manifest', () => { 344 344 - const root: Directory = { 345 345 - $type: 'place.wisp.fs#directory', 346 346 - type: 'directory', 347 347 - entries: [], 348 348 - } 349 349 - 350 350 - const manifest = createManifest('example.com', root, 0) 351 351 - 352 352 - expect(manifest.$type).toBe('place.wisp.fs') 353 353 - expect(manifest.site).toBe('example.com') 354 354 - expect(manifest.root).toBe(root) 355 355 - expect(manifest.fileCount).toBe(0) 356 356 - expect(manifest.createdAt).toBeDefined() 357 357 - 358 358 - // Verify it's a valid ISO date string 359 359 - const date = new Date(manifest.createdAt) 360 360 - expect(date.toISOString()).toBe(manifest.createdAt) 361 361 - }) 362 362 - 363 363 - test('should create manifest with file count', () => { 364 364 - const root: Directory = { 365 365 - $type: 'place.wisp.fs#directory', 366 366 - type: 'directory', 367 367 - entries: [], 368 368 - } 369 369 - 370 370 - const manifest = createManifest('test-site', root, 42) 371 371 - 372 372 - expect(manifest.fileCount).toBe(42) 373 373 - expect(manifest.site).toBe('test-site') 374 374 - }) 375 375 - 376 376 - test('should create manifest with populated directory', () => { 377 377 - const mockBlob = createMockBlobRef('text/html', 100) 378 378 - 379 379 - const root: Directory = { 380 380 - $type: 'place.wisp.fs#directory', 381 381 - type: 'directory', 382 382 - entries: [ 383 383 - { 384 384 - name: 'index.html', 385 385 - node: { 386 386 - $type: 'place.wisp.fs#file', 387 387 - type: 'file', 388 388 - blob: mockBlob, 389 389 - }, 390 390 - }, 391 391 - ], 392 392 - } 393 393 - 394 394 - const manifest = createManifest('populated-site', root, 1) 395 395 - 396 396 - expect(manifest).toBeDefined() 397 397 - expect(manifest.site).toBe('populated-site') 398 398 - expect(manifest.root.entries).toHaveLength(1) 399 399 - }) 400 400 - }) 401 401 - 402 402 - describe('updateFileBlobs', () => { 403 403 - test('should update single file blob at root', () => { 404 404 - const directory: Directory = { 405 405 - $type: 'place.wisp.fs#directory', 406 406 - type: 'directory', 407 407 - entries: [ 408 408 - { 409 409 - name: 'index.html', 410 410 - node: { 411 411 - $type: 'place.wisp.fs#file', 412 412 - type: 'file', 413 413 - blob: undefined as any, 414 414 - }, 415 415 - }, 416 416 - ], 417 417 - } 418 418 - 419 419 - const mockBlob = createMockBlobRef('text/html', 100) 420 420 - const uploadResults: FileUploadResult[] = [ 421 421 - { 422 422 - hash: TEST_CID_STRING, 423 423 - blobRef: mockBlob, 424 424 - mimeType: 'text/html', 425 425 - }, 426 426 - ] 427 427 - 428 428 - const filePaths = ['index.html'] 429 429 - 430 430 - const updated = updateFileBlobs(directory, uploadResults, filePaths) 431 431 - 432 432 - expect(updated.entries).toHaveLength(1) 433 433 - const fileNode = updated.entries[0].node 434 434 - 435 435 - if ('blob' in fileNode) { 436 436 - expect(fileNode.blob).toBeDefined() 437 437 - expect(fileNode.blob.mimeType).toBe('text/html') 438 438 - expect(fileNode.blob.size).toBe(100) 439 439 - } else { 440 440 - throw new Error('Expected file node') 441 441 - } 442 442 - }) 443 443 - 444 444 - test('should update files in nested directories', () => { 445 445 - const directory: Directory = { 446 446 - $type: 'place.wisp.fs#directory', 447 447 - type: 'directory', 448 448 - entries: [ 449 449 - { 450 450 - name: 'css', 451 451 - node: { 452 452 - $type: 'place.wisp.fs#directory', 453 453 - type: 'directory', 454 454 - entries: [ 455 455 - { 456 456 - name: 'styles.css', 457 457 - node: { 458 458 - $type: 'place.wisp.fs#file', 459 459 - type: 'file', 460 460 - blob: undefined as any, 461 461 - }, 462 462 - }, 463 463 - ], 464 464 - }, 465 465 - }, 466 466 - ], 467 467 - } 468 468 - 469 469 - const mockBlob = createMockBlobRef('text/css', 50) 470 470 - const uploadResults: FileUploadResult[] = [ 471 471 - { 472 472 - hash: TEST_CID_STRING, 473 473 - blobRef: mockBlob, 474 474 - mimeType: 'text/css', 475 475 - encoding: 'gzip', 476 476 - }, 477 477 - ] 478 478 - 479 479 - const filePaths = ['css/styles.css'] 480 480 - 481 481 - const updated = updateFileBlobs(directory, uploadResults, filePaths) 482 482 - 483 483 - const cssDir = updated.entries[0] 484 484 - expect(cssDir.name).toBe('css') 485 485 - 486 486 - if ('entries' in cssDir.node) { 487 487 - const cssFile = cssDir.node.entries[0] 488 488 - expect(cssFile.name).toBe('styles.css') 489 489 - 490 490 - if ('blob' in cssFile.node) { 491 491 - expect(cssFile.node.blob.mimeType).toBe('text/css') 492 492 - if ('encoding' in cssFile.node) { 493 493 - expect(cssFile.node.encoding).toBe('gzip') 494 494 - } 495 495 - } else { 496 496 - throw new Error('Expected file node') 497 497 - } 498 498 - } else { 499 499 - throw new Error('Expected directory node') 500 500 - } 501 501 - }) 502 502 - 503 503 - test('should handle normalized paths with base folder removed', () => { 504 504 - const directory: Directory = { 505 505 - $type: 'place.wisp.fs#directory', 506 506 - type: 'directory', 507 507 - entries: [ 508 508 - { 509 509 - name: 'index.html', 510 510 - node: { 511 511 - $type: 'place.wisp.fs#file', 512 512 - type: 'file', 513 513 - blob: undefined as any, 514 514 - }, 515 515 - }, 516 516 - ], 517 517 - } 518 518 - 519 519 - const mockBlob = createMockBlobRef('text/html', 100) 520 520 - const uploadResults: FileUploadResult[] = [ 521 521 - { 522 522 - hash: TEST_CID_STRING, 523 523 - blobRef: mockBlob, 524 524 - }, 525 525 - ] 526 526 - 527 527 - // Path includes base folder that should be normalized 528 528 - const filePaths = ['dist/index.html'] 529 529 - 530 530 - const updated = updateFileBlobs(directory, uploadResults, filePaths) 531 531 - 532 532 - const fileNode = updated.entries[0].node 533 533 - if ('blob' in fileNode) { 534 534 - expect(fileNode.blob).toBeDefined() 535 535 - } else { 536 536 - throw new Error('Expected file node') 537 537 - } 538 538 - }) 539 539 - 540 540 - test('should preserve file metadata (encoding, mimeType, base64)', () => { 541 541 - const directory: Directory = { 542 542 - $type: 'place.wisp.fs#directory', 543 543 - type: 'directory', 544 544 - entries: [ 545 545 - { 546 546 - name: 'data.json', 547 547 - node: { 548 548 - $type: 'place.wisp.fs#file', 549 549 - type: 'file', 550 550 - blob: undefined as any, 551 551 - }, 552 552 - }, 553 553 - ], 554 554 - } 555 555 - 556 556 - const mockBlob = createMockBlobRef('application/json', 200) 557 557 - const uploadResults: FileUploadResult[] = [ 558 558 - { 559 559 - hash: TEST_CID_STRING, 560 560 - blobRef: mockBlob, 561 561 - mimeType: 'application/json', 562 562 - encoding: 'gzip', 563 563 - base64: true, 564 564 - }, 565 565 - ] 566 566 - 567 567 - const filePaths = ['data.json'] 568 568 - 569 569 - const updated = updateFileBlobs(directory, uploadResults, filePaths) 570 570 - 571 571 - const fileNode = updated.entries[0].node 572 572 - if ('blob' in fileNode && 'mimeType' in fileNode && 'encoding' in fileNode && 'base64' in fileNode) { 573 573 - expect(fileNode.mimeType).toBe('application/json') 574 574 - expect(fileNode.encoding).toBe('gzip') 575 575 - expect(fileNode.base64).toBe(true) 576 576 - } else { 577 577 - throw new Error('Expected file node with metadata') 578 578 - } 579 579 - }) 580 580 - 581 581 - test('should handle multiple files at different directory levels', () => { 582 582 - const directory: Directory = { 583 583 - $type: 'place.wisp.fs#directory', 584 584 - type: 'directory', 585 585 - entries: [ 586 586 - { 587 587 - name: 'index.html', 588 588 - node: { 589 589 - $type: 'place.wisp.fs#file', 590 590 - type: 'file', 591 591 - blob: undefined as any, 592 592 - }, 593 593 - }, 594 594 - { 595 595 - name: 'assets', 596 596 - node: { 597 597 - $type: 'place.wisp.fs#directory', 598 598 - type: 'directory', 599 599 - entries: [ 600 600 - { 601 601 - name: 'logo.svg', 602 602 - node: { 603 603 - $type: 'place.wisp.fs#file', 604 604 - type: 'file', 605 605 - blob: undefined as any, 606 606 - }, 607 607 - }, 608 608 - ], 609 609 - }, 610 610 - }, 611 611 - ], 612 612 - } 613 613 - 614 614 - const htmlBlob = createMockBlobRef('text/html', 100) 615 615 - const svgBlob = createMockBlobRef('image/svg+xml', 500) 616 616 - 617 617 - const uploadResults: FileUploadResult[] = [ 618 618 - { 619 619 - hash: TEST_CID_STRING, 620 620 - blobRef: htmlBlob, 621 621 - }, 622 622 - { 623 623 - hash: TEST_CID_STRING, 624 624 - blobRef: svgBlob, 625 625 - }, 626 626 - ] 627 627 - 628 628 - const filePaths = ['index.html', 'assets/logo.svg'] 629 629 - 630 630 - const updated = updateFileBlobs(directory, uploadResults, filePaths) 631 631 - 632 632 - // Check root file 633 633 - const indexNode = updated.entries[0].node 634 634 - if ('blob' in indexNode) { 635 635 - expect(indexNode.blob.mimeType).toBe('text/html') 636 636 - } 637 637 - 638 638 - // Check nested file 639 639 - const assetsDir = updated.entries[1] 640 640 - if ('entries' in assetsDir.node) { 641 641 - const logoNode = assetsDir.node.entries[0].node 642 642 - if ('blob' in logoNode) { 643 643 - expect(logoNode.blob.mimeType).toBe('image/svg+xml') 644 644 - } 645 645 - } 646 646 - }) 647 647 - }) 648 648 - 649 649 - describe('computeCID', () => { 650 650 - test('should compute CID for gzipped+base64 encoded content', () => { 651 651 - // This simulates the actual flow: gzip -> base64 -> compute CID 652 652 - const originalContent = Buffer.from('Hello, World!') 653 653 - const gzipped = compressFile(originalContent) 654 654 - const base64Content = Buffer.from(gzipped.toString('base64'), 'binary') 655 655 - 656 656 - const cid = computeCID(base64Content) 657 657 - 658 658 - // CID should be a valid CIDv1 string starting with 'bafkrei' 659 659 - expect(cid).toMatch(/^bafkrei[a-z0-9]+$/) 660 660 - expect(cid.length).toBeGreaterThan(10) 661 661 - }) 662 662 - 663 663 - test('should compute deterministic CIDs for identical content', () => { 664 664 - const content = Buffer.from('Test content for CID calculation') 665 665 - const gzipped = compressFile(content) 666 666 - const base64Content = Buffer.from(gzipped.toString('base64'), 'binary') 667 667 - 668 668 - const cid1 = computeCID(base64Content) 669 669 - const cid2 = computeCID(base64Content) 670 670 - 671 671 - expect(cid1).toBe(cid2) 672 672 - }) 673 673 - 674 674 - test('should compute different CIDs for different content', () => { 675 675 - const content1 = Buffer.from('Content A') 676 676 - const content2 = Buffer.from('Content B') 677 677 - 678 678 - const gzipped1 = compressFile(content1) 679 679 - const gzipped2 = compressFile(content2) 680 680 - 681 681 - const base64Content1 = Buffer.from(gzipped1.toString('base64'), 'binary') 682 682 - const base64Content2 = Buffer.from(gzipped2.toString('base64'), 'binary') 683 683 - 684 684 - const cid1 = computeCID(base64Content1) 685 685 - const cid2 = computeCID(base64Content2) 686 686 - 687 687 - expect(cid1).not.toBe(cid2) 688 688 - }) 689 689 - 690 690 - test('should handle empty content', () => { 691 691 - const emptyContent = Buffer.from('') 692 692 - const gzipped = compressFile(emptyContent) 693 693 - const base64Content = Buffer.from(gzipped.toString('base64'), 'binary') 694 694 - 695 695 - const cid = computeCID(base64Content) 696 696 - 697 697 - expect(cid).toMatch(/^bafkrei[a-z0-9]+$/) 698 698 - }) 699 699 - 700 700 - test('should compute same CID as PDS for base64-encoded content', () => { 701 701 - // Test that binary encoding produces correct bytes for CID calculation 702 702 - const testContent = Buffer.from('<!DOCTYPE html><html><body>Hello</body></html>') 703 703 - const gzipped = compressFile(testContent) 704 704 - const base64Content = Buffer.from(gzipped.toString('base64'), 'binary') 705 705 - 706 706 - // Compute CID twice to ensure consistency 707 707 - const cid1 = computeCID(base64Content) 708 708 - const cid2 = computeCID(base64Content) 709 709 - 710 710 - expect(cid1).toBe(cid2) 711 711 - expect(cid1).toMatch(/^bafkrei/) 712 712 - }) 713 713 - 714 714 - test('should use binary encoding for base64 strings', () => { 715 715 - // This test verifies we're using the correct encoding method 716 716 - // For base64 strings, 'binary' encoding ensures each character becomes exactly one byte 717 717 - const content = Buffer.from('Test content') 718 718 - const gzipped = compressFile(content) 719 719 - const base64String = gzipped.toString('base64') 720 720 - 721 721 - // Using binary encoding (what we use in production) 722 722 - const base64Content = Buffer.from(base64String, 'binary') 723 723 - 724 724 - // Verify the length matches the base64 string length 725 725 - expect(base64Content.length).toBe(base64String.length) 726 726 - 727 727 - // Verify CID is computed correctly 728 728 - const cid = computeCID(base64Content) 729 729 - expect(cid).toMatch(/^bafkrei/) 730 730 - }) 731 731 - }) 732 732 - 733 733 - describe('extractBlobMap', () => { 734 734 - test('should extract blob map from flat directory structure', () => { 735 735 - const mockCid = CID.parse(TEST_CID_STRING) 736 736 - const mockBlob = new BlobRef(mockCid as any, 'text/html', 100) 737 737 - 738 738 - const directory: Directory = { 739 739 - $type: 'place.wisp.fs#directory', 740 740 - type: 'directory', 741 741 - entries: [ 742 742 - { 743 743 - name: 'index.html', 744 744 - node: { 745 745 - $type: 'place.wisp.fs#file', 746 746 - type: 'file', 747 747 - blob: mockBlob, 748 748 - }, 749 749 - }, 750 750 - ], 751 751 - } 752 752 - 753 753 - const blobMap = extractBlobMap(directory) 754 754 - 755 755 - expect(blobMap.size).toBe(1) 756 756 - expect(blobMap.has('index.html')).toBe(true) 757 757 - 758 758 - const entry = blobMap.get('index.html') 759 759 - expect(entry?.cid).toBe(TEST_CID_STRING) 760 760 - expect(entry?.blobRef).toBe(mockBlob) 761 761 - }) 762 762 - 763 763 - test('should extract blob map from nested directory structure', () => { 764 764 - const mockCid1 = CID.parse(TEST_CID_STRING) 765 765 - const mockCid2 = CID.parse('bafkreiabaduc3573q6snt2xgxzpglwuaojkzflocncrh2vj5j3jykdpqhi') 766 766 - 767 767 - const mockBlob1 = new BlobRef(mockCid1 as any, 'text/html', 100) 768 768 - const mockBlob2 = new BlobRef(mockCid2 as any, 'text/css', 50) 769 769 - 770 770 - const directory: Directory = { 771 771 - $type: 'place.wisp.fs#directory', 772 772 - type: 'directory', 773 773 - entries: [ 774 774 - { 775 775 - name: 'index.html', 776 776 - node: { 777 777 - $type: 'place.wisp.fs#file', 778 778 - type: 'file', 779 779 - blob: mockBlob1, 780 780 - }, 781 781 - }, 782 782 - { 783 783 - name: 'assets', 784 784 - node: { 785 785 - $type: 'place.wisp.fs#directory', 786 786 - type: 'directory', 787 787 - entries: [ 788 788 - { 789 789 - name: 'styles.css', 790 790 - node: { 791 791 - $type: 'place.wisp.fs#file', 792 792 - type: 'file', 793 793 - blob: mockBlob2, 794 794 - }, 795 795 - }, 796 796 - ], 797 797 - }, 798 798 - }, 799 799 - ], 800 800 - } 801 801 - 802 802 - const blobMap = extractBlobMap(directory) 803 803 - 804 804 - expect(blobMap.size).toBe(2) 805 805 - expect(blobMap.has('index.html')).toBe(true) 806 806 - expect(blobMap.has('assets/styles.css')).toBe(true) 807 807 - 808 808 - expect(blobMap.get('index.html')?.cid).toBe(TEST_CID_STRING) 809 809 - expect(blobMap.get('assets/styles.css')?.cid).toBe('bafkreiabaduc3573q6snt2xgxzpglwuaojkzflocncrh2vj5j3jykdpqhi') 810 810 - }) 811 811 - 812 812 - test('should handle deeply nested directory structures', () => { 813 813 - const mockCid = CID.parse(TEST_CID_STRING) 814 814 - const mockBlob = new BlobRef(mockCid as any, 'text/javascript', 200) 815 815 - 816 816 - const directory: Directory = { 817 817 - $type: 'place.wisp.fs#directory', 818 818 - type: 'directory', 819 819 - entries: [ 820 820 - { 821 821 - name: 'src', 822 822 - node: { 823 823 - $type: 'place.wisp.fs#directory', 824 824 - type: 'directory', 825 825 - entries: [ 826 826 - { 827 827 - name: 'lib', 828 828 - node: { 829 829 - $type: 'place.wisp.fs#directory', 830 830 - type: 'directory', 831 831 - entries: [ 832 832 - { 833 833 - name: 'utils.js', 834 834 - node: { 835 835 - $type: 'place.wisp.fs#file', 836 836 - type: 'file', 837 837 - blob: mockBlob, 838 838 - }, 839 839 - }, 840 840 - ], 841 841 - }, 842 842 - }, 843 843 - ], 844 844 - }, 845 845 - }, 846 846 - ], 847 847 - } 848 848 - 849 849 - const blobMap = extractBlobMap(directory) 850 850 - 851 851 - expect(blobMap.size).toBe(1) 852 852 - expect(blobMap.has('src/lib/utils.js')).toBe(true) 853 853 - expect(blobMap.get('src/lib/utils.js')?.cid).toBe(TEST_CID_STRING) 854 854 - }) 855 855 - 856 856 - test('should handle empty directory', () => { 857 857 - const directory: Directory = { 858 858 - $type: 'place.wisp.fs#directory', 859 859 - type: 'directory', 860 860 - entries: [], 861 861 - } 862 862 - 863 863 - const blobMap = extractBlobMap(directory) 864 864 - 865 865 - expect(blobMap.size).toBe(0) 866 866 - }) 867 867 - 868 868 - test('should correctly extract CID from BlobRef instances (not plain objects)', () => { 869 869 - // This test verifies the fix: AT Protocol SDK returns BlobRef instances, 870 870 - // not plain objects with $type and $link properties 871 871 - const mockCid = CID.parse(TEST_CID_STRING) 872 872 - const mockBlob = new BlobRef(mockCid as any, 'application/octet-stream', 500) 873 873 - 874 874 - const directory: Directory = { 875 875 - $type: 'place.wisp.fs#directory', 876 876 - type: 'directory', 877 877 - entries: [ 878 878 - { 879 879 - name: 'test.bin', 880 880 - node: { 881 881 - $type: 'place.wisp.fs#file', 882 882 - type: 'file', 883 883 - blob: mockBlob, 884 884 - }, 885 885 - }, 886 886 - ], 887 887 - } 888 888 - 889 889 - const blobMap = extractBlobMap(directory) 890 890 - 891 891 - // The fix: we call .toString() on the CID instance instead of accessing $link 892 892 - expect(blobMap.get('test.bin')?.cid).toBe(TEST_CID_STRING) 893 893 - expect(blobMap.get('test.bin')?.blobRef.ref.toString()).toBe(TEST_CID_STRING) 894 894 - }) 895 895 - 896 896 - test('should handle multiple files in same directory', () => { 897 897 - const mockCid1 = CID.parse(TEST_CID_STRING) 898 898 - const mockCid2 = CID.parse('bafkreiabaduc3573q6snt2xgxzpglwuaojkzflocncrh2vj5j3jykdpqhi') 899 899 - const mockCid3 = CID.parse('bafkreieb3ixgchss44kw7xiavnkns47emdfsqbhcdfluo3p6n3o53fl3vq') 900 900 - 901 901 - const mockBlob1 = new BlobRef(mockCid1 as any, 'image/png', 1000) 902 902 - const mockBlob2 = new BlobRef(mockCid2 as any, 'image/png', 2000) 903 903 - const mockBlob3 = new BlobRef(mockCid3 as any, 'image/png', 3000) 904 904 - 905 905 - const directory: Directory = { 906 906 - $type: 'place.wisp.fs#directory', 907 907 - type: 'directory', 908 908 - entries: [ 909 909 - { 910 910 - name: 'images', 911 911 - node: { 912 912 - $type: 'place.wisp.fs#directory', 913 913 - type: 'directory', 914 914 - entries: [ 915 915 - { 916 916 - name: 'logo.png', 917 917 - node: { 918 918 - $type: 'place.wisp.fs#file', 919 919 - type: 'file', 920 920 - blob: mockBlob1, 921 921 - }, 922 922 - }, 923 923 - { 924 924 - name: 'banner.png', 925 925 - node: { 926 926 - $type: 'place.wisp.fs#file', 927 927 - type: 'file', 928 928 - blob: mockBlob2, 929 929 - }, 930 930 - }, 931 931 - { 932 932 - name: 'icon.png', 933 933 - node: { 934 934 - $type: 'place.wisp.fs#file', 935 935 - type: 'file', 936 936 - blob: mockBlob3, 937 937 - }, 938 938 - }, 939 939 - ], 940 940 - }, 941 941 - }, 942 942 - ], 943 943 - } 944 944 - 945 945 - const blobMap = extractBlobMap(directory) 946 946 - 947 947 - expect(blobMap.size).toBe(3) 948 948 - expect(blobMap.has('images/logo.png')).toBe(true) 949 949 - expect(blobMap.has('images/banner.png')).toBe(true) 950 950 - expect(blobMap.has('images/icon.png')).toBe(true) 951 951 - }) 952 952 - 953 953 - test('should handle mixed directory and file structure', () => { 954 954 - const mockCid1 = CID.parse(TEST_CID_STRING) 955 955 - const mockCid2 = CID.parse('bafkreiabaduc3573q6snt2xgxzpglwuaojkzflocncrh2vj5j3jykdpqhi') 956 956 - const mockCid3 = CID.parse('bafkreieb3ixgchss44kw7xiavnkns47emdfsqbhcdfluo3p6n3o53fl3vq') 957 957 - 958 958 - const directory: Directory = { 959 959 - $type: 'place.wisp.fs#directory', 960 960 - type: 'directory', 961 961 - entries: [ 962 962 - { 963 963 - name: 'index.html', 964 964 - node: { 965 965 - $type: 'place.wisp.fs#file', 966 966 - type: 'file', 967 967 - blob: new BlobRef(mockCid1 as any, 'text/html', 100), 968 968 - }, 969 969 - }, 970 970 - { 971 971 - name: 'assets', 972 972 - node: { 973 973 - $type: 'place.wisp.fs#directory', 974 974 - type: 'directory', 975 975 - entries: [ 976 976 - { 977 977 - name: 'styles.css', 978 978 - node: { 979 979 - $type: 'place.wisp.fs#file', 980 980 - type: 'file', 981 981 - blob: new BlobRef(mockCid2 as any, 'text/css', 50), 982 982 - }, 983 983 - }, 984 984 - ], 985 985 - }, 986 986 - }, 987 987 - { 988 988 - name: 'README.md', 989 989 - node: { 990 990 - $type: 'place.wisp.fs#file', 991 991 - type: 'file', 992 992 - blob: new BlobRef(mockCid3 as any, 'text/markdown', 200), 993 993 - }, 994 994 - }, 995 995 - ], 996 996 - } 997 997 - 998 998 - const blobMap = extractBlobMap(directory) 999 999 - 1000 1000 - expect(blobMap.size).toBe(3) 1001 1001 - expect(blobMap.has('index.html')).toBe(true) 1002 1002 - expect(blobMap.has('assets/styles.css')).toBe(true) 1003 1003 - expect(blobMap.has('README.md')).toBe(true) 1004 1004 - }) 1005 1005 - })

-470

src/lib/wisp-utils.ts

··· 1 1 - import type { BlobRef } from "@atproto/api"; 2 2 - import type { Record, Directory, File, Entry } from "../lexicons/types/place/wisp/fs"; 3 3 - import { validateRecord } from "../lexicons/types/place/wisp/fs"; 4 4 - import { gzipSync } from 'zlib'; 5 5 - import { CID } from 'multiformats/cid'; 6 6 - import { sha256 } from 'multiformats/hashes/sha2'; 7 7 - import * as raw from 'multiformats/codecs/raw'; 8 8 - import { createHash } from 'crypto'; 9 9 - import * as mf from 'multiformats'; 10 10 - 11 11 - export interface UploadedFile { 12 12 - name: string; 13 13 - content: Buffer; 14 14 - mimeType: string; 15 15 - size: number; 16 16 - compressed?: boolean; 17 17 - base64Encoded?: boolean; 18 18 - originalMimeType?: string; 19 19 - } 20 20 - 21 21 - export interface FileUploadResult { 22 22 - hash: string; 23 23 - blobRef: BlobRef; 24 24 - encoding?: 'gzip'; 25 25 - mimeType?: string; 26 26 - base64?: boolean; 27 27 - } 28 28 - 29 29 - export interface ProcessedDirectory { 30 30 - directory: Directory; 31 31 - fileCount: number; 32 32 - } 33 33 - 34 34 - /** 35 35 - * Determine if a file should be gzip compressed based on its MIME type and filename 36 36 - */ 37 37 - export function shouldCompressFile(mimeType: string, fileName?: string): boolean { 38 38 - // Never compress _redirects file - it needs to be plain text for the hosting service 39 39 - if (fileName && (fileName.endsWith('/_redirects') || fileName === '_redirects')) { 40 40 - return false; 41 41 - } 42 42 - 43 43 - // Compress text-based files and uncompressed audio formats 44 44 - const compressibleTypes = [ 45 45 - 'text/html', 46 46 - 'text/css', 47 47 - 'text/javascript', 48 48 - 'application/javascript', 49 49 - 'application/json', 50 50 - 'image/svg+xml', 51 51 - 'text/xml', 52 52 - 'application/xml', 53 53 - 'text/plain', 54 54 - 'application/x-javascript', 55 55 - // Uncompressed audio formats (WAV, AIFF, etc.) 56 56 - 'audio/wav', 57 57 - 'audio/wave', 58 58 - 'audio/x-wav', 59 59 - 'audio/aiff', 60 60 - 'audio/x-aiff' 61 61 - ]; 62 62 - 63 63 - // Check if mime type starts with any compressible type 64 64 - return compressibleTypes.some(type => mimeType.startsWith(type)); 65 65 - } 66 66 - 67 67 - /** 68 68 - * Compress a file using gzip with deterministic output 69 69 - */ 70 70 - export function compressFile(content: Buffer): Buffer { 71 71 - return gzipSync(content, { 72 72 - level: 9 73 73 - }); 74 74 - } 75 75 - 76 76 - /** 77 77 - * Process uploaded files into a directory structure 78 78 - */ 79 79 - export function processUploadedFiles(files: UploadedFile[]): ProcessedDirectory { 80 80 - const entries: Entry[] = []; 81 81 - let fileCount = 0; 82 82 - 83 83 - // Group files by directory 84 84 - const directoryMap = new Map<string, UploadedFile[]>(); 85 85 - 86 86 - for (const file of files) { 87 87 - // Skip undefined/null files (defensive) 88 88 - if (!file || !file.name) { 89 89 - console.error('Skipping undefined or invalid file in processUploadedFiles'); 90 90 - continue; 91 91 - } 92 92 - 93 93 - // Remove any base folder name from the path 94 94 - const normalizedPath = file.name.replace(/^[^\/]*\//, ''); 95 95 - 96 96 - // Skip files in .git directories 97 97 - if (normalizedPath.startsWith('.git/') || normalizedPath === '.git') { 98 98 - continue; 99 99 - } 100 100 - 101 101 - const parts = normalizedPath.split('/'); 102 102 - 103 103 - if (parts.length === 1) { 104 104 - // Root level file 105 105 - entries.push({ 106 106 - name: parts[0], 107 107 - node: { 108 108 - $type: 'place.wisp.fs#file' as const, 109 109 - type: 'file' as const, 110 110 - blob: undefined as any // Will be filled after upload 111 111 - } 112 112 - }); 113 113 - fileCount++; 114 114 - } else { 115 115 - // File in subdirectory 116 116 - const dirPath = parts.slice(0, -1).join('/'); 117 117 - if (!directoryMap.has(dirPath)) { 118 118 - directoryMap.set(dirPath, []); 119 119 - } 120 120 - directoryMap.get(dirPath)!.push({ 121 121 - ...file, 122 122 - name: normalizedPath 123 123 - }); 124 124 - } 125 125 - } 126 126 - 127 127 - // Process subdirectories 128 128 - for (const [dirPath, dirFiles] of directoryMap) { 129 129 - const dirEntries: Entry[] = []; 130 130 - 131 131 - for (const file of dirFiles) { 132 132 - const fileName = file.name.split('/').pop()!; 133 133 - dirEntries.push({ 134 134 - name: fileName, 135 135 - node: { 136 136 - $type: 'place.wisp.fs#file' as const, 137 137 - type: 'file' as const, 138 138 - blob: undefined as any // Will be filled after upload 139 139 - } 140 140 - }); 141 141 - fileCount++; 142 142 - } 143 143 - 144 144 - // Build nested directory structure 145 145 - const pathParts = dirPath.split('/'); 146 146 - let currentEntries = entries; 147 147 - 148 148 - for (let i = 0; i < pathParts.length; i++) { 149 149 - const part = pathParts[i]; 150 150 - const isLast = i === pathParts.length - 1; 151 151 - 152 152 - let existingEntry = currentEntries.find(e => e.name === part); 153 153 - 154 154 - if (!existingEntry) { 155 155 - const newDir = { 156 156 - $type: 'place.wisp.fs#directory' as const, 157 157 - type: 'directory' as const, 158 158 - entries: isLast ? dirEntries : [] 159 159 - }; 160 160 - 161 161 - existingEntry = { 162 162 - name: part, 163 163 - node: newDir 164 164 - }; 165 165 - currentEntries.push(existingEntry); 166 166 - } else if ('entries' in existingEntry.node && isLast) { 167 167 - (existingEntry.node as any).entries.push(...dirEntries); 168 168 - } 169 169 - 170 170 - if (existingEntry && 'entries' in existingEntry.node) { 171 171 - currentEntries = (existingEntry.node as any).entries; 172 172 - } 173 173 - } 174 174 - } 175 175 - 176 176 - const result = { 177 177 - directory: { 178 178 - $type: 'place.wisp.fs#directory' as const, 179 179 - type: 'directory' as const, 180 180 - entries 181 181 - }, 182 182 - fileCount 183 183 - }; 184 184 - 185 185 - return result; 186 186 - } 187 187 - 188 188 - /** 189 189 - * Create the manifest record for a site 190 190 - */ 191 191 - export function createManifest( 192 192 - siteName: string, 193 193 - root: Directory, 194 194 - fileCount: number 195 195 - ): Record { 196 196 - const manifest = { 197 197 - $type: 'place.wisp.fs' as const, 198 198 - site: siteName, 199 199 - root, 200 200 - fileCount, 201 201 - createdAt: new Date().toISOString() 202 202 - }; 203 203 - 204 204 - // Validate the manifest before returning 205 205 - const validationResult = validateRecord(manifest); 206 206 - if (!validationResult.success) { 207 207 - throw new Error(`Invalid manifest: ${validationResult.error?.message || 'Validation failed'}`); 208 208 - } 209 209 - 210 210 - return manifest; 211 211 - } 212 212 - 213 213 - /** 214 214 - * Update file blobs in directory structure after upload 215 215 - * Uses path-based matching to correctly match files in nested directories 216 216 - * Filters out files that were not successfully uploaded 217 217 - */ 218 218 - export function updateFileBlobs( 219 219 - directory: Directory, 220 220 - uploadResults: FileUploadResult[], 221 221 - filePaths: string[], 222 222 - currentPath: string = '', 223 223 - successfulPaths?: Set<string> 224 224 - ): Directory { 225 225 - const updatedEntries = directory.entries.map(entry => { 226 226 - if ('type' in entry.node && entry.node.type === 'file') { 227 227 - // Build the full path for this file 228 228 - const fullPath = currentPath ? `${currentPath}/${entry.name}` : entry.name; 229 229 - 230 230 - // If successfulPaths is provided, skip files that weren't successfully uploaded 231 231 - if (successfulPaths && !successfulPaths.has(fullPath)) { 232 232 - return null; // Filter out failed files 233 233 - } 234 234 - 235 235 - // Find exact match in filePaths (need to handle normalized paths) 236 236 - const fileIndex = filePaths.findIndex((path) => { 237 237 - // Normalize both paths by removing leading base folder 238 238 - const normalizedUploadPath = path.replace(/^[^\/]*\//, ''); 239 239 - const normalizedEntryPath = fullPath; 240 240 - return normalizedUploadPath === normalizedEntryPath || path === fullPath; 241 241 - }); 242 242 - 243 243 - if (fileIndex !== -1 && uploadResults[fileIndex]) { 244 244 - const result = uploadResults[fileIndex]; 245 245 - const blobRef = result.blobRef; 246 246 - 247 247 - return { 248 248 - ...entry, 249 249 - node: { 250 250 - $type: 'place.wisp.fs#file' as const, 251 251 - type: 'file' as const, 252 252 - blob: blobRef, 253 253 - ...(result.encoding && { encoding: result.encoding }), 254 254 - ...(result.mimeType && { mimeType: result.mimeType }), 255 255 - ...(result.base64 && { base64: result.base64 }) 256 256 - } 257 257 - }; 258 258 - } else { 259 259 - console.error(`Could not find blob for file: ${fullPath}`); 260 260 - return null; // Filter out files without blobs 261 261 - } 262 262 - } else if ('type' in entry.node && entry.node.type === 'directory') { 263 263 - const dirPath = currentPath ? `${currentPath}/${entry.name}` : entry.name; 264 264 - return { 265 265 - ...entry, 266 266 - node: updateFileBlobs(entry.node as Directory, uploadResults, filePaths, dirPath, successfulPaths) 267 267 - }; 268 268 - } 269 269 - return entry; 270 270 - }).filter(entry => entry !== null) as Entry[]; // Remove null entries (failed files) 271 271 - 272 272 - const result = { 273 273 - $type: 'place.wisp.fs#directory' as const, 274 274 - type: 'directory' as const, 275 275 - entries: updatedEntries 276 276 - }; 277 277 - 278 278 - return result; 279 279 - } 280 280 - 281 281 - /** 282 282 - * Compute CID (Content Identifier) for blob content 283 283 - * Uses the same algorithm as AT Protocol: CIDv1 with raw codec and SHA-256 284 284 - * Based on @atproto/common/src/ipld.ts sha256RawToCid implementation 285 285 - */ 286 286 - export function computeCID(content: Buffer): string { 287 287 - // Use node crypto to compute sha256 hash (same as AT Protocol) 288 288 - const hash = createHash('sha256').update(content).digest(); 289 289 - // Create digest object from hash bytes 290 290 - const digest = mf.digest.create(sha256.code, hash); 291 291 - // Create CIDv1 with raw codec 292 292 - const cid = CID.createV1(raw.code, digest); 293 293 - return cid.toString(); 294 294 - } 295 295 - 296 296 - /** 297 297 - * Extract blob information from a directory tree 298 298 - * Returns a map of file paths to their blob refs and CIDs 299 299 - */ 300 300 - export function extractBlobMap( 301 301 - directory: Directory, 302 302 - currentPath: string = '' 303 303 - ): Map<string, { blobRef: BlobRef; cid: string }> { 304 304 - const blobMap = new Map<string, { blobRef: BlobRef; cid: string }>(); 305 305 - 306 306 - for (const entry of directory.entries) { 307 307 - const fullPath = currentPath ? `${currentPath}/${entry.name}` : entry.name; 308 308 - 309 309 - if ('type' in entry.node && entry.node.type === 'file') { 310 310 - const fileNode = entry.node as File; 311 311 - // AT Protocol SDK returns BlobRef class instances, not plain objects 312 312 - // The ref is a CID instance that can be converted to string 313 313 - if (fileNode.blob && fileNode.blob.ref) { 314 314 - const cidString = fileNode.blob.ref.toString(); 315 315 - blobMap.set(fullPath, { 316 316 - blobRef: fileNode.blob, 317 317 - cid: cidString 318 318 - }); 319 319 - } 320 320 - } else if ('type' in entry.node && entry.node.type === 'directory') { 321 321 - const subMap = extractBlobMap(entry.node as Directory, fullPath); 322 322 - subMap.forEach((value, key) => blobMap.set(key, value)); 323 323 - } 324 324 - // Skip subfs nodes - they don't contain blobs in the main tree 325 325 - } 326 326 - 327 327 - return blobMap; 328 328 - } 329 329 - 330 330 - /** 331 331 - * Extract all subfs URIs from a directory tree with their mount paths 332 332 - */ 333 333 - export function extractSubfsUris( 334 334 - directory: Directory, 335 335 - currentPath: string = '' 336 336 - ): Array<{ uri: string; path: string }> { 337 337 - const uris: Array<{ uri: string; path: string }> = []; 338 338 - 339 339 - for (const entry of directory.entries) { 340 340 - const fullPath = currentPath ? `${currentPath}/${entry.name}` : entry.name; 341 341 - 342 342 - if ('type' in entry.node) { 343 343 - if (entry.node.type === 'subfs') { 344 344 - // Subfs node with subject URI 345 345 - const subfsNode = entry.node as any; 346 346 - if (subfsNode.subject) { 347 347 - uris.push({ uri: subfsNode.subject, path: fullPath }); 348 348 - } 349 349 - } else if (entry.node.type === 'directory') { 350 350 - // Recursively search subdirectories 351 351 - const subUris = extractSubfsUris(entry.node as Directory, fullPath); 352 352 - uris.push(...subUris); 353 353 - } 354 354 - } 355 355 - } 356 356 - 357 357 - return uris; 358 358 - } 359 359 - 360 360 - /** 361 361 - * Estimate the JSON size of a directory tree 362 362 - */ 363 363 - export function estimateDirectorySize(directory: Directory): number { 364 364 - return JSON.stringify(directory).length; 365 365 - } 366 366 - 367 367 - /** 368 368 - * Count files in a directory tree 369 369 - */ 370 370 - export function countFilesInDirectory(directory: Directory): number { 371 371 - let count = 0; 372 372 - for (const entry of directory.entries) { 373 373 - if ('type' in entry.node && entry.node.type === 'file') { 374 374 - count++; 375 375 - } else if ('type' in entry.node && entry.node.type === 'directory') { 376 376 - count += countFilesInDirectory(entry.node as Directory); 377 377 - } 378 378 - } 379 379 - return count; 380 380 - } 381 381 - 382 382 - /** 383 383 - * Find all directories in a tree with their paths and sizes 384 384 - */ 385 385 - export function findLargeDirectories(directory: Directory, currentPath: string = ''): Array<{ 386 386 - path: string; 387 387 - directory: Directory; 388 388 - size: number; 389 389 - fileCount: number; 390 390 - }> { 391 391 - const result: Array<{ path: string; directory: Directory; size: number; fileCount: number }> = []; 392 392 - 393 393 - for (const entry of directory.entries) { 394 394 - if ('type' in entry.node && entry.node.type === 'directory') { 395 395 - const dirPath = currentPath ? `${currentPath}/${entry.name}` : entry.name; 396 396 - const dir = entry.node as Directory; 397 397 - const size = estimateDirectorySize(dir); 398 398 - const fileCount = countFilesInDirectory(dir); 399 399 - 400 400 - result.push({ path: dirPath, directory: dir, size, fileCount }); 401 401 - 402 402 - // Recursively find subdirectories 403 403 - const subdirs = findLargeDirectories(dir, dirPath); 404 404 - result.push(...subdirs); 405 405 - } 406 406 - } 407 407 - 408 408 - return result; 409 409 - } 410 410 - 411 411 - /** 412 412 - * Replace a directory with a subfs node in the tree 413 413 - */ 414 414 - export function replaceDirectoryWithSubfs( 415 415 - directory: Directory, 416 416 - targetPath: string, 417 417 - subfsUri: string 418 418 - ): Directory { 419 419 - const pathParts = targetPath.split('/'); 420 420 - const targetName = pathParts[pathParts.length - 1]; 421 421 - const parentPath = pathParts.slice(0, -1).join('/'); 422 422 - 423 423 - // If this is a root-level directory 424 424 - if (pathParts.length === 1) { 425 425 - const newEntries = directory.entries.map(entry => { 426 426 - if (entry.name === targetName && 'type' in entry.node && entry.node.type === 'directory') { 427 427 - return { 428 428 - name: entry.name, 429 429 - node: { 430 430 - $type: 'place.wisp.fs#subfs' as const, 431 431 - type: 'subfs' as const, 432 432 - subject: subfsUri, 433 433 - flat: false // Preserve directory structure 434 434 - } 435 435 - }; 436 436 - } 437 437 - return entry; 438 438 - }); 439 439 - 440 440 - return { 441 441 - $type: 'place.wisp.fs#directory' as const, 442 442 - type: 'directory' as const, 443 443 - entries: newEntries 444 444 - }; 445 445 - } 446 446 - 447 447 - // Recursively navigate to parent directory 448 448 - const newEntries = directory.entries.map(entry => { 449 449 - if ('type' in entry.node && entry.node.type === 'directory') { 450 450 - const entryPath = entry.name; 451 451 - if (parentPath.startsWith(entryPath) || parentPath === entry.name) { 452 452 - const remainingPath = pathParts.slice(1).join('/'); 453 453 - return { 454 454 - name: entry.name, 455 455 - node: { 456 456 - ...replaceDirectoryWithSubfs(entry.node as Directory, remainingPath, subfsUri), 457 457 - $type: 'place.wisp.fs#directory' as const 458 458 - } 459 459 - }; 460 460 - } 461 461 - } 462 462 - return entry; 463 463 - }); 464 464 - 465 465 - return { 466 466 - $type: 'place.wisp.fs#directory' as const, 467 467 - type: 'directory' as const, 468 468 - entries: newEntries 469 469 - }; 470 470 - }

+1 -1

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

··· 1 1 // Admin API routes 2 2 import { Elysia, t } from 'elysia' 3 3 import { adminAuth, requireAdmin } from '../lib/admin-auth' 4 4 - import { logCollector, errorTracker, metricsCollector } from '../lib/observability' 4 4 + import { logCollector, errorTracker, metricsCollector } from '@wisp/observability' 5 5 import { db } from '../lib/db' 6 6 7 7 export const adminRoutes = (cookieSecret: string) =>

+3 -1

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

··· 3 3 import { getSitesByDid, getDomainByDid, getCookieSecret } from '../lib/db' 4 4 import { syncSitesFromPDS } from '../lib/sync-sites' 5 5 import { authenticateRequest } from '../lib/wisp-auth' 6 6 - import { logger } from '../lib/observability' 6 6 + import { createLogger } from '@wisp/observability' 7 7 + 8 8 + const logger = createLogger('main-app') 7 9 8 10 export const authRoutes = (client: NodeOAuthClient, cookieSecret: string) => new Elysia({ 9 11 cookie: {

+3 -1

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

··· 22 22 } from '../lib/db' 23 23 import { createHash } from 'crypto' 24 24 import { verifyCustomDomain } from '../lib/dns-verify' 25 25 - import { logger } from '../lib/logger' 25 25 + import { createLogger } from '@wisp/observability' 26 26 + 27 27 + const logger = createLogger('main-app') 26 28 27 29 export const domainRoutes = (client: NodeOAuthClient, cookieSecret: string) => 28 30 new Elysia({

+4 -2

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

··· 3 3 import { NodeOAuthClient } from '@atproto/oauth-client-node' 4 4 import { Agent } from '@atproto/api' 5 5 import { deleteSite } from '../lib/db' 6 6 - import { logger } from '../lib/logger' 7 7 - import { extractSubfsUris } from '../lib/wisp-utils' 6 6 + import { createLogger } from '@wisp/observability' 7 7 + import { extractSubfsUris } from '@wisp/atproto-utils' 8 8 + 9 9 + const logger = createLogger('main-app') 8 10 9 11 export const siteRoutes = (client: NodeOAuthClient, cookieSecret: string) => 10 12 new Elysia({

+4 -2

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

··· 4 4 import { Agent } from '@atproto/api' 5 5 import { getSitesByDid, getDomainByDid, getCustomDomainsByDid, getWispDomainInfo, getDomainsBySite, getAllWispDomains } from '../lib/db' 6 6 import { syncSitesFromPDS } from '../lib/sync-sites' 7 7 - import { logger } from '../lib/logger' 7 7 + import { createLogger } from '@wisp/observability' 8 8 + 9 9 + const logger = createLogger('main-app') 8 10 9 11 export const userRoutes = (client: NodeOAuthClient, cookieSecret: string) => 10 12 new Elysia({ ··· 96 98 }) 97 99 .post('/sync', async ({ auth }) => { 98 100 try { 99 99 - logger.debug('[User] Manual sync requested for', auth.did) 101 101 + logger.debug('[User] Manual sync requested for', { did: auth.did }) 100 102 const result = await syncSitesFromPDS(auth.did, auth.session) 101 103 102 104 return {

+14 -10

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

··· 7 7 type UploadedFile, 8 8 type FileUploadResult, 9 9 processUploadedFiles, 10 10 - createManifest, 11 10 updateFileBlobs, 11 11 + findLargeDirectories, 12 12 + replaceDirectoryWithSubfs, 13 13 + estimateDirectorySize 14 14 + } from '@wisp/fs-utils' 15 15 + import { 12 16 shouldCompressFile, 13 17 compressFile, 14 18 computeCID, 15 19 extractBlobMap, 16 16 - extractSubfsUris, 17 17 - findLargeDirectories, 18 18 - replaceDirectoryWithSubfs, 19 19 - estimateDirectorySize 20 20 - } from '../lib/wisp-utils' 20 20 + extractSubfsUris 21 21 + } from '@wisp/atproto-utils' 22 22 + import { createManifest } from '@wisp/fs-utils' 21 23 import { upsertSite } from '../lib/db' 22 22 - import { logger } from '../lib/observability' 23 23 - import { validateRecord } from '../lexicons/types/place/wisp/fs' 24 24 - import { validateRecord as validateSubfsRecord } from '../lexicons/types/place/wisp/subfs' 25 25 - import { MAX_SITE_SIZE, MAX_FILE_SIZE, MAX_FILE_COUNT } from '../lib/constants' 24 24 + import { createLogger } from '@wisp/observability' 25 25 + import { validateRecord, type Directory } from '@wisp/lexicons/types/place/wisp/fs' 26 26 + import { validateRecord as validateSubfsRecord } from '@wisp/lexicons/types/place/wisp/subfs' 27 27 + import { MAX_SITE_SIZE, MAX_FILE_SIZE, MAX_FILE_COUNT } from '@wisp/constants' 26 28 import { 27 29 createUploadJob, 28 30 getUploadJob, ··· 31 33 failUploadJob, 32 34 addJobListener 33 35 } from '../lib/upload-jobs' 36 36 + 37 37 + const logger = createLogger('main-app') 34 38 35 39 function isValidSiteName(siteName: string): boolean { 36 40 if (!siteName || typeof siteName !== 'string') return false;

-40

testDeploy/index.html

··· 1 1 - <!DOCTYPE html> 2 2 - <html lang="en"> 3 3 - <head> 4 4 - <meta charset="UTF-8"> 5 5 - <meta name="viewport" content="width=device-width, initial-scale=1.0"> 6 6 - <title>Wisp.place Test Site</title> 7 7 - <style> 8 8 - body { 9 9 - font-family: system-ui, -apple-system, sans-serif; 10 10 - max-width: 800px; 11 11 - margin: 4rem auto; 12 12 - padding: 0 2rem; 13 13 - line-height: 1.6; 14 14 - } 15 15 - h1 { 16 16 - color: #333; 17 17 - } 18 18 - .info { 19 19 - background: #f0f0f0; 20 20 - padding: 1rem; 21 21 - border-radius: 8px; 22 22 - margin: 2rem 0; 23 23 - } 24 24 - </style> 25 25 - </head> 26 26 - <body> 27 27 - <h1>Hello from Wisp.place!</h1> 28 28 - <p>This is a test deployment using the wisp-cli and Tangled Spindles CI/CD.</p> 29 29 - 30 30 - <div class="info"> 31 31 - <h2>About this deployment</h2> 32 32 - <p>This site was deployed to the AT Protocol using:</p> 33 33 - <ul> 34 34 - <li>Wisp.place CLI (Rust)</li> 35 35 - <li>Tangled Spindles CI/CD</li> 36 36 - <li>AT Protocol for decentralized hosting</li> 37 37 - </ul> 38 38 - </div> 39 39 - </body> 40 40 - </html>

+1 -1

tsconfig.json

··· 27 27 /* Modules */ 28 28 "module": "ES2022" /* Specify what module code is generated. */, 29 29 // "rootDir": "./", /* Specify the root folder within your source files. */ 30 30 - "moduleResolution": "node" /* Specify how TypeScript looks up a file from a given module specifier. */, 30 30 + "moduleResolution": "bundler" /* Specify how TypeScript looks up a file from a given module specifier. */, 31 31 // "baseUrl": "./", /* Specify the base directory to resolve non-relative module names. */ 32 32 // "paths": {}, /* Specify a set of entries that re-map imports to additional lookup locations. */ 33 33 // "rootDirs": [], /* Allow multiple folders to be treated as one when resolving modules. */