@gallop.software/studio 1.5.9 → 2.0.0

package/dist/handlers/index.mjs

@@ -10,13 +10,36 @@ import { NextResponse as NextResponse6 } from "next/server";
 // src/handlers/list.ts
 import { NextResponse } from "next/server";
 import { promises as fs4 } from "fs";
-import path5 from "path";
+import path4 from "path";
 
 // src/handlers/utils/meta.ts
 import { promises as fs } from "fs";
+
+// src/config/workspace.ts
 import path from "path";
+var workspacePath = null;
+function getWorkspace() {
+  if (workspacePath === null) {
+    workspacePath = process.env.STUDIO_WORKSPACE || process.cwd();
+  }
+  return workspacePath;
+}
+function getPublicPath(...segments) {
+  return path.join(getWorkspace(), "public", ...segments);
+}
+function getDataPath(...segments) {
+  return path.join(getWorkspace(), "_data", ...segments);
+}
+function getSrcAppPath(...segments) {
+  return path.join(getWorkspace(), "src", "app", ...segments);
+}
+function getWorkspacePath(...segments) {
+  return path.join(getWorkspace(), ...segments);
+}
+
+// src/handlers/utils/meta.ts
 async function loadMeta() {
-  const metaPath = path.join(process.cwd(), "_data", "_studio.json");
+  const metaPath = getDataPath("_studio.json");
   try {
     const content = await fs.readFile(metaPath, "utf-8");
     return JSON.parse(content);
@@ -25,9 +48,9 @@ async function loadMeta() {
   }
 }
 async function saveMeta(meta) {
-  const dataDir = path.join(process.cwd(), "_data");
+  const dataDir = getDataPath();
   await fs.mkdir(dataDir, { recursive: true });
-  const metaPath = path.join(dataDir, "_studio.json");
+  const metaPath = getDataPath("_studio.json");
   const ordered = {};
   if (meta._cdns) {
     ordered._cdns = meta._cdns;
@@ -123,7 +146,7 @@ async function processImage(buffer, imageKey) {
   const baseName = path3.basename(keyWithoutSlash, path3.extname(keyWithoutSlash));
   const ext = path3.extname(keyWithoutSlash).toLowerCase();
   const imageDir = path3.dirname(keyWithoutSlash);
-  const imagesPath = path3.join(process.cwd(), "public", "images", imageDir === "." ? "" : imageDir);
+  const imagesPath = getPublicPath("images", imageDir === "." ? "" : imageDir);
   await fs2.mkdir(imagesPath, { recursive: true });
   const isPng = ext === ".png";
   const outputExt = isPng ? ".png" : ".jpg";
@@ -131,7 +154,7 @@ async function processImage(buffer, imageKey) {
     o: { w: originalWidth, h: originalHeight }
   };
   const fullFileName = imageDir === "." ? `${baseName}${outputExt}` : `${imageDir}/${baseName}${outputExt}`;
-  const fullPath = path3.join(process.cwd(), "public", "images", fullFileName);
+  const fullPath = getPublicPath("images", fullFileName);
   let fullWidth = originalWidth;
   let fullHeight = originalHeight;
   if (originalWidth > FULL_MAX_WIDTH) {
@@ -158,7 +181,7 @@ async function processImage(buffer, imageKey) {
     const newHeight = Math.round(maxWidth * ratio);
     const sizeFileName = `${baseName}${suffix}${outputExt}`;
     const sizeFilePath = imageDir === "." ? sizeFileName : `${imageDir}/${sizeFileName}`;
-    const sizePath = path3.join(process.cwd(), "public", "images", sizeFilePath);
+    const sizePath = getPublicPath("images", sizeFilePath);
     if (isPng) {
       await sharp(buffer).resize(maxWidth, newHeight).png({ quality: 80 }).toFile(sizePath);
     } else {
@@ -173,7 +196,6 @@ async function processImage(buffer, imageKey) {
 
 // src/handlers/utils/cdn.ts
 import { promises as fs3 } from "fs";
-import path4 from "path";
 import { S3Client, GetObjectCommand, PutObjectCommand, DeleteObjectCommand } from "@aws-sdk/client-s3";
 async function purgeCloudflareCache(urls) {
   const zoneId = process.env.CLOUDFLARE_ZONE_ID;
@@ -247,7 +269,7 @@ async function uploadToCdn(imageKey) {
   if (!bucketName) throw new Error("R2 bucket not configured");
   const r2 = getR2Client();
   for (const thumbPath of getAllThumbnailPaths(imageKey)) {
-    const localPath = path4.join(process.cwd(), "public", thumbPath);
+    const localPath = getPublicPath(thumbPath);
     try {
       const fileBuffer = await fs3.readFile(localPath);
       await r2.send(
@@ -264,7 +286,7 @@ async function uploadToCdn(imageKey) {
 }
 async function deleteLocalThumbnails(imageKey) {
   for (const thumbPath of getAllThumbnailPaths(imageKey)) {
-    const localPath = path4.join(process.cwd(), "public", thumbPath);
+    const localPath = getPublicPath(thumbPath);
     try {
       await fs3.unlink(localPath);
     } catch {
@@ -295,7 +317,7 @@ async function uploadOriginalToCdn(imageKey) {
   const bucketName = process.env.CLOUDFLARE_R2_BUCKET_NAME;
   if (!bucketName) throw new Error("R2 bucket not configured");
   const r2 = getR2Client();
-  const localPath = path4.join(process.cwd(), "public", imageKey);
+  const localPath = getPublicPath(imageKey);
   const fileBuffer = await fs3.readFile(localPath);
   await r2.send(
     new PutObjectCommand({
@@ -495,7 +517,7 @@ async function handleList(request) {
       }
       return NextResponse.json({ items });
     }
-    const absoluteDir = path5.join(process.cwd(), requestedPath);
+    const absoluteDir = getWorkspacePath(requestedPath);
     try {
       const dirEntries = await fs4.readdir(absoluteDir, { withFileTypes: true });
       for (const entry of dirEntries) {
@@ -606,7 +628,7 @@ async function handleList(request) {
               hasThumbnail = true;
             }
           } else {
-            const localThumbPath = path5.join(process.cwd(), "public", thumbPath);
+            const localThumbPath = getPublicPath(thumbPath);
             try {
               await fs4.access(localThumbPath);
               thumbnail = thumbPath;
@@ -627,7 +649,7 @@ async function handleList(request) {
         }
         if (!isPushedToCloud) {
           try {
-            const filePath = path5.join(process.cwd(), "public", key);
+            const filePath = getPublicPath(key);
             const stats = await fs4.stat(filePath);
             fileSize = stats.size;
           } catch {
@@ -669,7 +691,7 @@ async function handleSearch(request) {
     const items = [];
     for (const [key, entry] of fileEntries) {
       if (!key.toLowerCase().includes(query)) continue;
-      const fileName = path5.basename(key);
+      const fileName = path4.basename(key);
       const relativePath = key.slice(1);
       const isImage = isImageFile(fileName);
       const isPushedToCloud = entry.c !== void 0;
@@ -687,7 +709,7 @@ async function handleSearch(request) {
             hasThumbnail = true;
           }
         } else {
-          const localThumbPath = path5.join(process.cwd(), "public", thumbPath);
+          const localThumbPath = getPublicPath(thumbPath);
           try {
             await fs4.access(localThumbPath);
             thumbnail = thumbPath;
@@ -745,13 +767,13 @@ async function handleListFolders() {
           if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "images") {
             const folderRelPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
             folderSet.add(folderRelPath);
-            await scanDir(path5.join(dir, entry.name), folderRelPath);
+            await scanDir(path4.join(dir, entry.name), folderRelPath);
           }
         }
       } catch {
       }
     }
-    const publicDir = path5.join(process.cwd(), "public");
+    const publicDir = getPublicPath();
     await scanDir(publicDir, "");
     const folders = [];
     folders.push({ path: "public", name: "public", depth: 0 });
@@ -777,7 +799,7 @@ async function handleCountImages() {
     const fileEntries = getFileEntries(meta);
     const allImages = [];
     for (const [key] of fileEntries) {
-      const fileName = path5.basename(key);
+      const fileName = path4.basename(key);
       if (isImageFile(fileName)) {
         allImages.push(key.slice(1));
       }
@@ -801,35 +823,34 @@ async function handleFolderImages(request) {
     const folders = foldersParam.split(",");
     const meta = await loadMeta();
     const fileEntries = getFileEntries(meta);
-    const allImages = [];
+    const allFiles = [];
     const prefixes = folders.map((f) => {
       const rel = f.replace(/^public\/?/, "");
       return rel ? `/${rel}/` : "/";
     });
     for (const [key] of fileEntries) {
-      const fileName = path5.basename(key);
-      if (!isImageFile(fileName)) continue;
       for (const prefix of prefixes) {
         if (key.startsWith(prefix) || prefix === "/" && key.startsWith("/")) {
-          allImages.push(key.slice(1));
+          allFiles.push(key.slice(1));
           break;
         }
       }
     }
     return NextResponse.json({
-      count: allImages.length,
-      images: allImages
+      count: allFiles.length,
+      images: allFiles
+      // Keep as 'images' for backwards compatibility
     });
   } catch (error) {
-    console.error("Failed to get folder images:", error);
-    return NextResponse.json({ error: "Failed to get folder images" }, { status: 500 });
+    console.error("Failed to get folder files:", error);
+    return NextResponse.json({ error: "Failed to get folder files" }, { status: 500 });
   }
 }
 
 // src/handlers/files.ts
 import { NextResponse as NextResponse2 } from "next/server";
 import { promises as fs5 } from "fs";
-import path6 from "path";
+import path5 from "path";
 import sharp2 from "sharp";
 async function handleUpload(request) {
   try {
@@ -842,7 +863,7 @@ async function handleUpload(request) {
     const bytes = await file.arrayBuffer();
     const buffer = Buffer.from(bytes);
     const fileName = file.name;
-    const ext = path6.extname(fileName).toLowerCase();
+    const ext = path5.extname(fileName).toLowerCase();
     const isImage = isImageFile(fileName);
     const isMedia = isMediaFile(fileName);
     const meta = await loadMeta();
@@ -860,7 +881,7 @@ async function handleUpload(request) {
     }
     let imageKey = "/" + (relativeDir ? `${relativeDir}/${fileName}` : fileName);
     if (meta[imageKey]) {
-      const baseName = path6.basename(fileName, ext);
+      const baseName = path5.basename(fileName, ext);
       let counter = 1;
       let newFileName = `${baseName}-${counter}${ext}`;
       let newKey = "/" + (relativeDir ? `${relativeDir}/${newFileName}` : newFileName);
@@ -871,10 +892,10 @@ async function handleUpload(request) {
       }
       imageKey = newKey;
     }
-    const actualFileName = path6.basename(imageKey);
-    const uploadDir = path6.join(process.cwd(), "public", relativeDir);
+    const actualFileName = path5.basename(imageKey);
+    const uploadDir = getPublicPath(relativeDir);
     await fs5.mkdir(uploadDir, { recursive: true });
-    await fs5.writeFile(path6.join(uploadDir, actualFileName), buffer);
+    await fs5.writeFile(path5.join(uploadDir, actualFileName), buffer);
     if (!isMedia) {
       return NextResponse2.json({
         success: true,
@@ -921,7 +942,7 @@ async function handleDelete(request) {
           errors.push(`Invalid path: ${itemPath}`);
           continue;
         }
-        const absolutePath = path6.join(process.cwd(), itemPath);
+        const absolutePath = getWorkspacePath(itemPath);
         const imageKey = "/" + itemPath.replace(/^public\//, "");
         const entry = meta[imageKey];
         const isPushedToCloud = entry?.c !== void 0;
@@ -935,7 +956,7 @@ async function handleDelete(request) {
                 const keyEntry = meta[key];
                 if (keyEntry && keyEntry.c === void 0) {
                   for (const thumbPath of getAllThumbnailPaths(key)) {
-                    const absoluteThumbPath = path6.join(process.cwd(), "public", thumbPath);
+                    const absoluteThumbPath = getPublicPath(thumbPath);
                     try {
                       await fs5.unlink(absoluteThumbPath);
                     } catch {
@@ -951,7 +972,7 @@ async function handleDelete(request) {
             if (!isInImagesFolder && entry) {
               if (!isPushedToCloud) {
                 for (const thumbPath of getAllThumbnailPaths(imageKey)) {
-                  const absoluteThumbPath = path6.join(process.cwd(), "public", thumbPath);
+                  const absoluteThumbPath = getPublicPath(thumbPath);
                   try {
                     await fs5.unlink(absoluteThumbPath);
                   } catch {
@@ -1007,8 +1028,8 @@ async function handleCreateFolder(request) {
       return NextResponse2.json({ error: "Invalid folder name" }, { status: 400 });
     }
     const safePath = (parentPath || "public").replace(/\.\./g, "");
-    const folderPath = path6.join(process.cwd(), safePath, sanitizedName);
-    if (!folderPath.startsWith(path6.join(process.cwd(), "public"))) {
+    const folderPath = getWorkspacePath(safePath, sanitizedName);
+    if (!folderPath.startsWith(getPublicPath())) {
       return NextResponse2.json({ error: "Invalid path" }, { status: 400 });
     }
     try {
@@ -1017,7 +1038,7 @@ async function handleCreateFolder(request) {
     } catch {
     }
     await fs5.mkdir(folderPath, { recursive: true });
-    return NextResponse2.json({ success: true, path: path6.join(safePath, sanitizedName) });
+    return NextResponse2.json({ success: true, path: path5.join(safePath, sanitizedName) });
   } catch (error) {
     console.error("Failed to create folder:", error);
     return NextResponse2.json({ error: "Failed to create folder" }, { status: 500 });
@@ -1034,10 +1055,10 @@ async function handleRename(request) {
       return NextResponse2.json({ error: "Invalid name" }, { status: 400 });
     }
     const safePath = oldPath.replace(/\.\./g, "");
-    const absoluteOldPath = path6.join(process.cwd(), safePath);
-    const parentDir = path6.dirname(absoluteOldPath);
-    const absoluteNewPath = path6.join(parentDir, sanitizedName);
-    if (!absoluteOldPath.startsWith(path6.join(process.cwd(), "public"))) {
+    const absoluteOldPath = getWorkspacePath(safePath);
+    const parentDir = path5.dirname(absoluteOldPath);
+    const absoluteNewPath = path5.join(parentDir, sanitizedName);
+    if (!absoluteOldPath.startsWith(getPublicPath())) {
       return NextResponse2.json({ error: "Invalid path" }, { status: 400 });
     }
     try {
@@ -1052,12 +1073,12 @@ async function handleRename(request) {
     }
     const stats = await fs5.stat(absoluteOldPath);
     const isFile = stats.isFile();
-    const isImage = isFile && isImageFile(path6.basename(oldPath));
+    const isImage = isFile && isImageFile(path5.basename(oldPath));
     await fs5.rename(absoluteOldPath, absoluteNewPath);
     if (isImage) {
       const meta = await loadMeta();
       const oldRelativePath = safePath.replace(/^public\//, "");
-      const newRelativePath = path6.join(path6.dirname(oldRelativePath), sanitizedName);
+      const newRelativePath = path5.join(path5.dirname(oldRelativePath), sanitizedName);
       const oldKey = "/" + oldRelativePath;
       const newKey = "/" + newRelativePath;
       if (meta[oldKey]) {
@@ -1065,9 +1086,9 @@ async function handleRename(request) {
         const oldThumbPaths = getAllThumbnailPaths(oldKey);
         const newThumbPaths = getAllThumbnailPaths(newKey);
         for (let i = 0; i < oldThumbPaths.length; i++) {
-          const oldThumbPath = path6.join(process.cwd(), "public", oldThumbPaths[i]);
-          const newThumbPath = path6.join(process.cwd(), "public", newThumbPaths[i]);
-          await fs5.mkdir(path6.dirname(newThumbPath), { recursive: true });
+          const oldThumbPath = getPublicPath(oldThumbPaths[i]);
+          const newThumbPath = getPublicPath(newThumbPaths[i]);
+          await fs5.mkdir(path5.dirname(newThumbPath), { recursive: true });
           try {
             await fs5.rename(oldThumbPath, newThumbPath);
           } catch {
@@ -1078,7 +1099,7 @@ async function handleRename(request) {
       }
       await saveMeta(meta);
     }
-    const newPath = path6.join(path6.dirname(safePath), sanitizedName);
+    const newPath = path5.join(path5.dirname(safePath), sanitizedName);
     return NextResponse2.json({ success: true, newPath });
   } catch (error) {
     console.error("Failed to rename:", error);
@@ -1107,8 +1128,8 @@ async function handleMoveStream(request) {
           return;
         }
         const safeDestination = destination.replace(/\.\./g, "");
-        const absoluteDestination = path6.join(process.cwd(), safeDestination);
-        if (!absoluteDestination.startsWith(path6.join(process.cwd(), "public"))) {
+        const absoluteDestination = getWorkspacePath(safeDestination);
+        if (!absoluteDestination.startsWith(getPublicPath())) {
           sendEvent({ type: "error", message: "Invalid destination" });
           controller.close();
           return;
@@ -1124,10 +1145,10 @@ async function handleMoveStream(request) {
         for (let i = 0; i < paths.length; i++) {
           const itemPath = paths[i];
           const safePath = itemPath.replace(/\.\./g, "");
-          const itemName = path6.basename(safePath);
-          const newAbsolutePath = path6.join(absoluteDestination, itemName);
+          const itemName = path5.basename(safePath);
+          const newAbsolutePath = path5.join(absoluteDestination, itemName);
           const oldRelativePath = safePath.replace(/^public\//, "");
-          const newRelativePath = path6.join(safeDestination.replace(/^public\//, ""), itemName);
+          const newRelativePath = path5.join(safeDestination.replace(/^public\//, ""), itemName);
           const oldKey = "/" + oldRelativePath;
           const newKey = "/" + newRelativePath;
           sendEvent({
@@ -1152,7 +1173,7 @@ async function handleMoveStream(request) {
             if (isRemote && isImage) {
               const remoteUrl = `${fileCdnUrl}${oldKey}`;
               const buffer = await downloadFromRemoteUrl(remoteUrl);
-              await fs5.mkdir(path6.dirname(newAbsolutePath), { recursive: true });
+              await fs5.mkdir(path5.dirname(newAbsolutePath), { recursive: true });
               await fs5.writeFile(newAbsolutePath, buffer);
               const newEntry = {
                 o: entry?.o,
@@ -1163,7 +1184,7 @@ async function handleMoveStream(request) {
               moved.push(itemPath);
             } else if (isPushedToR2 && isImage) {
               const buffer = await downloadFromCdn(oldKey);
-              await fs5.mkdir(path6.dirname(newAbsolutePath), { recursive: true });
+              await fs5.mkdir(path5.dirname(newAbsolutePath), { recursive: true });
               await fs5.writeFile(newAbsolutePath, buffer);
               let newEntry = {
                 o: entry?.o,
@@ -1190,8 +1211,8 @@ async function handleMoveStream(request) {
               meta[newKey] = newEntry;
               moved.push(itemPath);
             } else {
-              const absolutePath = path6.join(process.cwd(), safePath);
-              if (absoluteDestination.startsWith(absolutePath + path6.sep)) {
+              const absolutePath = getWorkspacePath(safePath);
+              if (absoluteDestination.startsWith(absolutePath + path5.sep)) {
                 errors.push(`Cannot move ${itemName} into itself`);
                 continue;
               }
@@ -1213,9 +1234,9 @@ async function handleMoveStream(request) {
                 const oldThumbPaths = getAllThumbnailPaths(oldKey);
                 const newThumbPaths = getAllThumbnailPaths(newKey);
                 for (let j = 0; j < oldThumbPaths.length; j++) {
-                  const oldThumbPath = path6.join(process.cwd(), "public", oldThumbPaths[j]);
-                  const newThumbPath = path6.join(process.cwd(), "public", newThumbPaths[j]);
-                  await fs5.mkdir(path6.dirname(newThumbPath), { recursive: true });
+                  const oldThumbPath = getPublicPath(oldThumbPaths[j]);
+                  const newThumbPath = getPublicPath(newThumbPaths[j]);
+                  await fs5.mkdir(path5.dirname(newThumbPath), { recursive: true });
                   try {
                     await fs5.rename(oldThumbPath, newThumbPath);
                   } catch {
@@ -1268,7 +1289,7 @@ async function handleMoveStream(request) {
 // src/handlers/images.ts
 import { NextResponse as NextResponse3 } from "next/server";
 import { promises as fs6 } from "fs";
-import path7 from "path";
+import path6 from "path";
 import { S3Client as S3Client2, PutObjectCommand as PutObjectCommand2 } from "@aws-sdk/client-s3";
 async function handleSync(request) {
   const accountId = process.env.CLOUDFLARE_R2_ACCOUNT_ID;
@@ -1320,7 +1341,7 @@ async function handleSync(request) {
           const remoteUrl = `${existingCdnUrl}${imageKey}`;
           originalBuffer = await downloadFromRemoteUrl(remoteUrl);
         } else {
-          const originalLocalPath = path7.join(process.cwd(), "public", imageKey);
+          const originalLocalPath = getPublicPath(imageKey);
           try {
             originalBuffer = await fs6.readFile(originalLocalPath);
           } catch {
@@ -1339,7 +1360,7 @@ async function handleSync(request) {
         urlsToPurge.push(`${publicUrl}${imageKey}`);
         if (!isRemote && isProcessed(entry)) {
           for (const thumbPath of getAllThumbnailPaths(imageKey)) {
-            const localPath = path7.join(process.cwd(), "public", thumbPath);
+            const localPath = getPublicPath(thumbPath);
             try {
               const fileBuffer = await fs6.readFile(localPath);
               await r2.send(
@@ -1357,9 +1378,9 @@ async function handleSync(request) {
         }
         entry.c = cdnIndex;
         if (!isRemote) {
-          const originalLocalPath = path7.join(process.cwd(), "public", imageKey);
+          const originalLocalPath = getPublicPath(imageKey);
           for (const thumbPath of getAllThumbnailPaths(imageKey)) {
-            const localPath = path7.join(process.cwd(), "public", thumbPath);
+            const localPath = getPublicPath(thumbPath);
             try {
               await fs6.unlink(localPath);
             } catch {
@@ -1413,19 +1434,19 @@ async function handleReprocess(request) {
         const existingCdnUrl = existingCdnIndex !== void 0 ? cdnUrls[existingCdnIndex] : void 0;
         const isInOurR2 = existingCdnUrl === publicUrl;
         const isRemote = existingCdnIndex !== void 0 && !isInOurR2;
-        const originalPath = path7.join(process.cwd(), "public", imageKey);
+        const originalPath = getPublicPath(imageKey);
         try {
           buffer = await fs6.readFile(originalPath);
         } catch {
           if (isInOurR2) {
             buffer = await downloadFromCdn(imageKey);
-            const dir = path7.dirname(originalPath);
+            const dir = path6.dirname(originalPath);
             await fs6.mkdir(dir, { recursive: true });
             await fs6.writeFile(originalPath, buffer);
           } else if (isRemote && existingCdnUrl) {
             const remoteUrl = `${existingCdnUrl}${imageKey}`;
             buffer = await downloadFromRemoteUrl(remoteUrl);
-            const dir = path7.dirname(originalPath);
+            const dir = path6.dirname(originalPath);
             await fs6.mkdir(dir, { recursive: true });
             await fs6.writeFile(originalPath, buffer);
           } else {
@@ -1623,33 +1644,33 @@ async function handleReprocessStream(request) {
             const existingCdnUrl = existingCdnIndex !== void 0 ? cdnUrls[existingCdnIndex] : void 0;
             const isInOurR2 = existingCdnUrl === publicUrl;
             const isRemote = existingCdnIndex !== void 0 && !isInOurR2;
-            const originalPath = path7.join(process.cwd(), "public", imageKey);
+            const originalPath = getPublicPath(imageKey);
             try {
               buffer = await fs6.readFile(originalPath);
             } catch {
               if (isInOurR2) {
                 buffer = await downloadFromCdn(imageKey);
-                const dir = path7.dirname(originalPath);
+                const dir = path6.dirname(originalPath);
                 await fs6.mkdir(dir, { recursive: true });
                 await fs6.writeFile(originalPath, buffer);
               } else if (isRemote && existingCdnUrl) {
                 const remoteUrl = `${existingCdnUrl}${imageKey}`;
                 buffer = await downloadFromRemoteUrl(remoteUrl);
-                const dir = path7.dirname(originalPath);
+                const dir = path6.dirname(originalPath);
                 await fs6.mkdir(dir, { recursive: true });
                 await fs6.writeFile(originalPath, buffer);
               } else {
                 throw new Error(`File not found: ${imageKey}`);
               }
             }
-            const ext = path7.extname(imageKey).toLowerCase();
+            const ext = path6.extname(imageKey).toLowerCase();
             const isSvg = ext === ".svg";
             if (isSvg) {
-              const imageDir = path7.dirname(imageKey.slice(1));
-              const imagesPath = path7.join(process.cwd(), "public", "images", imageDir === "." ? "" : imageDir);
+              const imageDir = path6.dirname(imageKey.slice(1));
+              const imagesPath = getPublicPath("images", imageDir === "." ? "" : imageDir);
               await fs6.mkdir(imagesPath, { recursive: true });
-              const fileName = path7.basename(imageKey);
-              const destPath = path7.join(imagesPath, fileName);
+              const fileName = path6.basename(imageKey);
+              const destPath = path6.join(imagesPath, fileName);
               await fs6.writeFile(destPath, buffer);
               meta[imageKey] = {
                 ...entry,
@@ -1734,7 +1755,7 @@ async function handleProcessAllStream() {
         let alreadyProcessed = 0;
         const imagesToProcess = [];
         for (const [key, entry] of getFileEntries(meta)) {
-          const fileName = path7.basename(key);
+          const fileName = path6.basename(key);
           if (!isImageFile(fileName)) continue;
           if (!isProcessed(entry)) {
             imagesToProcess.push({ key, entry });
@@ -1746,7 +1767,7 @@ async function handleProcessAllStream() {
         sendEvent({ type: "start", total });
         for (let i = 0; i < imagesToProcess.length; i++) {
           const { key, entry } = imagesToProcess[i];
-          const fullPath = path7.join(process.cwd(), "public", key);
+          const fullPath = getPublicPath(key);
           const existingCdnIndex = entry.c;
           const existingCdnUrl = existingCdnIndex !== void 0 ? cdnUrls[existingCdnIndex] : void 0;
           const isInOurR2 = existingCdnUrl === publicUrl;
@@ -1763,26 +1784,26 @@ async function handleProcessAllStream() {
             let buffer;
             if (isInOurR2) {
               buffer = await downloadFromCdn(key);
-              const dir = path7.dirname(fullPath);
+              const dir = path6.dirname(fullPath);
               await fs6.mkdir(dir, { recursive: true });
               await fs6.writeFile(fullPath, buffer);
             } else if (isRemote && existingCdnUrl) {
               const remoteUrl = `${existingCdnUrl}${key}`;
               buffer = await downloadFromRemoteUrl(remoteUrl);
-              const dir = path7.dirname(fullPath);
+              const dir = path6.dirname(fullPath);
               await fs6.mkdir(dir, { recursive: true });
               await fs6.writeFile(fullPath, buffer);
             } else {
               buffer = await fs6.readFile(fullPath);
             }
-            const ext = path7.extname(key).toLowerCase();
+            const ext = path6.extname(key).toLowerCase();
             const isSvg = ext === ".svg";
             if (isSvg) {
-              const imageDir = path7.dirname(key.slice(1));
-              const imagesPath = path7.join(process.cwd(), "public", "images", imageDir === "." ? "" : imageDir);
+              const imageDir = path6.dirname(key.slice(1));
+              const imagesPath = getPublicPath("images", imageDir === "." ? "" : imageDir);
               await fs6.mkdir(imagesPath, { recursive: true });
-              const fileName = path7.basename(key);
-              const destPath = path7.join(imagesPath, fileName);
+              const fileName = path6.basename(key);
+              const destPath = path6.join(imagesPath, fileName);
               await fs6.writeFile(destPath, buffer);
               meta[key] = {
                 ...entry,
@@ -1832,7 +1853,7 @@ async function handleProcessAllStream() {
             const entries = await fs6.readdir(dir, { withFileTypes: true });
             for (const fsEntry of entries) {
               if (fsEntry.name.startsWith(".")) continue;
-              const entryFullPath = path7.join(dir, fsEntry.name);
+              const entryFullPath = path6.join(dir, fsEntry.name);
               const relPath = relativePath ? `${relativePath}/${fsEntry.name}` : fsEntry.name;
               if (fsEntry.isDirectory()) {
                 await findOrphans(entryFullPath, relPath);
@@ -1851,7 +1872,7 @@ async function handleProcessAllStream() {
           } catch {
           }
         }
-        const imagesDir = path7.join(process.cwd(), "public", "images");
+        const imagesDir = getPublicPath("images");
         try {
           await findOrphans(imagesDir);
         } catch {
@@ -1862,7 +1883,7 @@ async function handleProcessAllStream() {
             let isEmpty = true;
             for (const fsEntry of entries) {
               if (fsEntry.isDirectory()) {
-                const subDirEmpty = await removeEmptyDirs(path7.join(dir, fsEntry.name));
+                const subDirEmpty = await removeEmptyDirs(path6.join(dir, fsEntry.name));
                 if (!subDirEmpty) isEmpty = false;
               } else {
                 isEmpty = false;
@@ -1941,8 +1962,8 @@ async function handleDownloadStream(request) {
           }
           try {
             const imageBuffer = await downloadFromCdn(imageKey);
-            const localPath = path7.join(process.cwd(), "public", imageKey.replace(/^\//, ""));
-            await fs6.mkdir(path7.dirname(localPath), { recursive: true });
+            const localPath = getPublicPath(imageKey.replace(/^\//, ""));
+            await fs6.mkdir(path6.dirname(localPath), { recursive: true });
             await fs6.writeFile(localPath, imageBuffer);
             await deleteThumbnailsFromCdn(imageKey);
             const wasProcessed = isProcessed(entry);
@@ -2007,7 +2028,7 @@ async function handleDownloadStream(request) {
 // src/handlers/scan.ts
 import { NextResponse as NextResponse4 } from "next/server";
 import { promises as fs7 } from "fs";
-import path8 from "path";
+import path7 from "path";
 import sharp3 from "sharp";
 import { encode as encode2 } from "blurhash";
 async function handleScanStream() {
@@ -2033,7 +2054,7 @@ async function handleScanStream() {
             const entries = await fs7.readdir(dir, { withFileTypes: true });
             for (const entry of entries) {
               if (entry.name.startsWith(".")) continue;
-              const fullPath = path8.join(dir, entry.name);
+              const fullPath = path7.join(dir, entry.name);
               const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
               if (relPath === "images" || relPath.startsWith("images/")) continue;
               if (entry.isDirectory()) {
@@ -2045,7 +2066,7 @@ async function handleScanStream() {
           } catch {
           }
         }
-        const publicDir = path8.join(process.cwd(), "public");
+        const publicDir = getPublicPath();
         await scanDir(publicDir);
         const total = allFiles.length;
         sendEvent({ type: "start", total });
@@ -2063,7 +2084,7 @@ async function handleScanStream() {
             continue;
           }
           if (meta[imageKey]) {
-            const ext = path8.extname(relativePath);
+            const ext = path7.extname(relativePath);
             const baseName = relativePath.slice(0, -ext.length);
             let counter = 1;
             let newKey = `/${baseName}-${counter}${ext}`;
@@ -2072,7 +2093,7 @@ async function handleScanStream() {
               newKey = `/${baseName}-${counter}${ext}`;
             }
             const newRelativePath = `${baseName}-${counter}${ext}`;
-            const newFullPath = path8.join(process.cwd(), "public", newRelativePath);
+            const newFullPath = getPublicPath(newRelativePath);
             try {
               await fs7.rename(fullPath, newFullPath);
               renamed.push({ from: relativePath, to: newRelativePath });
@@ -2088,7 +2109,7 @@ async function handleScanStream() {
           try {
             const isImage = isImageFile(relativePath);
             if (isImage) {
-              const ext = path8.extname(relativePath).toLowerCase();
+              const ext = path7.extname(relativePath).toLowerCase();
               if (ext === ".svg") {
                 meta[imageKey] = { o: { w: 0, h: 0 }, b: "" };
               } else {
@@ -2130,7 +2151,7 @@ async function handleScanStream() {
             const entries = await fs7.readdir(dir, { withFileTypes: true });
             for (const entry of entries) {
               if (entry.name.startsWith(".")) continue;
-              const fullPath = path8.join(dir, entry.name);
+              const fullPath = path7.join(dir, entry.name);
               const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
               if (entry.isDirectory()) {
                 await findOrphans(fullPath, relPath);
@@ -2144,7 +2165,7 @@ async function handleScanStream() {
           } catch {
           }
         }
-        const imagesDir = path8.join(process.cwd(), "public", "images");
+        const imagesDir = getPublicPath("images");
         try {
           await findOrphans(imagesDir);
         } catch {
@@ -2188,7 +2209,7 @@ async function handleDeleteOrphans(request) {
         errors.push(`Invalid path: ${orphanPath}`);
         continue;
       }
-      const fullPath = path8.join(process.cwd(), "public", orphanPath);
+      const fullPath = getPublicPath(orphanPath);
       try {
         await fs7.unlink(fullPath);
         deleted.push(orphanPath);
@@ -2197,14 +2218,14 @@ async function handleDeleteOrphans(request) {
         errors.push(orphanPath);
       }
     }
-    const imagesDir = path8.join(process.cwd(), "public", "images");
+    const imagesDir = getPublicPath("images");
     async function removeEmptyDirs(dir) {
       try {
         const entries = await fs7.readdir(dir, { withFileTypes: true });
         let isEmpty = true;
         for (const entry of entries) {
           if (entry.isDirectory()) {
-            const subDirEmpty = await removeEmptyDirs(path8.join(dir, entry.name));
+            const subDirEmpty = await removeEmptyDirs(path7.join(dir, entry.name));
             if (!subDirEmpty) isEmpty = false;
           } else {
             isEmpty = false;
@@ -2239,8 +2260,8 @@ import { encode as encode3 } from "blurhash";
 function parseImageUrl(url) {
   const parsed = new URL(url);
   const base = `${parsed.protocol}//${parsed.host}`;
-  const path10 = parsed.pathname;
-  return { base, path: path10 };
+  const path9 = parsed.pathname;
+  return { base, path: path9 };
 }
 async function processRemoteImage(url) {
   const response = await fetch(url);
@@ -2289,20 +2310,20 @@ async function handleImportUrls(request) {
             currentFile: url
           });
           try {
-            const { base, path: path10 } = parseImageUrl(url);
-            const existingEntry = getMetaEntry(meta, path10);
+            const { base, path: path9 } = parseImageUrl(url);
+            const existingEntry = getMetaEntry(meta, path9);
             if (existingEntry) {
-              skipped.push(path10);
+              skipped.push(path9);
               continue;
             }
             const cdnIndex = getOrAddCdnIndex(meta, base);
             const imageData = await processRemoteImage(url);
-            setMetaEntry(meta, path10, {
+            setMetaEntry(meta, path9, {
               o: imageData.o,
               b: imageData.b,
               c: cdnIndex
             });
-            added.push(path10);
+            added.push(path9);
           } catch (error) {
             console.error(`Failed to import ${url}:`, error);
             errors.push(url);
@@ -2360,7 +2381,7 @@ async function handleUpdateCdns(request) {
 // src/handlers/favicon.ts
 import { NextResponse as NextResponse5 } from "next/server";
 import sharp5 from "sharp";
-import path9 from "path";
+import path8 from "path";
 import fs8 from "fs/promises";
 var FAVICON_CONFIGS = [
   { name: "favicon.ico", size: 48 },
@@ -2379,13 +2400,13 @@ async function handleGenerateFavicon(request) {
   } catch {
     return NextResponse5.json({ error: "Invalid request body" }, { status: 400 });
   }
-  const fileName = path9.basename(imagePath).toLowerCase();
+  const fileName = path8.basename(imagePath).toLowerCase();
   if (fileName !== "favicon.png" && fileName !== "favicon.jpg") {
     return NextResponse5.json({
       error: "Source file must be named favicon.png or favicon.jpg"
     }, { status: 400 });
   }
-  const sourcePath = path9.join(process.cwd(), "public", imagePath.replace(/^\//, ""));
+  const sourcePath = getPublicPath(imagePath.replace(/^\//, ""));
   try {
     await fs8.access(sourcePath);
   } catch {
@@ -2397,7 +2418,7 @@ async function handleGenerateFavicon(request) {
   } catch {
     return NextResponse5.json({ error: "Source file is not a valid image" }, { status: 400 });
   }
-  const outputDir = path9.join(process.cwd(), "src", "app");
+  const outputDir = getSrcAppPath();
   try {
     await fs8.access(outputDir);
   } catch {
@@ -2431,7 +2452,7 @@ async function handleGenerateFavicon(request) {
             message: `Generating ${config.name} (${config.size}x${config.size})...`
           });
           try {
-            const outputPath = path9.join(outputDir, config.name);
+            const outputPath = path8.join(outputDir, config.name);
             await sharp5(sourcePath).resize(config.size, config.size, {
               fit: "cover",
               position: "center"