fix regression in nested directories, ensure test on handling

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

···
                 continue;
             }
 
-            console.log(`Processing file ${i + 1}/${fileArray.length}:`, file.name, file.size, 'bytes');
+            // Use webkitRelativePath when available (directory uploads), fallback to name for regular file uploads
+            const filePath = (file as any).webkitRelativePath || file.name;
+
             updateJobProgress(jobId, {
                 filesProcessed: i + 1,
-                currentFile: file.name
+                currentFile: filePath
             });
 
             // Skip files that match ignore patterns
-            const normalizedPath = file.name.replace(/^[^\/]*\//, '');
+            const normalizedPath = filePath.replace(/^[^\/]*\//, '');
 
             if (shouldIgnore(ignoreMatcher, normalizedPath)) {
-                console.log(`Skipping ignored file: ${file.name}`);
                 skippedFiles.push({
-                    name: file.name,
+                    name: filePath,
                     reason: 'matched ignore pattern'
                 });
                 continue;
···
             const maxSize = MAX_FILE_SIZE;
             if (file.size > maxSize) {
                 skippedFiles.push({
-                    name: file.name,
+                    name: filePath,
                     reason: `file too large (${(file.size / 1024 / 1024).toFixed(2)}MB, max 100MB)`
                 });
                 continue;
···
                     // Text files: compress AND base64 encode
                     finalContent = Buffer.from(compressedContent.toString('base64'), 'binary');
                     base64Encoded = true;
-                    const compressionRatio = (compressedContent.length / originalContent.length * 100).toFixed(1);
-                    console.log(`Compressing+base64 ${file.name}: ${originalContent.length} -> ${compressedContent.length} bytes (${compressionRatio}%), base64: ${finalContent.length} bytes`);
-                    logger.info(`Compressing+base64 ${file.name}: ${originalContent.length} -> ${compressedContent.length} bytes (${compressionRatio}%), base64: ${finalContent.length} bytes`);
                 } else {
                     // Audio files: just compress, no base64
                     finalContent = compressedContent;
-                    const compressionRatio = (compressedContent.length / originalContent.length * 100).toFixed(1);
-                    console.log(`Compressing ${file.name}: ${originalContent.length} -> ${compressedContent.length} bytes (${compressionRatio}%)`);
-                    logger.info(`Compressing ${file.name}: ${originalContent.length} -> ${compressedContent.length} bytes (${compressionRatio}%)`);
                 }
             } else {
                 // Binary files: upload directly
                 finalContent = originalContent;
-                console.log(`Uploading ${file.name} directly: ${originalContent.length} bytes (no compression)`);
-                logger.info(`Uploading ${file.name} directly: ${originalContent.length} bytes (binary)`);
             }
 
             uploadedFiles.push({
-                name: file.name,
+                name: filePath,
                 content: finalContent,
                 mimeType: originalMimeType,
                 size: finalContent.length,

bun.lock

···
         "elysia": "^1.4.18",
         "tailwindcss": "^4.1.17",
       },
+      "devDependencies": {
+        "@types/bun": "^1.3.5",
+      },
     },
     "apps/hosting-service": {
       "name": "wisp-hosting-service",
···
 
     "@ts-morph/common": ["@ts-morph/common@0.25.0", "", { "dependencies": { "minimatch": "^9.0.4", "path-browserify": "^1.0.1", "tinyglobby": "^0.2.9" } }, "sha512-kMnZz+vGGHi4GoHnLmMhGNjm44kGtKUXGnOvrKmMwAuvNjM/PgKVGfUnL7IDvK7Jb2QQ82jq3Zmp04Gy+r3Dkg=="],
 
-    "@types/bun": ["@types/bun@1.3.3", "", { "dependencies": { "bun-types": "1.3.3" } }, "sha512-ogrKbJ2X5N0kWLLFKeytG0eHDleBYtngtlbu9cyBKFtNL3cnpDZkNdQj8flVf6WTZUX5ulI9AY1oa7ljhSrp+g=="],
+    "@types/bun": ["@types/bun@1.3.5", "", { "dependencies": { "bun-types": "1.3.5" } }, "sha512-RnygCqNrd3srIPEWBd5LFeUYG7plCoH2Yw9WaZGyNmdTEei+gWaHqydbaIRkIkcbXwhBT94q78QljxN0Sk838w=="],
 
     "@types/mime-types": ["@types/mime-types@2.1.4", "", {}, "sha512-lfU4b34HOri+kAY5UheuFMWPDOI+OPceBSHZKp69gEyTL/mmJ4cnU6Y/rlme3UL3GyOn6Y42hyIEw0/q8sWx5w=="],
 
···
 
     "@tokenizer/inflate/debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
 
-    "@types/bun/bun-types": ["bun-types@1.3.3", "", { "dependencies": { "@types/node": "*" } }, "sha512-z3Xwlg7j2l9JY27x5Qn3Wlyos8YAp0kKRlrePAOjgjMGS5IG6E7Jnlx736vH9UVI4wUICwwhC9anYL++XeOgTQ=="],
+    "@types/bun/bun-types": ["bun-types@1.3.5", "", { "dependencies": { "@types/node": "*" } }, "sha512-inmAYe2PFLs0SUbFOWSVD24sg1jFlMPxOjOSSCYqUgn4Hsc3rDc7dFvfVYjFPNHtov6kgUeulV4SxbuIV/stPw=="],
 
     "@wisp/main-app/@atproto/api": ["@atproto/api@0.17.7", "", { "dependencies": { "@atproto/common-web": "^0.4.3", "@atproto/lexicon": "^0.5.1", "@atproto/syntax": "^0.4.1", "@atproto/xrpc": "^0.7.5", "await-lock": "^2.2.2", "multiformats": "^9.9.0", "tlds": "^1.234.0", "zod": "^3.23.8" } }, "sha512-V+OJBZq9chcrD21xk1bUa6oc5DSKfQj5DmUPf5rmZncqL1w9ZEbS38H5cMyqqdhfgo2LWeDRdZHD0rvNyJsIaw=="],
 
···
     "uint8arrays/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="],
 
     "wisp-hosting-service/@atproto/api": ["@atproto/api@0.17.7", "", { "dependencies": { "@atproto/common-web": "^0.4.3", "@atproto/lexicon": "^0.5.1", "@atproto/syntax": "^0.4.1", "@atproto/xrpc": "^0.7.5", "await-lock": "^2.2.2", "multiformats": "^9.9.0", "tlds": "^1.234.0", "zod": "^3.23.8" } }, "sha512-V+OJBZq9chcrD21xk1bUa6oc5DSKfQj5DmUPf5rmZncqL1w9ZEbS38H5cMyqqdhfgo2LWeDRdZHD0rvNyJsIaw=="],
+
+    "wisp-hosting-service/@types/bun": ["@types/bun@1.3.3", "", { "dependencies": { "bun-types": "1.3.3" } }, "sha512-ogrKbJ2X5N0kWLLFKeytG0eHDleBYtngtlbu9cyBKFtNL3cnpDZkNdQj8flVf6WTZUX5ulI9AY1oa7ljhSrp+g=="],
 
     "@atproto/sync/@atproto/xrpc-server/@atproto/ws-client": ["@atproto/ws-client@0.0.3", "", { "dependencies": { "@atproto/common": "^0.5.0", "ws": "^8.12.0" } }, "sha512-eKqkTWBk6zuMY+6gs02eT7mS8Btewm8/qaL/Dp00NDCqpNC+U59MWvQsOWT3xkNGfd9Eip+V6VI4oyPvAfsfTA=="],
 
···
     "tsx/esbuild/@esbuild/win32-x64": ["@esbuild/win32-x64@0.27.1", "", { "os": "win32", "cpu": "x64" }, "sha512-d5X6RMYv6taIymSk8JBP+nxv8DQAMY6A51GPgusqLdK9wBz5wWIXy1KjTck6HnjE9hqJzJRdk+1p/t5soSbCtw=="],
 
     "wisp-hosting-service/@atproto/api/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="],
+
+    "wisp-hosting-service/@types/bun/bun-types": ["bun-types@1.3.3", "", { "dependencies": { "@types/node": "*" } }, "sha512-z3Xwlg7j2l9JY27x5Qn3Wlyos8YAp0kKRlrePAOjgjMGS5IG6E7Jnlx736vH9UVI4wUICwwhC9anYL++XeOgTQ=="],
   }
 }

package.json

···
     "@parcel/watcher",
     "bun",
     "esbuild"
-  ]
+  ],
+  "devDependencies": {
+    "@types/bun": "^1.3.5"
+  }
 }

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

···
+import { describe, test, expect } from 'bun:test'
+import { processUploadedFiles, type UploadedFile } from './tree'
+
+describe('processUploadedFiles', () => {
+	test('should preserve nested directory structure', () => {
+		const files: UploadedFile[] = [
+			{
+				name: 'mysite/index.html',
+				content: Buffer.from('<html>'),
+				mimeType: 'text/html',
+				size: 6
+			},
+			{
+				name: 'mysite/_astro/main.js',
+				content: Buffer.from('console.log()'),
+				mimeType: 'application/javascript',
+				size: 13
+			},
+			{
+				name: 'mysite/_astro/styles.css',
+				content: Buffer.from('body {}'),
+				mimeType: 'text/css',
+				size: 7
+			},
+			{
+				name: 'mysite/images/logo.png',
+				content: Buffer.from([0x89, 0x50, 0x4e, 0x47]),
+				mimeType: 'image/png',
+				size: 4
+			}
+		]
+
+		const result = processUploadedFiles(files)
+
+		expect(result.fileCount).toBe(4)
+		expect(result.directory.entries).toHaveLength(3) // index.html, _astro/, images/
+
+		// Check _astro directory exists
+		const astroEntry = result.directory.entries.find(e => e.name === '_astro')
+		expect(astroEntry).toBeTruthy()
+		expect('type' in astroEntry!.node && astroEntry!.node.type).toBe('directory')
+		
+		if ('entries' in astroEntry!.node) {
+			const astroDir = astroEntry!.node
+			expect(astroDir.entries).toHaveLength(2) // main.js, styles.css
+			expect(astroDir.entries.find(e => e.name === 'main.js')).toBeTruthy()
+			expect(astroDir.entries.find(e => e.name === 'styles.css')).toBeTruthy()
+		}
+
+		// Check images directory exists
+		const imagesEntry = result.directory.entries.find(e => e.name === 'images')
+		expect(imagesEntry).toBeTruthy()
+		expect('type' in imagesEntry!.node && imagesEntry!.node.type).toBe('directory')
+		
+		if ('entries' in imagesEntry!.node) {
+			const imagesDir = imagesEntry!.node
+			expect(imagesDir.entries).toHaveLength(1) // logo.png
+			expect(imagesDir.entries.find(e => e.name === 'logo.png')).toBeTruthy()
+		}
+	})
+
+	test('should handle deeply nested directories', () => {
+		const files: UploadedFile[] = [
+			{
+				name: 'site/a/b/c/d/deep.txt',
+				content: Buffer.from('deep'),
+				mimeType: 'text/plain',
+				size: 4
+			}
+		]
+
+		const result = processUploadedFiles(files)
+
+		expect(result.fileCount).toBe(1)
+
+		// Navigate through nested structure
+		const aEntry = result.directory.entries.find(e => e.name === 'a')
+		expect(aEntry).toBeTruthy()
+		expect('type' in aEntry!.node && aEntry!.node.type).toBe('directory')
+
+		if ('entries' in aEntry!.node) {
+			const bEntry = aEntry!.node.entries.find(e => e.name === 'b')
+			expect(bEntry).toBeTruthy()
+			expect('type' in bEntry!.node && bEntry!.node.type).toBe('directory')
+
+			if ('entries' in bEntry!.node) {
+				const cEntry = bEntry!.node.entries.find(e => e.name === 'c')
+				expect(cEntry).toBeTruthy()
+				expect('type' in cEntry!.node && cEntry!.node.type).toBe('directory')
+
+				if ('entries' in cEntry!.node) {
+					const dEntry = cEntry!.node.entries.find(e => e.name === 'd')
+					expect(dEntry).toBeTruthy()
+					expect('type' in dEntry!.node && dEntry!.node.type).toBe('directory')
+
+					if ('entries' in dEntry!.node) {
+						const fileEntry = dEntry!.node.entries.find(e => e.name === 'deep.txt')
+						expect(fileEntry).toBeTruthy()
+						expect('type' in fileEntry!.node && fileEntry!.node.type).toBe('file')
+					}
+				}
+			}
+		}
+	})
+
+	test('should handle files at root level', () => {
+		const files: UploadedFile[] = [
+			{
+				name: 'mysite/index.html',
+				content: Buffer.from('<html>'),
+				mimeType: 'text/html',
+				size: 6
+			},
+			{
+				name: 'mysite/robots.txt',
+				content: Buffer.from('User-agent: *'),
+				mimeType: 'text/plain',
+				size: 13
+			}
+		]
+
+		const result = processUploadedFiles(files)
+
+		expect(result.fileCount).toBe(2)
+		expect(result.directory.entries).toHaveLength(2)
+		expect(result.directory.entries.find(e => e.name === 'index.html')).toBeTruthy()
+		expect(result.directory.entries.find(e => e.name === 'robots.txt')).toBeTruthy()
+	})
+
+	test('should skip .git directories', () => {
+		const files: UploadedFile[] = [
+			{
+				name: 'mysite/index.html',
+				content: Buffer.from('<html>'),
+				mimeType: 'text/html',
+				size: 6
+			},
+			{
+				name: 'mysite/.git/config',
+				content: Buffer.from('[core]'),
+				mimeType: 'text/plain',
+				size: 6
+			},
+			{
+				name: 'mysite/.gitignore',
+				content: Buffer.from('node_modules'),
+				mimeType: 'text/plain',
+				size: 12
+			}
+		]
+
+		const result = processUploadedFiles(files)
+
+		expect(result.fileCount).toBe(2) // Only index.html and .gitignore
+		expect(result.directory.entries).toHaveLength(2)
+		expect(result.directory.entries.find(e => e.name === 'index.html')).toBeTruthy()
+		expect(result.directory.entries.find(e => e.name === '.gitignore')).toBeTruthy()
+		expect(result.directory.entries.find(e => e.name === '.git')).toBeFalsy()
+	})
+
+	test('should handle mixed root and nested files', () => {
+		const files: UploadedFile[] = [
+			{
+				name: 'mysite/index.html',
+				content: Buffer.from('<html>'),
+				mimeType: 'text/html',
+				size: 6
+			},
+			{
+				name: 'mysite/about/index.html',
+				content: Buffer.from('<html>'),
+				mimeType: 'text/html',
+				size: 6
+			},
+			{
+				name: 'mysite/about/team.html',
+				content: Buffer.from('<html>'),
+				mimeType: 'text/html',
+				size: 6
+			},
+			{
+				name: 'mysite/robots.txt',
+				content: Buffer.from('User-agent: *'),
+				mimeType: 'text/plain',
+				size: 13
+			}
+		]
+
+		const result = processUploadedFiles(files)
+
+		expect(result.fileCount).toBe(4)
+		expect(result.directory.entries).toHaveLength(3) // index.html, about/, robots.txt
+
+		const aboutEntry = result.directory.entries.find(e => e.name === 'about')
+		expect(aboutEntry).toBeTruthy()
+		expect('type' in aboutEntry!.node && aboutEntry!.node.type).toBe('directory')
+		
+		if ('entries' in aboutEntry!.node) {
+			const aboutDir = aboutEntry!.node
+			expect(aboutDir.entries).toHaveLength(2) // index.html, team.html
+			expect(aboutDir.entries.find(e => e.name === 'index.html')).toBeTruthy()
+			expect(aboutDir.entries.find(e => e.name === 'team.html')).toBeTruthy()
+		}
+	})
+
+	test('should handle empty file array', () => {
+		const files: UploadedFile[] = []
+
+		const result = processUploadedFiles(files)
+
+		expect(result.fileCount).toBe(0)
+		expect(result.directory.entries).toHaveLength(0)
+	})
+
+	test('should strip base folder name from paths', () => {
+		// This tests the behavior where file.name includes the base folder
+		// e.g., "mysite/index.html" should become "index.html" at root
+		const files: UploadedFile[] = [
+			{
+				name: 'build-output/index.html',
+				content: Buffer.from('<html>'),
+				mimeType: 'text/html',
+				size: 6
+			},
+			{
+				name: 'build-output/assets/main.js',
+				content: Buffer.from('console.log()'),
+				mimeType: 'application/javascript',
+				size: 13
+			}
+		]
+
+		const result = processUploadedFiles(files)
+
+		expect(result.fileCount).toBe(2)
+		
+		// Should have index.html at root and assets/ directory
+		expect(result.directory.entries.find(e => e.name === 'index.html')).toBeTruthy()
+		expect(result.directory.entries.find(e => e.name === 'assets')).toBeTruthy()
+		
+		// Should NOT have 'build-output' directory
+		expect(result.directory.entries.find(e => e.name === 'build-output')).toBeFalsy()
+	})
+})

tsconfig.json

···
 		// "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
 		// "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
 		"types": [
-			"bun-types"
+			"bun"
 		] /* Specify type package names to be included without being referenced in a source file. */,
 		// "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
 		// "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */