playcademy 0.13.16 → 0.13.17

package/dist/index.js

@@ -8840,16 +8840,18 @@ function setupCleanupHandlers(workspace, getServer) {
 async function setupServerHotReload(serverRef, port, workspace, config, loggerEnabled) {
   return startHotReload(
     async () => {
-      if (serverRef.current) {
-        await serverRef.current.dispose();
-      }
       const newConfig = await loadConfig();
-      const { server } = await startDevServer({
+      await bundleBackend(newConfig, { sourcemap: false, minify: false });
+      const oldServer = serverRef.current;
+      if (oldServer) {
+        await oldServer.dispose();
+      }
+      const { server: newServer } = await startDevServer({
         port,
         config: newConfig,
         logger: loggerEnabled
       });
-      serverRef.current = server;
+      serverRef.current = newServer;
       await discoverRoutes(getCustomRoutesDirectory(workspace, newConfig));
     },
     { config }

package/dist/templates/api/sample-bucket.ts.template

@@ -4,42 +4,35 @@
  * This route will be available at: https://<your-game-slug>.playcademy.gg/api/sample/bucket
  */
 
-/**
- * File metadata for bucket storage
- */
+import type { Context } from 'hono'
+
 interface FileInfo {
-    /** File key in bucket */
     key: string
-    /** File size in bytes */
+    name: string
     size: number
-    /** Upload timestamp */
     uploaded: string
+    extension: string
 }
 
 /**
  * GET /api/sample/bucket
  *
- * List or retrieve files from bucket storage
+ * List all files or retrieve a specific file by key
+ * Query params:
+ *   - key: File key to download (optional)
+ *   - prefix: Filter files by prefix (optional)
  */
 export async function GET(c: Context): Promise<Response> {
     try {
         const fileKey = c.req.query('key')
 
-        // If key provided, get specific file
         if (fileKey) {
             const object = await c.env.BUCKET.get(fileKey)
 
             if (!object) {
-                return c.json(
-                    {
-                        success: false,
-                        error: 'File not found',
-                    },
-                    404,
-                )
+                return c.json({ success: false, error: 'File not found' }, 404)
             }
 
-            // Return file with appropriate headers
             return new Response(object.body, {
                 headers: {
                     'Content-Type': object.httpMetadata?.contentType || 'application/octet-stream',
@@ -49,28 +42,28 @@ export async function GET(c: Context): Promise<Response> {
             })
         }
 
-        // Otherwise, list files
         const prefix = c.req.query('prefix') || ''
         const listed = await c.env.BUCKET.list({ prefix })
 
-        const files: FileInfo[] = listed.objects.map(obj => ({
-            key: obj.key,
-            size: obj.size,
-            uploaded: obj.uploaded.toISOString(),
-        }))
+        const files: FileInfo[] = (listed.objects as Array<{ key: string; size: number; uploaded: Date }>).map(obj => {
+            const fileName = obj.key.split('/').pop() || obj.key
+            const extensionMatch = fileName.match(/\.([^.]+)$/)
+            return {
+                key: obj.key,
+                name: fileName,
+                size: obj.size,
+                uploaded: obj.uploaded.toISOString(),
+                extension: extensionMatch?.[1]?.toLowerCase() || 'unknown',
+            }
+        })
 
         return c.json({
             success: true,
-            data: files,
-            truncated: listed.truncated,
+            data: { files, total: files.length, truncated: listed.truncated },
         })
     } catch (error) {
         return c.json(
-            {
-                success: false,
-                error: 'Failed to access bucket storage',
-                details: error instanceof Error ? error.message : String(error),
-            },
+            { success: false, error: 'Failed to list files', details: error instanceof Error ? error.message : 'Unknown error' },
             500,
         )
     }
@@ -80,60 +73,60 @@ export async function GET(c: Context): Promise<Response> {
  * PUT /api/sample/bucket
  *
  * Upload a file to bucket storage
+ * Query params:
+ *   - name: File name (required)
  */
 export async function PUT(c: Context): Promise<Response> {
     try {
-        const fileKey = c.req.query('key')
-
-        if (!fileKey) {
-            return c.json(
-                {
-                    success: false,
-                    error: 'File key is required',
-                },
-                400,
-            )
+        const fileName = c.req.query('name')
+        if (!fileName) {
+            return c.json({ success: false, error: 'name query param is required' }, 400)
         }
 
-        // Get file from request body
         const body = await c.req.arrayBuffer()
-
         if (!body || body.byteLength === 0) {
-            return c.json(
-                {
-                    success: false,
-                    error: 'File body is required',
-                },
-                400,
-            )
+            return c.json({ success: false, error: 'File body is required' }, 400)
         }
 
-        // Get content type from header or default to binary
-        const contentType = c.req.header('Content-Type') || 'application/octet-stream'
+        // Validate file size (10MB limit)
+        const maxSize = 10 * 1024 * 1024
+        if (body.byteLength > maxSize) {
+            return c.json({ success: false, error: `File exceeds ${maxSize / 1024 / 1024}MB limit` }, 400)
+        }
 
-        // Upload to bucket
-        await c.env.BUCKET.put(fileKey, body, {
-            httpMetadata: {
-                contentType,
-            },
-        })
+        // Sanitize name and create key with timestamp
+        const safeName = fileName.replace(/[^a-zA-Z0-9._-]/g, '_')
+        const fileKey = `uploads/${Date.now()}-${safeName}`
+
+        // Map extension to content-type
+        const extension = safeName.split('.').pop()?.toLowerCase() || ''
+        const contentTypeMap: Record<string, string> = {
+            jpg: 'image/jpeg',
+            jpeg: 'image/jpeg',
+            png: 'image/png',
+            gif: 'image/gif',
+            webp: 'image/webp',
+            pdf: 'application/pdf',
+            txt: 'text/plain',
+            json: 'application/json',
+        }
+        const contentType = contentTypeMap[extension] || c.req.header('Content-Type') || 'application/octet-stream'
+
+        await c.env.BUCKET.put(fileKey, body, { httpMetadata: { contentType } })
 
         return c.json({
             success: true,
             data: {
                 key: fileKey,
+                name: safeName,
                 size: body.byteLength,
                 uploaded: new Date().toISOString(),
+                extension: extension || 'unknown',
             },
-            message: 'File uploaded successfully',
         })
     } catch (error) {
         return c.json(
-            {
-                success: false,
-                error: 'Failed to upload file',
-                details: error instanceof Error ? error.message : String(error),
-            },
+            { success: false, error: 'Failed to upload file', details: error instanceof Error ? error.message : 'Unknown error' },
             500,
         )
     }
@@ -143,35 +136,22 @@ export async function PUT(c: Context): Promise<Response> {
  * DELETE /api/sample/bucket
  *
  * Delete a file from bucket storage
+ * Query params:
+ *   - key: File key to delete (required)
  */
 export async function DELETE(c: Context): Promise<Response> {
     try {
         const fileKey = c.req.query('key')
 
         if (!fileKey) {
-            return c.json(
-                {
-                    success: false,
-                    error: 'File key is required',
-                },
-                400,
-            )
+            return c.json({ success: false, error: 'key query param is required' }, 400)
         }
 
-        // Delete from bucket
         await c.env.BUCKET.delete(fileKey)
-
-        return c.json({
-            success: true,
-            message: 'File deleted successfully',
-        })
+        return c.json({ success: true, message: 'File deleted successfully' })
     } catch (error) {
         return c.json(
-            {
-                success: false,
-                error: 'Failed to delete file',
-                details: error instanceof Error ? error.message : String(error),
-            },
+            { success: false, error: 'Failed to delete file', details: error instanceof Error ? error.message : 'Unknown error' },
             500,
         )
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "playcademy",
-    "version": "0.13.16",
+    "version": "0.13.17",
     "type": "module",
     "module": "./dist/index.js",
     "main": "./dist/index.js",
@@ -40,7 +40,7 @@
     },
     "dependencies": {
         "@inquirer/prompts": "^7.8.6",
-        "@playcademy/sdk": "0.1.6",
+        "@playcademy/sdk": "0.1.7",
         "better-sqlite3": "^12.4.1",
         "chokidar": "^4.0.3",
         "colorette": "^2.0.20",