commit 37312b38f1af4f2e1ed69b2bbcad4b68d22f1ace · nekomimi.pet/wisp.place-monorepo

-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
       +
       		)