-2

api.md

··· 37 37 * 38 38 * Routes: 39 39 * GET /wisp/sites - List all sites for authenticated user 40 40 - * GET /wisp/fs/:site - Get site record (metadata/manifest) 41 41 - * GET /wisp/fs/:site/file/* - Get individual file content by path 42 40 * POST /wisp/upload-files - Upload and deploy files as a site 43 41 */

+2 -2

lexicons/fs.json

··· 18 18 }, 19 19 "file": { 20 20 "type": "object", 21 21 - "required": ["type", "hash"], 21 21 + "required": ["type", "blob"], 22 22 "properties": { 23 23 "type": { "type": "string", "const": "file" }, 24 24 - "hash": { "type": "string", "description": "Content blob hash" } 24 24 + "blob": { "type": "blob", "accept": ["*/*"], "maxSize": 1000000, "description": "Content blob ref" } 25 25 } 26 26 }, 27 27 "directory": {

+123

public/editor/editor.tsx

··· 1 1 + import { useState, useRef } from 'react' 2 2 + import { createRoot } from 'react-dom/client' 3 3 + 4 4 + import Layout from '@public/layouts' 5 5 + 6 6 + function Editor() { 7 7 + const [uploading, setUploading] = useState(false) 8 8 + const [result, setResult] = useState<any>(null) 9 9 + const [error, setError] = useState<string | null>(null) 10 10 + const folderInputRef = useRef<HTMLInputElement>(null) 11 11 + const siteNameRef = useRef<HTMLInputElement>(null) 12 12 + 13 13 + const handleFileUpload = async (e: React.FormEvent) => { 14 14 + e.preventDefault() 15 15 + setError(null) 16 16 + setResult(null) 17 17 + 18 18 + const files = folderInputRef.current?.files 19 19 + const siteName = siteNameRef.current?.value 20 20 + 21 21 + if (!files || files.length === 0) { 22 22 + setError('Please select a folder to upload') 23 23 + return 24 24 + } 25 25 + 26 26 + if (!siteName) { 27 27 + setError('Please enter a site name') 28 28 + return 29 29 + } 30 30 + 31 31 + setUploading(true) 32 32 + 33 33 + try { 34 34 + const formData = new FormData() 35 35 + formData.append('siteName', siteName) 36 36 + 37 37 + for (let i = 0; i < files.length; i++) { 38 38 + formData.append('files', files[i]) 39 39 + } 40 40 + 41 41 + const response = await fetch('/wisp/upload-files', { 42 42 + method: 'POST', 43 43 + body: formData 44 44 + }) 45 45 + 46 46 + if (!response.ok) { 47 47 + throw new Error(`Upload failed: ${response.statusText}`) 48 48 + } 49 49 + 50 50 + const data = await response.json() 51 51 + setResult(data) 52 52 + } catch (err) { 53 53 + setError(err instanceof Error ? err.message : 'Upload failed') 54 54 + } finally { 55 55 + setUploading(false) 56 56 + } 57 57 + } 58 58 + 59 59 + return ( 60 60 + <div className="w-full max-w-2xl mx-auto p-6"> 61 61 + <h1 className="text-3xl font-bold mb-6 text-center">Upload Folder</h1> 62 62 + 63 63 + <form onSubmit={handleFileUpload} className="space-y-4"> 64 64 + <div> 65 65 + <label htmlFor="siteName" className="block text-sm font-medium mb-2"> 66 66 + Site Name 67 67 + </label> 68 68 + <input 69 69 + ref={siteNameRef} 70 70 + type="text" 71 71 + id="siteName" 72 72 + placeholder="Enter site name" 73 73 + className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500" 74 74 + /> 75 75 + </div> 76 76 + 77 77 + <div> 78 78 + <label htmlFor="folder" className="block text-sm font-medium mb-2"> 79 79 + Select Folder 80 80 + </label> 81 81 + <input 82 82 + ref={folderInputRef} 83 83 + type="file" 84 84 + id="folder" 85 85 + {...({ webkitdirectory: '', directory: '' } as any)} 86 86 + multiple 87 87 + className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500" 88 88 + /> 89 89 + </div> 90 90 + 91 91 + <button 92 92 + type="submit" 93 93 + disabled={uploading} 94 94 + className="w-full bg-blue-600 hover:bg-blue-700 disabled:bg-gray-400 text-white font-semibold py-2 px-4 rounded-md transition-colors" 95 95 + > 96 96 + {uploading ? 'Uploading...' : 'Upload Folder'} 97 97 + </button> 98 98 + </form> 99 99 + 100 100 + {error && ( 101 101 + <div className="mt-4 p-3 bg-red-100 border border-red-400 text-red-700 rounded-md"> 102 102 + {error} 103 103 + </div> 104 104 + )} 105 105 + 106 106 + {result && ( 107 107 + <div className="mt-4 p-3 bg-green-100 border border-green-400 text-green-700 rounded-md"> 108 108 + <h3 className="font-semibold mb-2">Upload Successful!</h3> 109 109 + <p>Files uploaded: {result.fileCount}</p> 110 110 + <p>Site name: {result.siteName}</p> 111 111 + <p>URI: {result.uri}</p> 112 112 + </div> 113 113 + )} 114 114 + </div> 115 115 + ) 116 116 + } 117 117 + 118 118 + const root = createRoot(document.getElementById('elysia')!) 119 119 + root.render( 120 120 + <Layout className="gap-6"> 121 121 + <Editor /> 122 122 + </Layout> 123 123 + )

+12

public/editor/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>Elysia Static</title> 7 7 + </head> 8 8 + <body> 9 9 + <div id="elysia"></div> 10 10 + <script type="module" src="./editor.tsx"></script> 11 11 + </body> 12 12 + </html>

+4 -21

src/index.ts

··· 10 10 getOAuthClient, 11 11 getCurrentKeys 12 12 } from './lib/oauth-client' 13 13 + import { authRoutes } from './routes/auth' 14 14 + import { wispRoutes } from './routes/wisp' 13 15 14 16 const config: Config = { 15 17 domain: (Bun.env.DOMAIN ?? `https://${BASE_HOST}`) as `https://${string}`, ··· 29 31 prefix: '/' 30 32 }) 31 33 ) 32 32 - .post('/api/auth/signin', async (c) => { 33 33 - try { 34 34 - const { handle } = await c.request.json() 35 35 - const state = crypto.randomUUID() 36 36 - const url = await client.authorize(handle, { state }) 37 37 - return { url: url.toString() } 38 38 - } catch (err) { 39 39 - console.error('Signin error', err) 40 40 - return { error: 'Authentication failed' } 41 41 - } 42 42 - }) 43 43 - .get('/api/auth/callback', async (c) => { 44 44 - const params = new URLSearchParams(c.query) 45 45 - const { session } = await client.callback(params) 46 46 - if (!session) return { error: 'Authentication failed' } 47 47 - 48 48 - const cookieSession = c.cookie 49 49 - cookieSession.did.value = session.did 50 50 - 51 51 - return c.redirect('/') 52 52 - }) 34 34 + .use(authRoutes(client)) 35 35 + .use(wispRoutes(client)) 53 36 .get('/client-metadata.json', (c) => { 54 37 return createClientMetadata(config) 55 38 })

+6 -4

src/lexicon/lexicons.ts

··· 42 42 }, 43 43 file: { 44 44 type: 'object', 45 45 - required: ['type', 'hash'], 45 45 + required: ['type', 'blob'], 46 46 properties: { 47 47 type: { 48 48 type: 'string', 49 49 const: 'file', 50 50 }, 51 51 - hash: { 52 52 - type: 'string', 53 53 - description: 'Content blob hash', 51 51 + blob: { 52 52 + type: 'blob', 53 53 + accept: ['*/*'], 54 54 + maxSize: 1000000, 55 55 + description: 'Content blob ref', 54 56 }, 55 57 }, 56 58 },

+2 -2

src/lexicon/types/place/wisp/fs.ts

··· 32 32 export interface File { 33 33 $type?: 'place.wisp.fs#file' 34 34 type: 'file' 35 35 - /** Content blob hash */ 36 36 - hash: string 35 35 + /** Content blob ref */ 36 36 + blob: BlobRef 37 37 } 38 38 39 39 const hashFile = 'file'

+37

src/lib/wisp-auth.ts

··· 1 1 + import { Did } from "@atproto/api"; 2 2 + import { NodeOAuthClient } from "@atproto/oauth-client-node"; 3 3 + import type { OAuthSession } from "@atproto/oauth-client-node"; 4 4 + import { Cookie } from "elysia"; 5 5 + 6 6 + 7 7 + export interface AuthenticatedContext { 8 8 + did: Did; 9 9 + session: OAuthSession; 10 10 + } 11 11 + 12 12 + export const authenticateRequest = async ( 13 13 + client: NodeOAuthClient, 14 14 + cookies: Record<string, Cookie<unknown>> 15 15 + ): Promise<AuthenticatedContext | null> => { 16 16 + try { 17 17 + const did = cookies.did?.value as Did; 18 18 + if (!did) return null; 19 19 + 20 20 + const session = await client.restore(did, "auto"); 21 21 + return session ? { did, session } : null; 22 22 + } catch (err) { 23 23 + console.error('Authentication error:', err); 24 24 + return null; 25 25 + } 26 26 + }; 27 27 + 28 28 + export const requireAuth = async ( 29 29 + client: NodeOAuthClient, 30 30 + cookies: Record<string, Cookie<unknown>> 31 31 + ): Promise<AuthenticatedContext> => { 32 32 + const auth = await authenticateRequest(client, cookies); 33 33 + if (!auth) { 34 34 + throw new Error('Authentication required'); 35 35 + } 36 36 + return auth; 37 37 + };

+203

src/lib/wisp-utils.ts

··· 1 1 + import type { BlobRef } from "@atproto/api"; 2 2 + import type { Record, Directory, File, Entry } from "../lexicon/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 + } 10 10 + 11 11 + export interface FileUploadResult { 12 12 + hash: string; 13 13 + blobRef: BlobRef; 14 14 + } 15 15 + 16 16 + export interface ProcessedDirectory { 17 17 + directory: Directory; 18 18 + fileCount: number; 19 19 + } 20 20 + 21 21 + /** 22 22 + * Process uploaded files into a directory structure 23 23 + */ 24 24 + export function processUploadedFiles(files: UploadedFile[]): ProcessedDirectory { 25 25 + console.log(`🏗️ Processing ${files.length} uploaded files`); 26 26 + const entries: Entry[] = []; 27 27 + let fileCount = 0; 28 28 + 29 29 + // Group files by directory 30 30 + const directoryMap = new Map<string, UploadedFile[]>(); 31 31 + 32 32 + for (const file of files) { 33 33 + // Remove any base folder name from the path 34 34 + const normalizedPath = file.name.replace(/^[^\/]*\//, ''); 35 35 + const parts = normalizedPath.split('/'); 36 36 + 37 37 + console.log(`📄 Processing file: ${file.name} -> normalized: ${normalizedPath}`); 38 38 + 39 39 + if (parts.length === 1) { 40 40 + // Root level file 41 41 + console.log(`📁 Root level file: ${parts[0]}`); 42 42 + entries.push({ 43 43 + name: parts[0], 44 44 + node: { 45 45 + $type: 'place.wisp.fs#file' as const, 46 46 + type: 'file' as const, 47 47 + blob: undefined as any // Will be filled after upload 48 48 + } 49 49 + }); 50 50 + fileCount++; 51 51 + } else { 52 52 + // File in subdirectory 53 53 + const dirPath = parts.slice(0, -1).join('/'); 54 54 + console.log(`📂 Subdirectory file: ${dirPath}/${parts[parts.length - 1]}`); 55 55 + if (!directoryMap.has(dirPath)) { 56 56 + directoryMap.set(dirPath, []); 57 57 + console.log(`➕ Created directory: ${dirPath}`); 58 58 + } 59 59 + directoryMap.get(dirPath)!.push({ 60 60 + ...file, 61 61 + name: normalizedPath 62 62 + }); 63 63 + } 64 64 + } 65 65 + 66 66 + // Process subdirectories 67 67 + console.log(`📂 Processing ${directoryMap.size} subdirectories`); 68 68 + for (const [dirPath, dirFiles] of directoryMap) { 69 69 + console.log(`📁 Processing directory: ${dirPath} with ${dirFiles.length} files`); 70 70 + const dirEntries: Entry[] = []; 71 71 + 72 72 + for (const file of dirFiles) { 73 73 + const fileName = file.name.split('/').pop()!; 74 74 + console.log(` 📄 Adding file to directory: ${fileName}`); 75 75 + dirEntries.push({ 76 76 + name: fileName, 77 77 + node: { 78 78 + $type: 'place.wisp.fs#file' as const, 79 79 + type: 'file' as const, 80 80 + blob: undefined as any // Will be filled after upload 81 81 + } 82 82 + }); 83 83 + fileCount++; 84 84 + } 85 85 + 86 86 + // Build nested directory structure 87 87 + const pathParts = dirPath.split('/'); 88 88 + let currentEntries = entries; 89 89 + 90 90 + console.log(`🏗️ Building nested structure for path: ${pathParts.join('/')}`); 91 91 + 92 92 + for (let i = 0; i < pathParts.length; i++) { 93 93 + const part = pathParts[i]; 94 94 + const isLast = i === pathParts.length - 1; 95 95 + 96 96 + let existingEntry = currentEntries.find(e => e.name === part); 97 97 + 98 98 + if (!existingEntry) { 99 99 + const newDir = { 100 100 + $type: 'place.wisp.fs#directory' as const, 101 101 + type: 'directory' as const, 102 102 + entries: isLast ? dirEntries : [] 103 103 + }; 104 104 + 105 105 + existingEntry = { 106 106 + name: part, 107 107 + node: newDir 108 108 + }; 109 109 + currentEntries.push(existingEntry); 110 110 + console.log(` ➕ Created directory entry: ${part}`); 111 111 + } else if ('entries' in existingEntry.node && isLast) { 112 112 + (existingEntry.node as any).entries.push(...dirEntries); 113 113 + console.log(` 📝 Added files to existing directory: ${part}`); 114 114 + } 115 115 + 116 116 + if (existingEntry && 'entries' in existingEntry.node) { 117 117 + currentEntries = (existingEntry.node as any).entries; 118 118 + } 119 119 + } 120 120 + } 121 121 + 122 122 + console.log(`✅ Directory structure completed with ${fileCount} total files`); 123 123 + 124 124 + const result = { 125 125 + directory: { 126 126 + $type: 'place.wisp.fs#directory' as const, 127 127 + type: 'directory' as const, 128 128 + entries 129 129 + }, 130 130 + fileCount 131 131 + }; 132 132 + 133 133 + console.log('📋 Final directory structure:', JSON.stringify(result, null, 2)); 134 134 + return result; 135 135 + } 136 136 + 137 137 + /** 138 138 + * Create the manifest record for a site 139 139 + */ 140 140 + export function createManifest( 141 141 + siteName: string, 142 142 + root: Directory, 143 143 + fileCount: number 144 144 + ): Record { 145 145 + const manifest: Record = { 146 146 + $type: 'place.wisp.fs' as const, 147 147 + site: siteName, 148 148 + root, 149 149 + fileCount, 150 150 + createdAt: new Date().toISOString() 151 151 + }; 152 152 + 153 153 + console.log(`📋 Created manifest for site "${siteName}" with ${fileCount} files`); 154 154 + console.log('📄 Manifest structure:', JSON.stringify(manifest, null, 2)); 155 155 + 156 156 + return manifest; 157 157 + } 158 158 + 159 159 + /** 160 160 + * Update file blobs in directory structure after upload 161 161 + */ 162 162 + export function updateFileBlobs( 163 163 + directory: Directory, 164 164 + uploadResults: FileUploadResult[], 165 165 + filePaths: string[] 166 166 + ): Directory { 167 167 + console.log(`🔄 Updating file blobs: ${uploadResults.length} results for ${filePaths.length} paths`); 168 168 + 169 169 + const updatedEntries = directory.entries.map(entry => { 170 170 + if ('type' in entry.node && entry.node.type === 'file') { 171 171 + const fileIndex = filePaths.findIndex(path => path.endsWith(entry.name)); 172 172 + if (fileIndex !== -1 && uploadResults[fileIndex]) { 173 173 + console.log(` 🔗 Updating blob for file: ${entry.name} -> ${uploadResults[fileIndex].hash}`); 174 174 + return { 175 175 + ...entry, 176 176 + node: { 177 177 + $type: 'place.wisp.fs#file' as const, 178 178 + type: 'file' as const, 179 179 + blob: uploadResults[fileIndex].blobRef 180 180 + } 181 181 + }; 182 182 + } else { 183 183 + console.warn(` ⚠️ Could not find upload result for file: ${entry.name}`); 184 184 + } 185 185 + } else if ('type' in entry.node && entry.node.type === 'directory') { 186 186 + console.log(` 📂 Recursively updating directory: ${entry.name}`); 187 187 + return { 188 188 + ...entry, 189 189 + node: updateFileBlobs(entry.node as Directory, uploadResults, filePaths) 190 190 + }; 191 191 + } 192 192 + return entry; 193 193 + }) as Entry[]; 194 194 + 195 195 + const result = { 196 196 + $type: 'place.wisp.fs#directory' as const, 197 197 + type: 'directory' as const, 198 198 + entries: updatedEntries 199 199 + }; 200 200 + 201 201 + console.log('✅ File blobs updated'); 202 202 + return result; 203 203 + }

+25

src/routes/auth.ts

··· 1 1 + import { Elysia } from 'elysia' 2 2 + import { NodeOAuthClient } from '@atproto/oauth-client-node' 3 3 + 4 4 + export const authRoutes = (client: NodeOAuthClient) => new Elysia() 5 5 + .post('/api/auth/signin', async (c) => { 6 6 + try { 7 7 + const { handle } = await c.request.json() 8 8 + const state = crypto.randomUUID() 9 9 + const url = await client.authorize(handle, { state }) 10 10 + return { url: url.toString() } 11 11 + } catch (err) { 12 12 + console.error('Signin error', err) 13 13 + return { error: 'Authentication failed' } 14 14 + } 15 15 + }) 16 16 + .get('/api/auth/callback', async (c) => { 17 17 + const params = new URLSearchParams(c.query) 18 18 + const { session } = await client.callback(params) 19 19 + if (!session) return { error: 'Authentication failed' } 20 20 + 21 21 + const cookieSession = c.cookie 22 22 + cookieSession.did.value = session.did 23 23 + 24 24 + return c.redirect('/editor') 25 25 + })

+230

src/routes/wisp.ts

··· 1 1 + import { Elysia } from 'elysia' 2 2 + import { requireAuth, type AuthenticatedContext } from '../lib/wisp-auth' 3 3 + import { NodeOAuthClient } from '@atproto/oauth-client-node' 4 4 + import { Agent } from '@atproto/api' 5 5 + import { 6 6 + type UploadedFile, 7 7 + type FileUploadResult, 8 8 + processUploadedFiles, 9 9 + createManifest, 10 10 + updateFileBlobs 11 11 + } from '../lib/wisp-utils' 12 12 + 13 13 + export const wispRoutes = (client: NodeOAuthClient) => 14 14 + new Elysia({ prefix: '/wisp' }) 15 15 + .derive(async ({ cookie }) => { 16 16 + const auth = await requireAuth(client, cookie) 17 17 + return { auth } 18 18 + }) 19 19 + .post( 20 20 + '/upload-files', 21 21 + async ({ body, auth }) => { 22 22 + const { siteName, files } = body as { 23 23 + siteName: string; 24 24 + files: File | File[] 25 25 + }; 26 26 + 27 27 + console.log('🚀 Starting upload process', { siteName, fileCount: Array.isArray(files) ? files.length : 1 }); 28 28 + 29 29 + try { 30 30 + if (!files || (Array.isArray(files) ? files.length === 0 : !files)) { 31 31 + console.error('❌ No files provided'); 32 32 + throw new Error('No files provided') 33 33 + } 34 34 + 35 35 + if (!siteName) { 36 36 + console.error('❌ Site name is required'); 37 37 + throw new Error('Site name is required') 38 38 + } 39 39 + 40 40 + console.log('✅ Initial validation passed'); 41 41 + 42 42 + // Create agent with OAuth session 43 43 + console.log('🔐 Creating agent with OAuth session'); 44 44 + const agent = new Agent((url, init) => auth.session.fetchHandler(url, init)) 45 45 + console.log('✅ Agent created successfully'); 46 46 + 47 47 + // Convert File objects to UploadedFile format 48 48 + // Elysia gives us File objects directly, handle both single file and array 49 49 + const fileArray = Array.isArray(files) ? files : [files]; 50 50 + console.log(`📁 Processing ${fileArray.length} files`); 51 51 + const uploadedFiles: UploadedFile[] = []; 52 52 + 53 53 + // Define allowed file extensions for static site hosting 54 54 + const allowedExtensions = new Set([ 55 55 + // HTML 56 56 + '.html', '.htm', 57 57 + // CSS 58 58 + '.css', 59 59 + // JavaScript 60 60 + '.js', '.mjs', '.jsx', '.ts', '.tsx', 61 61 + // Images 62 62 + '.jpg', '.jpeg', '.png', '.gif', '.svg', '.webp', '.ico', '.avif', 63 63 + // Fonts 64 64 + '.woff', '.woff2', '.ttf', '.otf', '.eot', 65 65 + // Documents 66 66 + '.pdf', '.txt', 67 67 + // JSON (for config files, but not .map files) 68 68 + '.json', 69 69 + // Audio/Video 70 70 + '.mp3', '.mp4', '.webm', '.ogg', '.wav', 71 71 + // Other web assets 72 72 + '.xml', '.rss', '.atom' 73 73 + ]); 74 74 + 75 75 + // Files to explicitly exclude 76 76 + const excludedFiles = new Set([ 77 77 + '.map', '.DS_Store', 'Thumbs.db' 78 78 + ]); 79 79 + 80 80 + for (let i = 0; i < fileArray.length; i++) { 81 81 + const file = fileArray[i]; 82 82 + const fileExtension = '.' + file.name.split('.').pop()?.toLowerCase(); 83 83 + 84 84 + console.log(`📄 Processing file ${i + 1}/${fileArray.length}: ${file.name} (${file.size} bytes, ${file.type})`); 85 85 + 86 86 + // Skip excluded files 87 87 + if (excludedFiles.has(fileExtension)) { 88 88 + console.log(`⏭️ Skipping excluded file: ${file.name}`); 89 89 + continue; 90 90 + } 91 91 + 92 92 + // Skip files that aren't in allowed extensions 93 93 + if (!allowedExtensions.has(fileExtension)) { 94 94 + console.log(`⏭️ Skipping non-web file: ${file.name} (${fileExtension})`); 95 95 + continue; 96 96 + } 97 97 + 98 98 + // Skip files that are too large (limit to 100MB per file) 99 99 + const maxSize = 100 * 1024 * 1024; // 100MB 100 100 + if (file.size > maxSize) { 101 101 + console.log(`⏭️ Skipping large file: ${file.name} (${(file.size / 1024 / 1024).toFixed(2)}MB > 100MB limit)`); 102 102 + continue; 103 103 + } 104 104 + 105 105 + console.log(`✅ Including file: ${file.name}`); 106 106 + const arrayBuffer = await file.arrayBuffer(); 107 107 + uploadedFiles.push({ 108 108 + name: file.name, 109 109 + content: Buffer.from(arrayBuffer), 110 110 + mimeType: file.type || 'application/octet-stream', 111 111 + size: file.size 112 112 + }); 113 113 + } 114 114 + 115 115 + // Check total size limit (300MB) 116 116 + const totalSize = uploadedFiles.reduce((sum, file) => sum + file.size, 0); 117 117 + const maxTotalSize = 300 * 1024 * 1024; // 300MB 118 118 + 119 119 + console.log(`📊 Filtered to ${uploadedFiles.length} files from ${fileArray.length} total files`); 120 120 + console.log(`📦 Total size: ${(totalSize / 1024 / 1024).toFixed(2)}MB (limit: 300MB)`); 121 121 + 122 122 + if (totalSize > maxTotalSize) { 123 123 + throw new Error(`Total upload size ${(totalSize / 1024 / 1024).toFixed(2)}MB exceeds 300MB limit`); 124 124 + } 125 125 + 126 126 + if (uploadedFiles.length === 0) { 127 127 + throw new Error('No valid web files found to upload. Allowed types: HTML, CSS, JS, images, fonts, PDFs, and other web assets.'); 128 128 + } 129 129 + 130 130 + console.log('✅ File conversion completed'); 131 131 + 132 132 + // Process files into directory structure 133 133 + console.log('🏗️ Building directory structure'); 134 134 + const { directory, fileCount } = processUploadedFiles(uploadedFiles); 135 135 + console.log(`✅ Directory structure created with ${fileCount} files`); 136 136 + 137 137 + // Upload files as blobs 138 138 + const uploadResults: FileUploadResult[] = []; 139 139 + const filePaths: string[] = []; 140 140 + 141 141 + console.log('⬆️ Starting blob upload process'); 142 142 + for (let i = 0; i < uploadedFiles.length; i++) { 143 143 + const file = uploadedFiles[i]; 144 144 + console.log(`📤 Uploading blob ${i + 1}/${uploadedFiles.length}: ${file.name}`); 145 145 + 146 146 + try { 147 147 + console.log(`🔍 Upload details:`, { 148 148 + fileName: file.name, 149 149 + fileSize: file.size, 150 150 + mimeType: file.mimeType, 151 151 + contentLength: file.content.length 152 152 + }); 153 153 + 154 154 + const uploadResult = await agent.com.atproto.repo.uploadBlob( 155 155 + file.content, 156 156 + { 157 157 + encoding: file.mimeType 158 158 + } 159 159 + ); 160 160 + 161 161 + console.log(`✅ Upload successful for ${file.name}:`, { 162 162 + hash: uploadResult.data.blob.ref.toString(), 163 163 + mimeType: uploadResult.data.blob.mimeType, 164 164 + size: uploadResult.data.blob.size 165 165 + }); 166 166 + 167 167 + uploadResults.push({ 168 168 + hash: uploadResult.data.blob.ref.toString(), 169 169 + blobRef: uploadResult.data.blob 170 170 + }); 171 171 + 172 172 + filePaths.push(file.name); 173 173 + } catch (uploadError) { 174 174 + console.error(`❌ Upload failed for file ${file.name}:`, uploadError); 175 175 + console.error('Upload error details:', { 176 176 + fileName: file.name, 177 177 + fileSize: file.size, 178 178 + mimeType: file.mimeType, 179 179 + error: uploadError 180 180 + }); 181 181 + throw uploadError; 182 182 + } 183 183 + } 184 184 + 185 185 + console.log('✅ All blobs uploaded successfully'); 186 186 + 187 187 + // Update directory with file blobs 188 188 + console.log('🔄 Updating file blobs in directory structure'); 189 189 + const updatedDirectory = updateFileBlobs(directory, uploadResults, filePaths); 190 190 + console.log('✅ File blobs updated'); 191 191 + 192 192 + // Create manifest 193 193 + console.log('📋 Creating manifest'); 194 194 + const manifest = createManifest(siteName, updatedDirectory, fileCount); 195 195 + console.log('✅ Manifest created'); 196 196 + 197 197 + // Create the record 198 198 + console.log('📝 Creating record in repo'); 199 199 + const record = await agent.com.atproto.repo.createRecord({ 200 200 + repo: auth.did, 201 201 + collection: 'place.wisp.fs', 202 202 + record: manifest 203 203 + }); 204 204 + 205 205 + console.log('✅ Record created successfully:', { 206 206 + uri: record.data.uri, 207 207 + cid: record.data.cid 208 208 + }); 209 209 + 210 210 + const result = { 211 211 + success: true, 212 212 + uri: record.data.uri, 213 213 + cid: record.data.cid, 214 214 + fileCount, 215 215 + siteName 216 216 + }; 217 217 + 218 218 + console.log('🎉 Upload process completed successfully'); 219 219 + return result; 220 220 + } catch (error) { 221 221 + console.error('❌ Upload error:', error); 222 222 + console.error('Error details:', { 223 223 + message: error instanceof Error ? error.message : 'Unknown error', 224 224 + stack: error instanceof Error ? error.stack : undefined, 225 225 + name: error instanceof Error ? error.name : undefined 226 226 + }); 227 227 + throw new Error(`Failed to upload files: ${error instanceof Error ? error.message : 'Unknown error'}`); 228 228 + } 229 229 + } 230 230 + )