commit 69e900e330179d3a19fdfd50368566756a7ff8ce · ptr.pet/wisp.place-monorepo

+8 -2

hosting-service/src/lib/db.ts

···

       46
       46
        
       

     

       47
       47
        
       export async function upsertSite(did: string, rkey: string, displayName?: string) {

     

       48
       48
        
         try {

     

       49
       49
       +
           // Only set display_name if provided (not undefined/null/empty)

     

       50
       50
       +
           const cleanDisplayName = displayName && displayName.trim() ? displayName.trim() : null;

     

       51
       51
       +
       

     

       49
       52
        
           await sql`

     

       50
       53
        
             INSERT INTO sites (did, rkey, display_name, created_at, updated_at)

     

       51
       51
       -
             VALUES (${did}, ${rkey}, ${displayName || null}, EXTRACT(EPOCH FROM NOW()), EXTRACT(EPOCH FROM NOW()))

     

       54
       54
       +
             VALUES (${did}, ${rkey}, ${cleanDisplayName}, EXTRACT(EPOCH FROM NOW()), EXTRACT(EPOCH FROM NOW()))

     

       52
       55
        
             ON CONFLICT (did, rkey)

     

       53
       56
        
             DO UPDATE SET

     

       54
       54
       -
               display_name = COALESCE(EXCLUDED.display_name, sites.display_name),

     

       57
       57
       +
               display_name = CASE

     

       58
       58
       +
                 WHEN EXCLUDED.display_name IS NOT NULL THEN EXCLUDED.display_name

     

       59
       59
       +
                 ELSE sites.display_name

     

       60
       60
       +
               END,

     

       55
       61
        
               updated_at = EXTRACT(EPOCH FROM NOW())

     

       56
       62
        
           `;

     

       57
       63
        
         } catch (err) {

+12

hosting-service/src/lib/utils.ts

···

       102
       102
        
       

     

       103
       103
        
       export async function downloadAndCacheSite(did: string, rkey: string, record: WispFsRecord, pdsEndpoint: string): Promise<void> {

     

       104
       104
        
         console.log('Caching site', did, rkey);

     

       105
       105
       +
       

     

       106
       106
       +
         // Validate record structure

     

       107
       107
       +
         if (!record.root) {

     

       108
       108
       +
           console.error('Record missing root directory:', JSON.stringify(record, null, 2));

     

       109
       109
       +
           throw new Error('Invalid record structure: missing root directory');

     

       110
       110
       +
         }

     

       111
       111
       +
       

     

       112
       112
       +
         if (!record.root.entries || !Array.isArray(record.root.entries)) {

     

       113
       113
       +
           console.error('Record root missing entries array:', JSON.stringify(record.root, null, 2));

     

       114
       114
       +
           throw new Error('Invalid record structure: root missing entries array');

     

       115
       115
       +
         }

     

       116
       116
       +
       

     

       105
       117
        
         await cacheFiles(did, rkey, record.root.entries, pdsEndpoint, '');

     

       106
       118
        
       }

     

       107
       119

+7 -1

src/index.ts

···

       52
       52
        
       			})

     

       53
       53
        
       		}

     

       54
       54
        
       	})

     

       55
       55
       -
       	.use(cors())

     

       55
       55
       +
       	.use(cors({

     

       56
       56
       +
       		origin: config.domain,

     

       57
       57
       +
       		credentials: true,

     

       58
       58
       +
       		methods: ['GET', 'POST', 'DELETE', 'OPTIONS'],

     

       59
       59
       +
       		allowedHeaders: ['Content-Type', 'Authorization'],

     

       60
       60
       +
       		maxAge: 86400 // 24 hours

     

       61
       61
       +
       	}))

     

       56
       62
        
       	.listen(8000)

     

       57
       63
        
       

     

       58
       64
        
       console.log(

+8 -2

src/lib/db.ts

···

       391
       391
        
       

     

       392
       392
        
       export const upsertSite = async (did: string, rkey: string, displayName?: string) => {

     

       393
       393
        
           try {

     

       394
       394
       +
               // Only set display_name if provided (not undefined/null/empty)

     

       395
       395
       +
               const cleanDisplayName = displayName && displayName.trim() ? displayName.trim() : null;

     

       396
       396
       +
       

     

       394
       397
        
               await db`

     

       395
       398
        
                   INSERT INTO sites (did, rkey, display_name, created_at, updated_at)

     

       396
       396
       -
                   VALUES (${did}, ${rkey}, ${displayName || null}, EXTRACT(EPOCH FROM NOW()), EXTRACT(EPOCH FROM NOW()))

     

       399
       399
       +
                   VALUES (${did}, ${rkey}, ${cleanDisplayName}, EXTRACT(EPOCH FROM NOW()), EXTRACT(EPOCH FROM NOW()))

     

       397
       400
        
                   ON CONFLICT (did, rkey)

     

       398
       401
        
                   DO UPDATE SET

     

       399
       399
       -
                       display_name = COALESCE(EXCLUDED.display_name, sites.display_name),

     

       402
       402
       +
                       display_name = CASE

     

       403
       403
       +
                           WHEN EXCLUDED.display_name IS NOT NULL THEN EXCLUDED.display_name

     

       404
       404
       +
                           ELSE sites.display_name

     

       405
       405
       +
                       END,

     

       400
       406
        
                       updated_at = EXTRACT(EPOCH FROM NOW())

     

       401
       407
        
               `;

     

       402
       408
        
               return { success: true };

+55 -31

src/lib/wisp-utils.ts

···

       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
       25
        
       	const entries: Entry[] = [];

     

       27
       26
        
       	let fileCount = 0;

     

       28
       27
        
       

     
···

       33
       32
        
       		// Remove any base folder name from the path

     

       34
       33
        
       		const normalizedPath = file.name.replace(/^[^\/]*\//, '');

     

       35
       34
        
       		const parts = normalizedPath.split('/');

     

       36
       36
       -
       

     

       37
       37
       -
       		console.log(`📄 Processing file: ${file.name} -> normalized: ${normalizedPath}`);

     

       38
       35
        
       

     

       39
       36
        
       		if (parts.length === 1) {

     

       40
       37
        
       			// Root level file

     

       41
       41
       -
       			console.log(`📁 Root level file: ${parts[0]}`);

     

       42
       38
        
       			entries.push({

     

       43
       39
        
       				name: parts[0],

     

       44
       40
        
       				node: {

     
···

       51
       47
        
       		} else {

     

       52
       48
        
       			// File in subdirectory

     

       53
       49
        
       			const dirPath = parts.slice(0, -1).join('/');

     

       54
       54
       -
       			console.log(`📂 Subdirectory file: ${dirPath}/${parts[parts.length - 1]}`);

     

       55
       50
        
       			if (!directoryMap.has(dirPath)) {

     

       56
       51
        
       				directoryMap.set(dirPath, []);

     

       57
       57
       -
       				console.log(`➕ Created directory: ${dirPath}`);

     

       58
       52
        
       			}

     

       59
       53
        
       			directoryMap.get(dirPath)!.push({

     

       60
       54
        
       				...file,

     
···

       64
       58
        
       	}

     

       65
       59
        
       

     

       66
       60
        
       	// Process subdirectories

     

       67
       67
       -
       	console.log(`📂 Processing ${directoryMap.size} subdirectories`);

     

       68
       61
        
       	for (const [dirPath, dirFiles] of directoryMap) {

     

       69
       69
       -
       		console.log(`📁 Processing directory: ${dirPath} with ${dirFiles.length} files`);

     

       70
       62
        
       		const dirEntries: Entry[] = [];

     

       71
       63
        
       

     

       72
       64
        
       		for (const file of dirFiles) {

     

       73
       65
        
       			const fileName = file.name.split('/').pop()!;

     

       74
       74
       -
       			console.log(`  📄 Adding file to directory: ${fileName}`);

     

       75
       66
        
       			dirEntries.push({

     

       76
       67
        
       				name: fileName,

     

       77
       68
        
       				node: {

     
···

       86
       77
        
       		// Build nested directory structure

     

       87
       78
        
       		const pathParts = dirPath.split('/');

     

       88
       79
        
       		let currentEntries = entries;

     

       89
       89
       -
       

     

       90
       90
       -
       		console.log(`🏗️  Building nested structure for path: ${pathParts.join('/')}`);

     

       91
       80
        
       

     

       92
       81
        
       		for (let i = 0; i < pathParts.length; i++) {

     

       93
       82
        
       			const part = pathParts[i];

     
···

       107
       96
        
       					node: newDir

     

       108
       97
        
       				};

     

       109
       98
        
       				currentEntries.push(existingEntry);

     

       110
       110
       -
       				console.log(`  ➕ Created directory entry: ${part}`);

     

       111
       99
        
       			} else if ('entries' in existingEntry.node && isLast) {

     

       112
       100
        
       				(existingEntry.node as any).entries.push(...dirEntries);

     

       113
       113
       -
       				console.log(`  📝 Added files to existing directory: ${part}`);

     

       114
       101
        
       			}

     

       115
       102
        
       

     

       116
       103
        
       			if (existingEntry && 'entries' in existingEntry.node) {

     
···

       119
       106
        
       		}

     

       120
       107
        
       	}

     

       121
       108
        
       

     

       122
       122
       -
       	console.log(`✅ Directory structure completed with ${fileCount} total files`);

     

       123
       123
       -
       

     

       124
       109
        
       	const result = {

     

       125
       110
        
       		directory: {

     

       126
       111
        
       			$type: 'place.wisp.fs#directory' as const,

     
···

       130
       115
        
       		fileCount

     

       131
       116
        
       	};

     

       132
       117
        
       

     

       133
       133
       -
       	console.log('📋 Final directory structure:', JSON.stringify(result, null, 2));

     

       134
       118
        
       	return result;

     

       135
       119
        
       }

     

       136
       120
        
       

     
···

       142
       126
        
       	root: Directory,

     

       143
       127
        
       	fileCount: number

     

       144
       128
        
       ): Record {

     

       145
       145
       -
       	const manifest: Record = {

     

       129
       129
       +
       	return {

     

       146
       130
        
       		$type: 'place.wisp.fs' as const,

     

       147
       131
        
       		site: siteName,

     

       148
       132
        
       		root,

     

       149
       133
        
       		fileCount,

     

       150
       134
        
       		createdAt: new Date().toISOString()

     

       151
       135
        
       	};

     

       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
       136
        
       }

     

       158
       137
        
       

     

       159
       138
        
       /**

     

       160
       139
        
        * Update file blobs in directory structure after upload

     

       140
       140
       +
        * Uses path-based matching to correctly match files in nested directories

     

       161
       141
        
        */

     

       162
       142
        
       export function updateFileBlobs(

     

       163
       143
        
       	directory: Directory,

     

       164
       144
        
       	uploadResults: FileUploadResult[],

     

       165
       165
       -
       	filePaths: string[]

     

       145
       145
       +
       	filePaths: string[],

     

       146
       146
       +
       	currentPath: string = ''

     

       166
       147
        
       ): Directory {

     

       167
       167
       -
       	console.log(`🔄 Updating file blobs: ${uploadResults.length} results for ${filePaths.length} paths`);

     

       148
       148
       +
       	const mimeTypeMismatches: string[] = [];

     

       168
       149
        
       

     

       169
       150
        
       	const updatedEntries = directory.entries.map(entry => {

     

       170
       151
        
       		if ('type' in entry.node && entry.node.type === 'file') {

     

       171
       171
       -
       			const fileIndex = filePaths.findIndex(path => path.endsWith(entry.name));

     

       152
       152
       +
       			// Build the full path for this file

     

       153
       153
       +
       			const fullPath = currentPath ? `${currentPath}/${entry.name}` : entry.name;

     

       154
       154
       +
       

     

       155
       155
       +
       			// Find exact match in filePaths (need to handle normalized paths)

     

       156
       156
       +
       			const fileIndex = filePaths.findIndex((path) => {

     

       157
       157
       +
       				// Normalize both paths by removing leading base folder

     

       158
       158
       +
       				const normalizedUploadPath = path.replace(/^[^\/]*\//, '');

     

       159
       159
       +
       				const normalizedEntryPath = fullPath;

     

       160
       160
       +
       				return normalizedUploadPath === normalizedEntryPath || path === fullPath;

     

       161
       161
       +
       			});

     

       162
       162
       +
       

     

       172
       163
        
       			if (fileIndex !== -1 && uploadResults[fileIndex]) {

     

       173
       173
       -
       				console.log(`  🔗 Updating blob for file: ${entry.name} -> ${uploadResults[fileIndex].hash}`);

     

       164
       164
       +
       				const blobRef = uploadResults[fileIndex].blobRef;

     

       165
       165
       +
       				const uploadedPath = filePaths[fileIndex];

     

       166
       166
       +
       

     

       167
       167
       +
       				// Check if MIME types make sense for this file extension

     

       168
       168
       +
       				const expectedMime = getExpectedMimeType(entry.name);

     

       169
       169
       +
       				if (expectedMime && blobRef.mimeType !== expectedMime && !blobRef.mimeType.startsWith(expectedMime)) {

     

       170
       170
       +
       					mimeTypeMismatches.push(`${fullPath}: expected ${expectedMime}, got ${blobRef.mimeType} (from upload: ${uploadedPath})`);

     

       171
       171
       +
       				}

     

       172
       172
       +
       

     

       174
       173
        
       				return {

     

       175
       174
        
       					...entry,

     

       176
       175
        
       					node: {

     

       177
       176
        
       						$type: 'place.wisp.fs#file' as const,

     

       178
       177
        
       						type: 'file' as const,

     

       179
       179
       -
       						blob: uploadResults[fileIndex].blobRef

     

       178
       178
       +
       						blob: blobRef

     

       180
       179
        
       					}

     

       181
       180
        
       				};

     

       182
       181
        
       			} else {

     

       183
       183
       -
       				console.warn(`  ⚠️  Could not find upload result for file: ${entry.name}`);

     

       182
       182
       +
       				console.error(`❌ BLOB MATCHING ERROR: Could not find blob for file: ${fullPath}`);

     

       183
       183
       +
       				console.error(`   Available paths:`, filePaths.slice(0, 10), filePaths.length > 10 ? `... and ${filePaths.length - 10} more` : '');

     

       184
       184
        
       			}

     

       185
       185
        
       		} else if ('type' in entry.node && entry.node.type === 'directory') {

     

       186
       186
       -
       			console.log(`  📂 Recursively updating directory: ${entry.name}`);

     

       186
       186
       +
       			const dirPath = currentPath ? `${currentPath}/${entry.name}` : entry.name;

     

       187
       187
        
       			return {

     

       188
       188
        
       				...entry,

     

       189
       189
       -
       				node: updateFileBlobs(entry.node as Directory, uploadResults, filePaths)

     

       189
       189
       +
       				node: updateFileBlobs(entry.node as Directory, uploadResults, filePaths, dirPath)

     

       190
       190
        
       			};

     

       191
       191
        
       		}

     

       192
       192
        
       		return entry;

     

       193
       193
        
       	}) as Entry[];

     

       194
       194
        
       

     

       195
       195
       +
       	if (mimeTypeMismatches.length > 0) {

     

       196
       196
       +
       		console.error('\n⚠️  MIME TYPE MISMATCHES DETECTED IN MANIFEST:');

     

       197
       197
       +
       		mimeTypeMismatches.forEach(m => console.error(`   ${m}`));

     

       198
       198
       +
       		console.error('');

     

       199
       199
       +
       	}

     

       200
       200
       +
       

     

       195
       201
        
       	const result = {

     

       196
       202
        
       		$type: 'place.wisp.fs#directory' as const,

     

       197
       203
        
       		type: 'directory' as const,

     

       198
       204
        
       		entries: updatedEntries

     

       199
       205
        
       	};

     

       200
       206
        
       

     

       201
       201
       -
       	console.log('✅ File blobs updated');

     

       202
       207
        
       	return result;

     

       203
       208
        
       }

     

       209
       209
       +
       

     

       210
       210
       +
       function getExpectedMimeType(filename: string): string | null {

     

       211
       211
       +
       	const ext = filename.toLowerCase().split('.').pop();

     

       212
       212
       +
       	const mimeMap: Record<string, string> = {

     

       213
       213
       +
       		'html': 'text/html',

     

       214
       214
       +
       		'htm': 'text/html',

     

       215
       215
       +
       		'css': 'text/css',

     

       216
       216
       +
       		'js': 'text/javascript',

     

       217
       217
       +
       		'mjs': 'text/javascript',

     

       218
       218
       +
       		'json': 'application/json',

     

       219
       219
       +
       		'jpg': 'image/jpeg',

     

       220
       220
       +
       		'jpeg': 'image/jpeg',

     

       221
       221
       +
       		'png': 'image/png',

     

       222
       222
       +
       		'gif': 'image/gif',

     

       223
       223
       +
       		'webp': 'image/webp',

     

       224
       224
       +
       		'svg': 'image/svg+xml',

     

       225
       225
       +
       	};

     

       226
       226
       +
       	return ext ? (mimeMap[ext] || null) : null;

     

       227
       227
       +
       }

+78 -21

src/routes/auth.ts

···

       2
       2
        
       import { NodeOAuthClient } from '@atproto/oauth-client-node'

     

       3
       3
        
       import { getSitesByDid, getDomainByDid } from '../lib/db'

     

       4
       4
        
       import { syncSitesFromPDS } from '../lib/sync-sites'

     

       5
       5
       +
       import { authenticateRequest } from '../lib/wisp-auth'

     

       5
       6
        
       

     

       6
       7
        
       export const authRoutes = (client: NodeOAuthClient) => new Elysia()

     

       7
       8
        
       	.post('/api/auth/signin', async (c) => {

     
···

       16
       17
        
       		}

     

       17
       18
        
       	})

     

       18
       19
        
       	.get('/api/auth/callback', async (c) => {

     

       19
       19
       -
       		const params = new URLSearchParams(c.query)

     

       20
       20
       -
       		const { session } = await client.callback(params)

     

       21
       21
       -
       		if (!session) return { error: 'Authentication failed' }

     

       20
       20
       +
       		try {

     

       21
       21
       +
       			const params = new URLSearchParams(c.query)

     

       22
       22
       +
       

     

       23
       23
       +
       			// client.callback() validates the state parameter internally

     

       24
       24
       +
       			// It will throw an error if state validation fails (CSRF protection)

     

       25
       25
       +
       			const { session } = await client.callback(params)

     

       26
       26
       +
       

     

       27
       27
       +
       			if (!session) {

     

       28
       28
       +
       				console.error('[Auth] OAuth callback failed: no session returned')

     

       29
       29
       +
       				return c.redirect('/?error=auth_failed')

     

       30
       30
       +
       			}

     

       22
       31
        
       

     

       23
       23
       -
       		const cookieSession = c.cookie

     

       24
       24
       -
       		cookieSession.did.value = session.did

     

       32
       32
       +
       			const cookieSession = c.cookie

     

       33
       33
       +
       			cookieSession.did.value = session.did

     

       25
       34
        
       

     

       26
       26
       -
       		// Sync sites from PDS to database cache

     

       27
       27
       -
       		console.log('[Auth] Syncing sites from PDS for', session.did)

     

       35
       35
       +
       			// Sync sites from PDS to database cache

     

       36
       36
       +
       			console.log('[Auth] Syncing sites from PDS for', session.did)

     

       37
       37
       +
       			try {

     

       38
       38
       +
       				const syncResult = await syncSitesFromPDS(session.did, session)

     

       39
       39
       +
       				console.log(`[Auth] Sync complete: ${syncResult.synced} sites synced`)

     

       40
       40
       +
       				if (syncResult.errors.length > 0) {

     

       41
       41
       +
       					console.warn('[Auth] Sync errors:', syncResult.errors)

     

       42
       42
       +
       				}

     

       43
       43
       +
       			} catch (err) {

     

       44
       44
       +
       				console.error('[Auth] Failed to sync sites:', err)

     

       45
       45
       +
       				// Don't fail auth if sync fails, just log it

     

       46
       46
       +
       			}

     

       47
       47
       +
       

     

       48
       48
       +
       			// Check if user has any sites or domain

     

       49
       49
       +
       			const sites = await getSitesByDid(session.did)

     

       50
       50
       +
       			const domain = await getDomainByDid(session.did)

     

       51
       51
       +
       

     

       52
       52
       +
       			// If no sites and no domain, redirect to onboarding

     

       53
       53
       +
       			if (sites.length === 0 && !domain) {

     

       54
       54
       +
       				return c.redirect('/onboarding')

     

       55
       55
       +
       			}

     

       56
       56
       +
       

     

       57
       57
       +
       			return c.redirect('/editor')

     

       58
       58
       +
       		} catch (err) {

     

       59
       59
       +
       			// This catches state validation failures and other OAuth errors

     

       60
       60
       +
       			console.error('[Auth] OAuth callback error:', err)

     

       61
       61
       +
       			return c.redirect('/?error=auth_failed')

     

       62
       62
       +
       		}

     

       63
       63
       +
       	})

     

       64
       64
       +
       	.post('/api/auth/logout', async (c) => {

     

       28
       65
        
       		try {

     

       29
       29
       -
       			const syncResult = await syncSitesFromPDS(session.did, session)

     

       30
       30
       -
       			console.log(`[Auth] Sync complete: ${syncResult.synced} sites synced`)

     

       31
       31
       -
       			if (syncResult.errors.length > 0) {

     

       32
       32
       -
       				console.warn('[Auth] Sync errors:', syncResult.errors)

     

       66
       66
       +
       			const cookieSession = c.cookie

     

       67
       67
       +
       			const did = cookieSession.did?.value

     

       68
       68
       +
       

     

       69
       69
       +
       			// Clear the session cookie

     

       70
       70
       +
       			cookieSession.did.value = ''

     

       71
       71
       +
       			cookieSession.did.maxAge = 0

     

       72
       72
       +
       

     

       73
       73
       +
       			// If we have a DID, try to revoke the OAuth session

     

       74
       74
       +
       			if (did && typeof did === 'string') {

     

       75
       75
       +
       				try {

     

       76
       76
       +
       					await client.revoke(did)

     

       77
       77
       +
       					console.log('[Auth] Revoked OAuth session for', did)

     

       78
       78
       +
       				} catch (err) {

     

       79
       79
       +
       					console.error('[Auth] Failed to revoke session:', err)

     

       80
       80
       +
       					// Continue with logout even if revoke fails

     

       81
       81
       +
       				}

     

       33
       82
        
       			}

     

       83
       83
       +
       

     

       84
       84
       +
       			return { success: true }

     

       34
       85
        
       		} catch (err) {

     

       35
       35
       -
       			console.error('[Auth] Failed to sync sites:', err)

     

       36
       36
       -
       			// Don't fail auth if sync fails, just log it

     

       86
       86
       +
       			console.error('[Auth] Logout error:', err)

     

       87
       87
       +
       			return { error: 'Logout failed' }

     

       37
       88
        
       		}

     

       89
       89
       +
       	})

     

       90
       90
       +
       	.get('/api/auth/status', async (c) => {

     

       91
       91
       +
       		try {

     

       92
       92
       +
       			const auth = await authenticateRequest(client, c.cookie)

     

       38
       93
        
       

     

       39
       39
       -
       		// Check if user has any sites or domain

     

       40
       40
       -
       		const sites = await getSitesByDid(session.did)

     

       41
       41
       -
       		const domain = await getDomainByDid(session.did)

     

       94
       94
       +
       			if (!auth) {

     

       95
       95
       +
       				return { authenticated: false }

     

       96
       96
       +
       			}

     

       42
       97
        
       

     

       43
       43
       -
       		// If no sites and no domain, redirect to onboarding

     

       44
       44
       -
       		if (sites.length === 0 && !domain) {

     

       45
       45
       -
       			return c.redirect('/onboarding')

     

       98
       98
       +
       			return {

     

       99
       99
       +
       				authenticated: true,

     

       100
       100
       +
       				did: auth.did

     

       101
       101
       +
       			}

     

       102
       102
       +
       		} catch (err) {

     

       103
       103
       +
       			console.error('[Auth] Status check error:', err)

     

       104
       104
       +
       			return { authenticated: false }

     

       46
       105
        
       		}

     

       47
       47
       -
       

     

       48
       48
       -
       		return c.redirect('/editor')

     

       49
       106
        
       	})

+97 -103

src/routes/wisp.ts

···

       51
       51
        
       					files: File | File[]

     

       52
       52
        
       				};

     

       53
       53
        
       

     

       54
       54
       -
       				console.log('🚀 Starting upload process', { siteName, fileCount: Array.isArray(files) ? files.length : 1 });

     

       55
       55
       -
       

     

       56
       54
        
       				try {

     

       57
       55
        
       					if (!siteName) {

     

       58
       58
       -
       						console.error('❌ Site name is required');

     

       59
       56
        
       						throw new Error('Site name is required')

     

       60
       57
        
       					}

     

       61
       58
        
       

     

       62
       59
        
       					if (!isValidSiteName(siteName)) {

     

       63
       63
       -
       						console.error('❌ Invalid site name format');

     

       64
       60
        
       						throw new Error('Invalid site name: must be 1-512 characters and contain only alphanumeric, dots, dashes, underscores, tildes, and colons')

     

       65
       61
        
       					}

     

       66
       62
        
       

     

       67
       67
       -
       					console.log('✅ Initial validation passed');

     

       68
       68
       -
       

     

       69
       63
        
       					// Check if files were provided

     

       70
       64
        
       					const hasFiles = files && (Array.isArray(files) ? files.length > 0 : !!files);

     

       71
       65
        
       

     

       72
       66
        
       					if (!hasFiles) {

     

       73
       73
       -
       						console.log('📝 Creating empty site (no files provided)');

     

       74
       74
       -
       

     

       75
       67
        
       						// Create agent with OAuth session

     

       76
       76
       -
       						console.log('🔐 Creating agent with OAuth session');

     

       77
       68
        
       						const agent = new Agent((url, init) => auth.session.fetchHandler(url, init))

     

       78
       78
       -
       						console.log('✅ Agent created successfully');

     

       79
       69
        
       

     

       80
       70
        
       						// Create empty manifest

     

       81
       71
        
       						const emptyManifest = {

     
···

       92
       82
        
       						// Use site name as rkey

     

       93
       83
        
       						const rkey = siteName;

     

       94
       84
        
       

     

       95
       95
       -
       						// Create the record with explicit rkey

     

       96
       96
       -
       						console.log(`📝 Creating empty site record in repo with rkey: ${rkey}`);

     

       97
       85
        
       						const record = await agent.com.atproto.repo.putRecord({

     

       98
       86
        
       							repo: auth.did,

     

       99
       87
        
       							collection: 'place.wisp.fs',

     
···

       101
       89
        
       							record: emptyManifest

     

       102
       90
        
       						});

     

       103
       91
        
       

     

       104
       104
       -
       						console.log('✅ Empty site record created successfully:', {

     

       105
       105
       -
       							uri: record.data.uri,

     

       106
       106
       -
       							cid: record.data.cid

     

       107
       107
       -
       						});

     

       108
       108
       -
       

     

       109
       109
       -
       						// Store site in database cache

     

       110
       110
       -
       						console.log('💾 Storing site in database cache');

     

       111
       92
        
       						await upsertSite(auth.did, rkey, siteName);

     

       112
       112
       -
       						console.log('✅ Site stored in database');

     

       113
       93
        
       

     

       114
       94
        
       						return {

     

       115
       95
        
       							success: true,

     
···

       121
       101
        
       					}

     

       122
       102
        
       

     

       123
       103
        
       					// Create agent with OAuth session

     

       124
       124
       -
       					console.log('🔐 Creating agent with OAuth session');

     

       125
       104
        
       					const agent = new Agent((url, init) => auth.session.fetchHandler(url, init))

     

       126
       126
       -
       					console.log('✅ Agent created successfully');

     

       127
       105
        
       

     

       128
       106
        
       					// Convert File objects to UploadedFile format

     

       129
       107
        
       					// Elysia gives us File objects directly, handle both single file and array

     

       130
       108
        
       					const fileArray = Array.isArray(files) ? files : [files];

     

       131
       131
       -
       					console.log(`📁 Processing ${fileArray.length} files`);

     

       132
       109
        
       					const uploadedFiles: UploadedFile[] = [];

     

       133
       110
        
       

     

       134
       111
        
       					// Define allowed file extensions for static site hosting

     
···

       161
       138
        
       					for (let i = 0; i < fileArray.length; i++) {

     

       162
       139
        
       						const file = fileArray[i];

     

       163
       140
        
       						const fileExtension = '.' + file.name.split('.').pop()?.toLowerCase();

     

       164
       164
       -
       						

     

       165
       165
       -
       						console.log(`📄 Processing file ${i + 1}/${fileArray.length}: ${file.name} (${file.size} bytes, ${file.type})`);

     

       166
       166
       -
       						

     

       141
       141
       +
       

     

       167
       142
        
       						// Skip excluded files

     

       168
       143
        
       						if (excludedFiles.has(fileExtension)) {

     

       169
       169
       -
       							console.log(`⏭️  Skipping excluded file: ${file.name}`);

     

       170
       144
        
       							continue;

     

       171
       145
        
       						}

     

       172
       172
       -
       						

     

       146
       146
       +
       

     

       173
       147
        
       						// Skip files that aren't in allowed extensions

     

       174
       148
        
       						if (!allowedExtensions.has(fileExtension)) {

     

       175
       175
       -
       							console.log(`⏭️  Skipping non-web file: ${file.name} (${fileExtension})`);

     

       176
       149
        
       							continue;

     

       177
       150
        
       						}

     

       178
       178
       -
       						

     

       151
       151
       +
       

     

       179
       152
        
       						// Skip files that are too large (limit to 100MB per file)

     

       180
       153
        
       						const maxSize = 100 * 1024 * 1024; // 100MB

     

       181
       154
        
       						if (file.size > maxSize) {

     

       182
       182
       -
       							console.log(`⏭️  Skipping large file: ${file.name} (${(file.size / 1024 / 1024).toFixed(2)}MB > 100MB limit)`);

     

       183
       155
        
       							continue;

     

       184
       156
        
       						}

     

       185
       185
       -
       						

     

       186
       186
       -
       						console.log(`✅ Including file: ${file.name}`);

     

       157
       157
       +
       

     

       187
       158
        
       						const arrayBuffer = await file.arrayBuffer();

     

       188
       159
        
       						uploadedFiles.push({

     

       189
       160
        
       							name: file.name,

     
···

       196
       167
        
       					// Check total size limit (300MB)

     

       197
       168
        
       					const totalSize = uploadedFiles.reduce((sum, file) => sum + file.size, 0);

     

       198
       169
        
       					const maxTotalSize = 300 * 1024 * 1024; // 300MB

     

       199
       199
       -
       					

     

       200
       200
       -
       					console.log(`📊 Filtered to ${uploadedFiles.length} files from ${fileArray.length} total files`);

     

       201
       201
       -
       					console.log(`📦 Total size: ${(totalSize / 1024 / 1024).toFixed(2)}MB (limit: 300MB)`);

     

       202
       170
        
       

     

       203
       171
        
       					if (totalSize > maxTotalSize) {

     

       204
       172
        
       						throw new Error(`Total upload size ${(totalSize / 1024 / 1024).toFixed(2)}MB exceeds 300MB limit`);

     

       205
       173
        
       					}

     

       206
       174
        
       

     

       207
       175
        
       					if (uploadedFiles.length === 0) {

     

       208
       208
       -
       						console.log('⚠️  No valid web files found, creating empty site instead');

     

       209
       176
        
       

     

       210
       177
        
       						// Create empty manifest

     

       211
       178
        
       						const emptyManifest = {

     
···

       222
       189
        
       						// Use site name as rkey

     

       223
       190
        
       						const rkey = siteName;

     

       224
       191
        
       

     

       225
       225
       -
       						// Create the record with explicit rkey

     

       226
       226
       -
       						console.log(`📝 Creating empty site record in repo with rkey: ${rkey}`);

     

       227
       192
        
       						const record = await agent.com.atproto.repo.putRecord({

     

       228
       193
        
       							repo: auth.did,

     

       229
       194
        
       							collection: 'place.wisp.fs',

     
···

       231
       196
        
       							record: emptyManifest

     

       232
       197
        
       						});

     

       233
       198
        
       

     

       234
       234
       -
       						console.log('✅ Empty site record created successfully:', {

     

       235
       235
       -
       							uri: record.data.uri,

     

       236
       236
       -
       							cid: record.data.cid

     

       237
       237
       -
       						});

     

       238
       238
       -
       

     

       239
       239
       -
       						// Store site in database cache

     

       240
       240
       -
       						console.log('💾 Storing site in database cache');

     

       241
       199
        
       						await upsertSite(auth.did, rkey, siteName);

     

       242
       242
       -
       						console.log('✅ Site stored in database');

     

       243
       200
        
       

     

       244
       201
        
       						return {

     

       245
       202
        
       							success: true,

     
···

       251
       208
        
       						};

     

       252
       209
        
       					}

     

       253
       210
        
       

     

       254
       254
       -
       					console.log('✅ File conversion completed');

     

       255
       255
       -
       

     

       256
       211
        
       					// Process files into directory structure

     

       257
       257
       -
       					console.log('🏗️  Building directory structure');

     

       258
       212
        
       					const { directory, fileCount } = processUploadedFiles(uploadedFiles);

     

       259
       259
       -
       					console.log(`✅ Directory structure created with ${fileCount} files`);

     

       260
       213
        
       

     

       261
       261
       -
       					// Upload files as blobs

     

       262
       262
       -
       					const uploadResults: FileUploadResult[] = [];

     

       263
       263
       -
       					const filePaths: string[] = [];

     

       214
       214
       +
       					// Upload files as blobs in parallel

     

       215
       215
       +
       					const mimeTypeMismatches: Array<{file: string, sent: string, returned: string}> = [];

     

       264
       216
        
       

     

       265
       265
       -
       					console.log('⬆️  Starting blob upload process');

     

       266
       266
       -
       					for (let i = 0; i < uploadedFiles.length; i++) {

     

       267
       267
       -
       						const file = uploadedFiles[i];

     

       268
       268
       -
       						console.log(`📤 Uploading blob ${i + 1}/${uploadedFiles.length}: ${file.name}`);

     

       269
       269
       -
       						

     

       217
       217
       +
       					const uploadPromises = uploadedFiles.map(async (file, i) => {

     

       270
       218
        
       						try {

     

       271
       271
       -
       							console.log(`🔍 Upload details:`, {

     

       272
       272
       -
       								fileName: file.name,

     

       273
       273
       -
       								fileSize: file.size,

     

       274
       274
       -
       								mimeType: file.mimeType,

     

       275
       275
       -
       								contentLength: file.content.length

     

       276
       276
       -
       							});

     

       277
       277
       -
       

     

       278
       219
        
       							const uploadResult = await agent.com.atproto.repo.uploadBlob(

     

       279
       220
        
       								file.content,

     

       280
       221
        
       								{

     
···

       282
       223
        
       								}

     

       283
       224
        
       							);

     

       284
       225
        
       

     

       285
       285
       -
       							console.log(`✅ Upload successful for ${file.name}:`, {

     

       286
       286
       -
       								hash: uploadResult.data.blob.ref.toString(),

     

       287
       287
       -
       								mimeType: uploadResult.data.blob.mimeType,

     

       288
       288
       -
       								size: uploadResult.data.blob.size

     

       289
       289
       -
       							});

     

       226
       226
       +
       							const sentMimeType = file.mimeType;

     

       227
       227
       +
       							const returnedBlobRef = uploadResult.data.blob;

     

       290
       228
        
       

     

       291
       291
       -
       							uploadResults.push({

     

       292
       292
       -
       								hash: uploadResult.data.blob.ref.toString(),

     

       293
       293
       -
       								blobRef: uploadResult.data.blob

     

       294
       294
       -
       							});

     

       229
       229
       +
       							// Track MIME type mismatches for summary

     

       230
       230
       +
       							if (sentMimeType !== returnedBlobRef.mimeType) {

     

       231
       231
       +
       								mimeTypeMismatches.push({

     

       232
       232
       +
       									file: file.name,

     

       233
       233
       +
       									sent: sentMimeType,

     

       234
       234
       +
       									returned: returnedBlobRef.mimeType

     

       235
       235
       +
       								});

     

       236
       236
       +
       							}

     

       295
       237
        
       

     

       296
       296
       -
       							filePaths.push(file.name);

     

       238
       238
       +
       							// Use the blob ref exactly as returned from PDS

     

       239
       239
       +
       							return {

     

       240
       240
       +
       								result: {

     

       241
       241
       +
       									hash: returnedBlobRef.ref.$link || returnedBlobRef.ref.toString(),

     

       242
       242
       +
       									blobRef: returnedBlobRef

     

       243
       243
       +
       								},

     

       244
       244
       +
       								filePath: file.name,

     

       245
       245
       +
       								sentMimeType,

     

       246
       246
       +
       								returnedMimeType: returnedBlobRef.mimeType

     

       247
       247
       +
       							};

     

       297
       248
        
       						} catch (uploadError) {

     

       298
       298
       -
       							console.error(`❌ Upload failed for file ${file.name}:`, uploadError);

     

       299
       299
       -
       							console.error('Upload error details:', {

     

       300
       300
       -
       								fileName: file.name,

     

       301
       301
       -
       								fileSize: file.size,

     

       302
       302
       -
       								mimeType: file.mimeType,

     

       303
       303
       -
       								error: uploadError

     

       304
       304
       -
       							});

     

       249
       249
       +
       							console.error(`❌ Upload failed for ${file.name}:`, uploadError);

     

       305
       250
        
       							throw uploadError;

     

       306
       251
        
       						}

     

       252
       252
       +
       					});

     

       253
       253
       +
       

     

       254
       254
       +
       					// Wait for all uploads to complete

     

       255
       255
       +
       					const uploadedBlobs = await Promise.all(uploadPromises);

     

       256
       256
       +
       

     

       257
       257
       +
       					// Show MIME type mismatch summary

     

       258
       258
       +
       					if (mimeTypeMismatches.length > 0) {

     

       259
       259
       +
       						console.warn(`\n⚠️  PDS changed MIME types for ${mimeTypeMismatches.length} files:`);

     

       260
       260
       +
       						mimeTypeMismatches.slice(0, 20).forEach(m => {

     

       261
       261
       +
       							console.warn(`   ${m.file}: ${m.sent} → ${m.returned}`);

     

       262
       262
       +
       						});

     

       263
       263
       +
       						if (mimeTypeMismatches.length > 20) {

     

       264
       264
       +
       							console.warn(`   ... and ${mimeTypeMismatches.length - 20} more`);

     

       265
       265
       +
       						}

     

       266
       266
       +
       						console.warn('');

     

       307
       267
        
       					}

     

       308
       268
        
       

     

       309
       309
       -
       					console.log('✅ All blobs uploaded successfully');

     

       269
       269
       +
       					// CRITICAL: Find files uploaded as application/octet-stream

     

       270
       270
       +
       					const octetStreamFiles = uploadedBlobs.filter(b => b.returnedMimeType === 'application/octet-stream');

     

       271
       271
       +
       					if (octetStreamFiles.length > 0) {

     

       272
       272
       +
       						console.error(`\n🚨 FILES UPLOADED AS application/octet-stream (${octetStreamFiles.length}):`);

     

       273
       273
       +
       						octetStreamFiles.forEach(f => {

     

       274
       274
       +
       							console.error(`   ${f.filePath}: sent=${f.sentMimeType}, returned=${f.returnedMimeType}`);

     

       275
       275
       +
       						});

     

       276
       276
       +
       						console.error('');

     

       277
       277
       +
       					}

     

       278
       278
       +
       

     

       279
       279
       +
       					// Extract results and file paths in correct order

     

       280
       280
       +
       					const uploadResults: FileUploadResult[] = uploadedBlobs.map(blob => blob.result);

     

       281
       281
       +
       					const filePaths: string[] = uploadedBlobs.map(blob => blob.filePath);

     

       310
       282
        
       

     

       311
       283
        
       					// Update directory with file blobs

     

       312
       312
       -
       					console.log('🔄 Updating file blobs in directory structure');

     

       313
       284
        
       					const updatedDirectory = updateFileBlobs(directory, uploadResults, filePaths);

     

       314
       314
       -
       					console.log('✅ File blobs updated');

     

       315
       285
        
       

     

       316
       286
        
       					// Create manifest

     

       317
       317
       -
       					console.log('📋 Creating manifest');

     

       318
       287
        
       					const manifest = createManifest(siteName, updatedDirectory, fileCount);

     

       319
       319
       -
       					console.log('✅ Manifest created');

     

       320
       288
        
       

     

       321
       289
        
       					// Use site name as rkey

     

       322
       290
        
       					const rkey = siteName;

     

       323
       291
        
       

     

       324
       324
       -
       					// Create the record with explicit rkey

     

       325
       325
       -
       					console.log(`📝 Creating record in repo with rkey: ${rkey}`);

     

       326
       326
       -
       					const record = await agent.com.atproto.repo.putRecord({

     

       327
       327
       -
       						repo: auth.did,

     

       328
       328
       -
       						collection: 'place.wisp.fs',

     

       329
       329
       -
       						rkey: rkey,

     

       330
       330
       -
       						record: manifest

     

       331
       331
       -
       					});

     

       292
       292
       +
       					let record;

     

       293
       293
       +
       					try {

     

       294
       294
       +
       						record = await agent.com.atproto.repo.putRecord({

     

       295
       295
       +
       							repo: auth.did,

     

       296
       296
       +
       							collection: 'place.wisp.fs',

     

       297
       297
       +
       							rkey: rkey,

     

       298
       298
       +
       							record: manifest

     

       299
       299
       +
       						});

     

       300
       300
       +
       					} catch (putRecordError: any) {

     

       301
       301
       +
       						console.error('\n❌ Failed to create record on PDS');

     

       302
       302
       +
       						console.error('Error:', putRecordError.message);

     

       332
       303
        
       

     

       333
       333
       -
       					console.log('✅ Record created successfully:', {

     

       334
       334
       -
       						uri: record.data.uri,

     

       335
       335
       -
       						cid: record.data.cid

     

       336
       336
       -
       					});

     

       304
       304
       +
       						// Try to identify which file has the MIME type mismatch

     

       305
       305
       +
       						if (putRecordError.message?.includes('Mimetype') || putRecordError.message?.includes('mimeType')) {

     

       306
       306
       +
       							console.error('\n🔍 Analyzing manifest for MIME type issues...');

     

       307
       307
       +
       

     

       308
       308
       +
       							// Recursively check all blobs in manifest

     

       309
       309
       +
       							const checkBlobs = (node: any, path: string = '') => {

     

       310
       310
       +
       								if (node.type === 'file' && node.blob) {

     

       311
       311
       +
       									const mimeType = node.blob.mimeType;

     

       312
       312
       +
       									console.error(`   File: ${path} - MIME: ${mimeType}`);

     

       313
       313
       +
       								} else if (node.type === 'directory' && node.entries) {

     

       314
       314
       +
       									for (const entry of node.entries) {

     

       315
       315
       +
       										const entryPath = path ? `${path}/${entry.name}` : entry.name;

     

       316
       316
       +
       										checkBlobs(entry.node, entryPath);

     

       317
       317
       +
       									}

     

       318
       318
       +
       								}

     

       319
       319
       +
       							};

     

       320
       320
       +
       

     

       321
       321
       +
       							checkBlobs(manifest.root, '');

     

       322
       322
       +
       

     

       323
       323
       +
       							console.error('\n📊 Blob upload summary:');

     

       324
       324
       +
       							uploadedBlobs.slice(0, 20).forEach((b, i) => {

     

       325
       325
       +
       								console.error(`   [${i}] ${b.filePath}: sent=${b.sentMimeType}, returned=${b.returnedMimeType}`);

     

       326
       326
       +
       							});

     

       327
       327
       +
       							if (uploadedBlobs.length > 20) {

     

       328
       328
       +
       								console.error(`   ... and ${uploadedBlobs.length - 20} more`);

     

       329
       329
       +
       							}

     

       330
       330
       +
       						}

     

       331
       331
       +
       

     

       332
       332
       +
       						throw putRecordError;

     

       333
       333
       +
       					}

     

       337
       334
        
       

     

       338
       335
        
       					// Store site in database cache

     

       339
       339
       -
       					console.log('💾 Storing site in database cache');

     

       340
       336
        
       					await upsertSite(auth.did, rkey, siteName);

     

       341
       341
       -
       					console.log('✅ Site stored in database');

     

       342
       337
        
       

     

       343
       338
        
       					const result = {

     

       344
       339
        
       						success: true,

     
···

       348
       343
        
       						siteName

     

       349
       344
        
       					};

     

       350
       345
        
       

     

       351
       351
       -
       					console.log('🎉 Upload process completed successfully');

     

       352
       346
        
       					return result;

     

       353
       347
        
       				} catch (error) {

     

       354
       348
        
       					console.error('❌ Upload error:', error);