@gallop.software/studio 0.1.88 → 0.1.90

package/dist/handlers/index.mjs

@@ -1,15 +1,15 @@
 import {
-  getAllThumbnailPaths
-} from "../chunk-3RI33B7A.mjs";
+  getAllThumbnailPaths,
+  getThumbnailPath
+} from "../chunk-ZGXOYJKZ.mjs";
 
 // src/handlers/index.ts
 import { NextResponse as NextResponse4 } from "next/server";
 
 // src/handlers/list.ts
 import { NextResponse } from "next/server";
-import { promises as fs5 } from "fs";
+import { promises as fs4 } from "fs";
 import path5 from "path";
-import sharp2 from "sharp";
 
 // src/handlers/utils/meta.ts
 import { promises as fs } from "fs";
@@ -31,7 +31,6 @@ async function saveMeta(meta) {
 }
 
 // src/handlers/utils/files.ts
-import { promises as fs2 } from "fs";
 import path2 from "path";
 function isImageFile(filename) {
   const ext = path2.extname(filename).toLowerCase();
@@ -63,32 +62,9 @@ function getContentType(filePath) {
       return "application/octet-stream";
   }
 }
-async function getFolderStats(folderPath) {
-  let fileCount = 0;
-  let totalSize = 0;
-  async function scanFolder(dir) {
-    try {
-      const entries = await fs2.readdir(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.name.startsWith(".")) continue;
-        const fullPath = path2.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          await scanFolder(fullPath);
-        } else if (isMediaFile(entry.name)) {
-          fileCount++;
-          const stats = await fs2.stat(fullPath);
-          totalSize += stats.size;
-        }
-      }
-    } catch {
-    }
-  }
-  await scanFolder(folderPath);
-  return { fileCount, totalSize };
-}
 
 // src/handlers/utils/thumbnails.ts
-import { promises as fs3 } from "fs";
+import { promises as fs2 } from "fs";
 import path3 from "path";
 import sharp from "sharp";
 import { encode } from "blurhash";
@@ -107,7 +83,7 @@ async function processImage(buffer, imageKey) {
   const ext = path3.extname(keyWithoutSlash).toLowerCase();
   const imageDir = path3.dirname(keyWithoutSlash);
   const imagesPath = path3.join(process.cwd(), "public", "images", imageDir === "." ? "" : imageDir);
-  await fs3.mkdir(imagesPath, { recursive: true });
+  await fs2.mkdir(imagesPath, { recursive: true });
   const isPng = ext === ".png";
   const outputExt = isPng ? ".png" : ".jpg";
   const fullFileName = imageDir === "." ? `${baseName}${outputExt}` : `${imageDir}/${baseName}${outputExt}`;
@@ -138,12 +114,12 @@ async function processImage(buffer, imageKey) {
   return {
     w: originalWidth,
     h: originalHeight,
-    blur: blurhash
+    b: blurhash
   };
 }
 
 // src/handlers/utils/cdn.ts
-import { promises as fs4 } from "fs";
+import { promises as fs3 } from "fs";
 import path4 from "path";
 import { S3Client, GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3";
 function getR2Client() {
@@ -183,7 +159,7 @@ async function uploadToCdn(imageKey) {
   for (const thumbPath of getAllThumbnailPaths(imageKey)) {
     const localPath = path4.join(process.cwd(), "public", thumbPath);
     try {
-      const fileBuffer = await fs4.readFile(localPath);
+      const fileBuffer = await fs3.readFile(localPath);
       await r2.send(
         new PutObjectCommand({
           Bucket: bucketName,
@@ -200,7 +176,7 @@ async function deleteLocalThumbnails(imageKey) {
   for (const thumbPath of getAllThumbnailPaths(imageKey)) {
     const localPath = path4.join(process.cwd(), "public", thumbPath);
     try {
-      await fs4.unlink(localPath);
+      await fs3.unlink(localPath);
     } catch {
     }
   }
@@ -211,70 +187,85 @@ async function handleList(request) {
   const searchParams = request.nextUrl.searchParams;
   const requestedPath = searchParams.get("path") || "public";
   try {
-    const safePath = requestedPath.replace(/\.\./g, "");
-    const absolutePath = path5.join(process.cwd(), safePath);
-    if (!absolutePath.startsWith(process.cwd())) {
-      return NextResponse.json({ error: "Invalid path" }, { status: 400 });
+    const meta = await loadMeta();
+    const metaKeys = Object.keys(meta);
+    if (metaKeys.length === 0) {
+      return NextResponse.json({ items: [], isEmpty: true });
     }
+    const relativePath = requestedPath.replace(/^public\/?/, "");
+    const pathPrefix = relativePath ? `/${relativePath}/` : "/";
     const items = [];
-    const entries = await fs5.readdir(absolutePath, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.name.startsWith(".")) continue;
-      const itemPath = path5.join(safePath, entry.name);
-      if (entry.isDirectory()) {
-        const folderStats = await getFolderStats(path5.join(absolutePath, entry.name));
-        items.push({
-          name: entry.name,
-          path: itemPath,
-          type: "folder",
-          fileCount: folderStats.fileCount,
-          totalSize: folderStats.totalSize
-        });
-      } else if (isMediaFile(entry.name)) {
-        const filePath = path5.join(absolutePath, entry.name);
-        const stats = await fs5.stat(filePath);
-        const isImage = isImageFile(entry.name);
+    const seenFolders = /* @__PURE__ */ new Set();
+    for (const key of metaKeys) {
+      const entry = meta[key];
+      if (!key.startsWith(pathPrefix) && pathPrefix !== "/") continue;
+      if (pathPrefix === "/" && !key.startsWith("/")) continue;
+      const remaining = pathPrefix === "/" ? key.slice(1) : key.slice(pathPrefix.length);
+      if (!remaining) continue;
+      const slashIndex = remaining.indexOf("/");
+      if (slashIndex !== -1) {
+        const folderName = remaining.slice(0, slashIndex);
+        if (!seenFolders.has(folderName)) {
+          seenFolders.add(folderName);
+          const folderPrefix = pathPrefix === "/" ? `/${folderName}/` : `${pathPrefix}${folderName}/`;
+          let fileCount = 0;
+          for (const k of metaKeys) {
+            if (k.startsWith(folderPrefix)) fileCount++;
+          }
+          items.push({
+            name: folderName,
+            path: relativePath ? `public/${relativePath}/${folderName}` : `public/${folderName}`,
+            type: "folder",
+            fileCount
+          });
+        }
+      } else {
+        const fileName = remaining;
+        const isImage = isImageFile(fileName);
+        const isSynced = entry.c === 1;
         let thumbnail;
         let hasThumbnail = false;
-        let dimensions;
-        if (isImage) {
-          const relativePath = safePath.replace(/^public\/?/, "");
-          if (relativePath === "images" || relativePath.startsWith("images/")) {
-            thumbnail = itemPath.replace("public", "");
-            hasThumbnail = true;
+        let fileSize;
+        if (isImage && (entry.w || entry.b)) {
+          const thumbPath = getThumbnailPath(key, "sm");
+          if (isSynced) {
+            const cdnUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL || process.env.NEXT_PUBLIC_CLOUDFLARE_R2_PUBLIC_URL;
+            if (cdnUrl) {
+              thumbnail = `${cdnUrl}${thumbPath}`;
+              hasThumbnail = true;
+            }
           } else {
-            const ext = path5.extname(entry.name).toLowerCase();
-            const baseName = path5.basename(entry.name, ext);
-            const thumbnailDir = relativePath ? `images/${relativePath}` : "images";
-            const thumbnailName = `${baseName}-sm${ext === ".png" ? ".png" : ".jpg"}`;
-            const thumbnailPath = path5.join(process.cwd(), "public", thumbnailDir, thumbnailName);
+            const localThumbPath = path5.join(process.cwd(), "public", thumbPath);
             try {
-              await fs5.access(thumbnailPath);
-              thumbnail = `/${thumbnailDir}/${thumbnailName}`;
+              await fs4.access(localThumbPath);
+              thumbnail = thumbPath;
               hasThumbnail = true;
             } catch {
-              thumbnail = itemPath.replace("public", "");
+              thumbnail = key;
               hasThumbnail = false;
             }
           }
-          if (!entry.name.toLowerCase().endsWith(".svg")) {
-            try {
-              const metadata = await sharp2(filePath).metadata();
-              if (metadata.width && metadata.height) {
-                dimensions = { width: metadata.width, height: metadata.height };
-              }
-            } catch {
-            }
+        } else if (isImage) {
+          thumbnail = key;
+          hasThumbnail = false;
+        }
+        if (!isSynced) {
+          try {
+            const filePath = path5.join(process.cwd(), "public", key);
+            const stats = await fs4.stat(filePath);
+            fileSize = stats.size;
+          } catch {
           }
         }
         items.push({
-          name: entry.name,
-          path: itemPath,
+          name: fileName,
+          path: relativePath ? `public/${relativePath}/${fileName}` : `public/${fileName}`,
           type: "file",
-          size: stats.size,
+          size: fileSize,
           thumbnail,
           hasThumbnail,
-          dimensions
+          cdnSynced: isSynced,
+          dimensions: entry.w && entry.h ? { width: entry.w, height: entry.h } : void 0
         });
       }
     }
@@ -291,62 +282,49 @@ async function handleSearch(request) {
     return NextResponse.json({ items: [] });
   }
   try {
+    const meta = await loadMeta();
     const items = [];
-    const publicDir = path5.join(process.cwd(), "public");
-    async function searchDir(dir, relativePath) {
-      try {
-        const entries = await fs5.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.name.startsWith(".")) continue;
-          const fullPath = path5.join(dir, entry.name);
-          const itemPath = relativePath ? `public/${relativePath}/${entry.name}` : `public/${entry.name}`;
-          const itemRelPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-          if (entry.isDirectory()) {
-            await searchDir(fullPath, itemRelPath);
-          } else if (isImageFile(entry.name)) {
-            if (itemPath.toLowerCase().includes(query)) {
-              const stats = await fs5.stat(fullPath);
-              let thumbnail;
-              let hasThumbnail = false;
-              let dimensions;
-              const ext = path5.extname(entry.name).toLowerCase();
-              const baseName = path5.basename(entry.name, ext);
-              const thumbnailDir = relativePath ? `images/${relativePath}` : "images";
-              const thumbnailName = `${baseName}-sm${ext === ".png" ? ".png" : ".jpg"}`;
-              const thumbnailPath = path5.join(process.cwd(), "public", thumbnailDir, thumbnailName);
-              try {
-                await fs5.access(thumbnailPath);
-                thumbnail = `/${thumbnailDir}/${thumbnailName}`;
-                hasThumbnail = true;
-              } catch {
-                thumbnail = `/${itemRelPath}`;
-                hasThumbnail = false;
-              }
-              if (!entry.name.toLowerCase().endsWith(".svg")) {
-                try {
-                  const metadata = await sharp2(fullPath).metadata();
-                  if (metadata.width && metadata.height) {
-                    dimensions = { width: metadata.width, height: metadata.height };
-                  }
-                } catch {
-                }
-              }
-              items.push({
-                name: entry.name,
-                path: itemPath,
-                type: "file",
-                size: stats.size,
-                thumbnail,
-                hasThumbnail,
-                dimensions
-              });
-            }
+    for (const [key, entry] of Object.entries(meta)) {
+      if (!key.toLowerCase().includes(query)) continue;
+      const fileName = path5.basename(key);
+      const relativePath = key.slice(1);
+      const isImage = isImageFile(fileName);
+      const isSynced = entry.c === 1;
+      let thumbnail;
+      let hasThumbnail = false;
+      if (isImage && (entry.w || entry.b)) {
+        const thumbPath = getThumbnailPath(key, "sm");
+        if (isSynced) {
+          const cdnUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL || process.env.NEXT_PUBLIC_CLOUDFLARE_R2_PUBLIC_URL;
+          if (cdnUrl) {
+            thumbnail = `${cdnUrl}${thumbPath}`;
+            hasThumbnail = true;
+          }
+        } else {
+          const localThumbPath = path5.join(process.cwd(), "public", thumbPath);
+          try {
+            await fs4.access(localThumbPath);
+            thumbnail = thumbPath;
+            hasThumbnail = true;
+          } catch {
+            thumbnail = key;
+            hasThumbnail = false;
           }
         }
-      } catch {
+      } else if (isImage) {
+        thumbnail = key;
+        hasThumbnail = false;
       }
+      items.push({
+        name: fileName,
+        path: `public/${relativePath}`,
+        type: "file",
+        thumbnail,
+        hasThumbnail,
+        cdnSynced: isSynced,
+        dimensions: entry.w && entry.h ? { width: entry.w, height: entry.h } : void 0
+      });
     }
-    await searchDir(publicDir, "");
     return NextResponse.json({ items });
   } catch (error) {
     console.error("Failed to search:", error);
@@ -355,27 +333,28 @@ async function handleSearch(request) {
 }
 async function handleListFolders() {
   try {
-    const publicDir = path5.join(process.cwd(), "public");
-    const folders = [];
-    async function scanDir(dir, relativePath, depth) {
-      try {
-        const entries = await fs5.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (!entry.isDirectory()) continue;
-          if (entry.name.startsWith(".")) continue;
-          const folderRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-          folders.push({
-            path: `public/${folderRelativePath}`,
-            name: entry.name,
-            depth
-          });
-          await scanDir(path5.join(dir, entry.name), folderRelativePath, depth + 1);
-        }
-      } catch {
+    const meta = await loadMeta();
+    const folderSet = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(meta)) {
+      const parts = key.split("/");
+      let current = "";
+      for (let i = 1; i < parts.length - 1; i++) {
+        current = current ? `${current}/${parts[i]}` : parts[i];
+        folderSet.add(current);
       }
     }
+    const folders = [];
     folders.push({ path: "public", name: "public", depth: 0 });
-    await scanDir(publicDir, "", 1);
+    const sortedFolders = Array.from(folderSet).sort();
+    for (const folderPath of sortedFolders) {
+      const depth = folderPath.split("/").length;
+      const name = folderPath.split("/").pop() || folderPath;
+      folders.push({
+        path: `public/${folderPath}`,
+        name,
+        depth
+      });
+    }
     return NextResponse.json({ folders });
   } catch (error) {
     console.error("Failed to list folders:", error);
@@ -384,26 +363,14 @@ async function handleListFolders() {
 }
 async function handleCountImages() {
   try {
+    const meta = await loadMeta();
     const allImages = [];
-    async function scanPublicFolder(dir, relativePath = "") {
-      try {
-        const entries = await fs5.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.name.startsWith(".")) continue;
-          const fullPath = path5.join(dir, entry.name);
-          const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-          if (relPath === "images" || relPath.startsWith("images/")) continue;
-          if (entry.isDirectory()) {
-            await scanPublicFolder(fullPath, relPath);
-          } else if (isImageFile(entry.name)) {
-            allImages.push(relPath);
-          }
-        }
-      } catch {
+    for (const key of Object.keys(meta)) {
+      const fileName = path5.basename(key);
+      if (isImageFile(fileName)) {
+        allImages.push(key.slice(1));
       }
     }
-    const publicDir = path5.join(process.cwd(), "public");
-    await scanPublicFolder(publicDir);
     return NextResponse.json({
       count: allImages.length,
       images: allImages
@@ -421,29 +388,22 @@ async function handleFolderImages(request) {
       return NextResponse.json({ error: "No folders provided" }, { status: 400 });
     }
     const folders = foldersParam.split(",");
+    const meta = await loadMeta();
     const allImages = [];
-    async function scanFolder(dir, relativePath = "") {
-      try {
-        const entries = await fs5.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.name.startsWith(".")) continue;
-          const fullPath = path5.join(dir, entry.name);
-          const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-          if (entry.isDirectory()) {
-            await scanFolder(fullPath, relPath);
-          } else if (isImageFile(entry.name)) {
-            allImages.push(relPath);
-          }
+    const prefixes = folders.map((f) => {
+      const rel = f.replace(/^public\/?/, "");
+      return rel ? `/${rel}/` : "/";
+    });
+    for (const key of Object.keys(meta)) {
+      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));
+          break;
         }
-      } catch {
       }
     }
-    for (const folder of folders) {
-      const relativePath = folder.replace(/^public\/?/, "");
-      if (relativePath === "images" || relativePath.startsWith("images/")) continue;
-      const folderPath = path5.join(process.cwd(), folder);
-      await scanFolder(folderPath, relativePath);
-    }
     return NextResponse.json({
       count: allImages.length,
       images: allImages
@@ -456,10 +416,9 @@ async function handleFolderImages(request) {
 
 // src/handlers/files.ts
 import { NextResponse as NextResponse2 } from "next/server";
-import { promises as fs6 } from "fs";
+import { promises as fs5 } from "fs";
 import path6 from "path";
-import sharp3 from "sharp";
-import { encode as encode2 } from "blurhash";
+import sharp2 from "sharp";
 async function handleUpload(request) {
   try {
     const formData = await request.formData();
@@ -471,11 +430,9 @@ async function handleUpload(request) {
     const bytes = await file.arrayBuffer();
     const buffer = Buffer.from(bytes);
     const fileName = file.name;
-    const baseName = path6.basename(fileName, path6.extname(fileName));
     const ext = path6.extname(fileName).toLowerCase();
     const isImage = isImageFile(fileName);
-    const isSvg = ext === ".svg";
-    const isProcessableImage = isImage && !isSvg;
+    const isMedia = isMediaFile(fileName);
     const meta = await loadMeta();
     let relativeDir = "";
     if (targetPath === "public") {
@@ -489,71 +446,49 @@ async function handleUpload(request) {
         { status: 400 }
       );
     }
+    let imageKey = "/" + (relativeDir ? `${relativeDir}/${fileName}` : fileName);
+    if (meta[imageKey]) {
+      const baseName = path6.basename(fileName, ext);
+      let counter = 1;
+      let newFileName = `${baseName}-${counter}${ext}`;
+      let newKey = "/" + (relativeDir ? `${relativeDir}/${newFileName}` : newFileName);
+      while (meta[newKey]) {
+        counter++;
+        newFileName = `${baseName}-${counter}${ext}`;
+        newKey = "/" + (relativeDir ? `${relativeDir}/${newFileName}` : newFileName);
+      }
+      imageKey = newKey;
+    }
+    const actualFileName = path6.basename(imageKey);
     const uploadDir = path6.join(process.cwd(), "public", relativeDir);
-    await fs6.mkdir(uploadDir, { recursive: true });
-    await fs6.writeFile(path6.join(uploadDir, fileName), buffer);
-    if (!isImage) {
+    await fs5.mkdir(uploadDir, { recursive: true });
+    await fs5.writeFile(path6.join(uploadDir, actualFileName), buffer);
+    if (!isMedia) {
       return NextResponse2.json({
         success: true,
-        message: "File uploaded successfully (non-image, no thumbnails generated)",
-        path: `public/${relativeDir ? relativeDir + "/" : ""}${fileName}`
+        message: "File uploaded (not a media file)",
+        path: `public/${relativeDir ? relativeDir + "/" : ""}${actualFileName}`
       });
     }
-    const imageKey = "/" + (relativeDir ? `${relativeDir}/${fileName}` : fileName);
-    if (meta[imageKey]) {
-      return NextResponse2.json(
-        { error: `File '${imageKey}' already exists in meta` },
-        { status: 409 }
-      );
-    }
-    const imagesPath = path6.join(process.cwd(), "public", "images", relativeDir);
-    await fs6.mkdir(imagesPath, { recursive: true });
-    let originalWidth = 0;
-    let originalHeight = 0;
-    let blurhash = "";
-    const originalPath = `/${relativeDir ? relativeDir + "/" : ""}${fileName}`;
-    if (isSvg) {
-      const fullPath = path6.join(imagesPath, fileName);
-      await fs6.writeFile(fullPath, buffer);
-    } else if (isProcessableImage) {
-      const sharpInstance = sharp3(buffer);
-      const metadata = await sharpInstance.metadata();
-      originalWidth = metadata.width || 0;
-      originalHeight = metadata.height || 0;
-      const outputExt = ext === ".png" ? ".png" : ".jpg";
-      const fullFileName = `${baseName}${outputExt}`;
-      const fullPath = path6.join(imagesPath, fullFileName);
-      if (ext === ".png") {
-        await sharp3(buffer).png({ quality: 85 }).toFile(fullPath);
-      } else {
-        await sharp3(buffer).jpeg({ quality: 85 }).toFile(fullPath);
-      }
-      for (const [, sizeConfig] of Object.entries(DEFAULT_SIZES)) {
-        const { width: maxWidth, suffix } = sizeConfig;
-        if (originalWidth <= maxWidth) {
-          continue;
-        }
-        const ratio = originalHeight / originalWidth;
-        const newHeight = Math.round(maxWidth * ratio);
-        const sizeFileName = `${baseName}${suffix}${outputExt}`;
-        const sizePath = path6.join(imagesPath, sizeFileName);
-        if (ext === ".png") {
-          await sharp3(buffer).resize(maxWidth, newHeight).png({ quality: 80 }).toFile(sizePath);
-        } else {
-          await sharp3(buffer).resize(maxWidth, newHeight).jpeg({ quality: 80 }).toFile(sizePath);
-        }
+    if (isImage && ext !== ".svg") {
+      try {
+        const metadata = await sharp2(buffer).metadata();
+        meta[imageKey] = {
+          w: metadata.width || 0,
+          h: metadata.height || 0
+        };
+      } catch {
+        meta[imageKey] = { w: 0, h: 0 };
       }
-      const { data, info } = await sharp3(buffer).resize(32, 32, { fit: "inside" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
-      blurhash = encode2(new Uint8ClampedArray(data), info.width, info.height, 4, 4);
+    } else {
+      meta[imageKey] = {};
     }
-    const entry = {
-      w: originalWidth,
-      h: originalHeight,
-      blur: blurhash
-    };
-    meta[originalPath] = entry;
     await saveMeta(meta);
-    return NextResponse2.json({ success: true, imageKey: originalPath, entry });
+    return NextResponse2.json({
+      success: true,
+      imageKey,
+      message: 'File uploaded. Run "Process Images" to generate thumbnails.'
+    });
   } catch (error) {
     console.error("Failed to upload:", error);
     const message = error instanceof Error ? error.message : "Unknown error";
@@ -576,31 +511,61 @@ async function handleDelete(request) {
           continue;
         }
         const absolutePath = path6.join(process.cwd(), itemPath);
-        const stats = await fs6.stat(absolutePath);
-        if (stats.isDirectory()) {
-          await fs6.rm(absolutePath, { recursive: true });
-          const prefix = "/" + itemPath.replace(/^public\/images\/?/, "").replace(/^public\/?/, "");
-          for (const key of Object.keys(meta)) {
-            if (key.startsWith(prefix)) {
-              delete meta[key];
+        const imageKey = "/" + itemPath.replace(/^public\//, "");
+        const entry = meta[imageKey];
+        const isSynced = entry?.c === 1;
+        try {
+          const stats = await fs5.stat(absolutePath);
+          if (stats.isDirectory()) {
+            await fs5.rm(absolutePath, { recursive: true });
+            const prefix = imageKey + "/";
+            for (const key of Object.keys(meta)) {
+              if (key.startsWith(prefix) || key === imageKey) {
+                if (!meta[key].c) {
+                  for (const thumbPath of getAllThumbnailPaths(key)) {
+                    const absoluteThumbPath = path6.join(process.cwd(), "public", thumbPath);
+                    try {
+                      await fs5.unlink(absoluteThumbPath);
+                    } catch {
+                    }
+                  }
+                }
+                delete meta[key];
+              }
             }
-          }
-        } else {
-          await fs6.unlink(absolutePath);
-          const isInImagesFolder = itemPath.startsWith("public/images/");
-          if (!isInImagesFolder) {
-            const imageKey = "/" + itemPath.replace(/^public\//, "");
-            if (meta[imageKey]) {
-              for (const thumbPath of getAllThumbnailPaths(imageKey)) {
-                const absoluteThumbPath = path6.join(process.cwd(), "public", thumbPath);
-                try {
-                  await fs6.unlink(absoluteThumbPath);
-                } catch {
+          } else {
+            await fs5.unlink(absolutePath);
+            const isInImagesFolder = itemPath.startsWith("public/images/");
+            if (!isInImagesFolder && entry) {
+              if (!isSynced) {
+                for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+                  const absoluteThumbPath = path6.join(process.cwd(), "public", thumbPath);
+                  try {
+                    await fs5.unlink(absoluteThumbPath);
+                  } catch {
+                  }
                 }
               }
               delete meta[imageKey];
             }
           }
+        } catch {
+          if (entry) {
+            delete meta[imageKey];
+          } else {
+            const prefix = imageKey + "/";
+            let foundAny = false;
+            for (const key of Object.keys(meta)) {
+              if (key.startsWith(prefix)) {
+                delete meta[key];
+                foundAny = true;
+              }
+            }
+            if (!foundAny) {
+              errors.push(`Not found: ${itemPath}`);
+              continue;
+            }
+          }
         }
         deleted.push(itemPath);
       } catch (error) {
@@ -635,11 +600,11 @@ async function handleCreateFolder(request) {
       return NextResponse2.json({ error: "Invalid path" }, { status: 400 });
     }
     try {
-      await fs6.access(folderPath);
+      await fs5.access(folderPath);
       return NextResponse2.json({ error: "A folder with this name already exists" }, { status: 400 });
     } catch {
     }
-    await fs6.mkdir(folderPath, { recursive: true });
+    await fs5.mkdir(folderPath, { recursive: true });
     return NextResponse2.json({ success: true, path: path6.join(safePath, sanitizedName) });
   } catch (error) {
     console.error("Failed to create folder:", error);
@@ -664,19 +629,19 @@ async function handleRename(request) {
       return NextResponse2.json({ error: "Invalid path" }, { status: 400 });
     }
     try {
-      await fs6.access(absoluteOldPath);
+      await fs5.access(absoluteOldPath);
     } catch {
       return NextResponse2.json({ error: "File or folder not found" }, { status: 404 });
     }
     try {
-      await fs6.access(absoluteNewPath);
+      await fs5.access(absoluteNewPath);
       return NextResponse2.json({ error: "An item with this name already exists" }, { status: 400 });
     } catch {
     }
-    const stats = await fs6.stat(absoluteOldPath);
+    const stats = await fs5.stat(absoluteOldPath);
     const isFile = stats.isFile();
     const isImage = isFile && isImageFile(path6.basename(oldPath));
-    await fs6.rename(absoluteOldPath, absoluteNewPath);
+    await fs5.rename(absoluteOldPath, absoluteNewPath);
     if (isImage) {
       const meta = await loadMeta();
       const oldRelativePath = safePath.replace(/^public\//, "");
@@ -690,9 +655,9 @@ async function handleRename(request) {
         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 fs6.mkdir(path6.dirname(newThumbPath), { recursive: true });
+          await fs5.mkdir(path6.dirname(newThumbPath), { recursive: true });
           try {
-            await fs6.rename(oldThumbPath, newThumbPath);
+            await fs5.rename(oldThumbPath, newThumbPath);
           } catch {
           }
         }
@@ -723,7 +688,7 @@ async function handleMove(request) {
       return NextResponse2.json({ error: "Invalid destination" }, { status: 400 });
     }
     try {
-      const destStats = await fs6.stat(absoluteDestination);
+      const destStats = await fs5.stat(absoluteDestination);
       if (!destStats.isDirectory()) {
         return NextResponse2.json({ error: "Destination is not a folder" }, { status: 400 });
       }
@@ -744,20 +709,20 @@ async function handleMove(request) {
         continue;
       }
       try {
-        await fs6.access(absolutePath);
+        await fs5.access(absolutePath);
       } catch {
         errors.push(`${itemName} not found`);
         continue;
       }
       try {
-        await fs6.access(newAbsolutePath);
+        await fs5.access(newAbsolutePath);
         errors.push(`${itemName} already exists in destination`);
         continue;
       } catch {
       }
       try {
-        await fs6.rename(absolutePath, newAbsolutePath);
-        const stats = await fs6.stat(newAbsolutePath);
+        await fs5.rename(absolutePath, newAbsolutePath);
+        const stats = await fs5.stat(newAbsolutePath);
         if (stats.isFile() && isImageFile(itemName)) {
           const oldRelativePath = safePath.replace(/^public\//, "");
           const newRelativePath = path6.join(safeDestination.replace(/^public\//, ""), itemName);
@@ -770,9 +735,9 @@ async function handleMove(request) {
             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 fs6.mkdir(path6.dirname(newThumbPath), { recursive: true });
+              await fs5.mkdir(path6.dirname(newThumbPath), { recursive: true });
               try {
-                await fs6.rename(oldThumbPath, newThumbPath);
+                await fs5.rename(oldThumbPath, newThumbPath);
               } catch {
               }
             }
@@ -802,7 +767,7 @@ async function handleMove(request) {
 
 // src/handlers/images.ts
 import { NextResponse as NextResponse3 } from "next/server";
-import { promises as fs7 } from "fs";
+import { promises as fs6 } from "fs";
 import path7 from "path";
 import { S3Client as S3Client2, PutObjectCommand as PutObjectCommand2 } from "@aws-sdk/client-s3";
 async function handleSync(request) {
@@ -833,18 +798,33 @@ async function handleSync(request) {
     for (const imageKey of imageKeys) {
       const entry = meta[imageKey];
       if (!entry) {
-        errors.push(`Image not found in meta: ${imageKey}`);
+        errors.push(`Image not found in meta: ${imageKey}. Run Scan first.`);
         continue;
       }
-      if (entry.s) {
+      if (entry.c) {
         synced.push(imageKey);
         continue;
       }
       try {
+        const originalLocalPath = path7.join(process.cwd(), "public", imageKey);
+        try {
+          const originalBuffer = await fs6.readFile(originalLocalPath);
+          await r2.send(
+            new PutObjectCommand2({
+              Bucket: bucketName,
+              Key: imageKey.replace(/^\//, ""),
+              Body: originalBuffer,
+              ContentType: getContentType(imageKey)
+            })
+          );
+        } catch (err) {
+          errors.push(`Original file not found: ${imageKey}`);
+          continue;
+        }
         for (const thumbPath of getAllThumbnailPaths(imageKey)) {
           const localPath = path7.join(process.cwd(), "public", thumbPath);
           try {
-            const fileBuffer = await fs7.readFile(localPath);
+            const fileBuffer = await fs6.readFile(localPath);
             await r2.send(
               new PutObjectCommand2({
                 Bucket: bucketName,
@@ -856,18 +836,22 @@ async function handleSync(request) {
           } catch {
           }
         }
-        entry.s = 1;
+        entry.c = 1;
         for (const thumbPath of getAllThumbnailPaths(imageKey)) {
           const localPath = path7.join(process.cwd(), "public", thumbPath);
           try {
-            await fs7.unlink(localPath);
+            await fs6.unlink(localPath);
           } catch {
           }
         }
+        try {
+          await fs6.unlink(originalLocalPath);
+        } catch {
+        }
         synced.push(imageKey);
       } catch (error) {
         console.error(`Failed to sync ${imageKey}:`, error);
-        errors.push(imageKey);
+        errors.push(`Failed to sync: ${imageKey}`);
       }
     }
     await saveMeta(meta);
@@ -894,21 +878,29 @@ async function handleReprocess(request) {
       try {
         let buffer;
         const entry = meta[imageKey];
+        const isSynced = entry?.c === 1;
         const originalPath = path7.join(process.cwd(), "public", imageKey);
         try {
-          buffer = await fs7.readFile(originalPath);
+          buffer = await fs6.readFile(originalPath);
         } catch {
-          if (entry?.s) {
+          if (isSynced) {
             buffer = await downloadFromCdn(imageKey);
+            const dir = path7.dirname(originalPath);
+            await fs6.mkdir(dir, { recursive: true });
+            await fs6.writeFile(originalPath, buffer);
           } else {
             throw new Error(`File not found: ${imageKey}`);
           }
         }
         const updatedEntry = await processImage(buffer, imageKey);
-        if (entry?.s) {
-          updatedEntry.s = 1;
+        if (isSynced) {
+          updatedEntry.c = 1;
           await uploadToCdn(imageKey);
           await deleteLocalThumbnails(imageKey);
+          try {
+            await fs6.unlink(originalPath);
+          } catch {
+          }
         }
         meta[imageKey] = updatedEntry;
         processed.push(imageKey);
@@ -942,78 +934,66 @@ async function handleProcessAllStream() {
         const processed = [];
         const errors = [];
         const orphansRemoved = [];
-        const allImages = [];
-        async function scanPublicFolder(dir, relativePath = "") {
-          try {
-            const entries = await fs7.readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-              if (entry.name.startsWith(".")) continue;
-              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()) {
-                await scanPublicFolder(fullPath, relPath);
-              } else if (isImageFile(entry.name)) {
-                allImages.push({ key: relPath, fullPath });
-              }
-            }
-          } catch {
+        const imagesToProcess = [];
+        for (const [key, entry] of Object.entries(meta)) {
+          if (entry.c) continue;
+          const fileName = path7.basename(key);
+          if (!isImageFile(fileName)) continue;
+          if (!entry.b) {
+            imagesToProcess.push({ key, entry });
           }
         }
-        const publicDir = path7.join(process.cwd(), "public");
-        await scanPublicFolder(publicDir);
-        const total = allImages.length;
+        const total = imagesToProcess.length;
         sendEvent({ type: "start", total });
-        for (let i = 0; i < allImages.length; i++) {
-          const { key, fullPath } = allImages[i];
-          const imageKey = "/" + key;
+        for (let i = 0; i < imagesToProcess.length; i++) {
+          const { key } = imagesToProcess[i];
+          const fullPath = path7.join(process.cwd(), "public", key);
           sendEvent({
             type: "progress",
             current: i + 1,
             total,
             percent: Math.round((i + 1) / total * 100),
-            currentFile: key
+            currentFile: key.slice(1)
+            // Remove leading /
           });
           try {
-            const buffer = await fs7.readFile(fullPath);
+            const buffer = await fs6.readFile(fullPath);
             const ext = path7.extname(key).toLowerCase();
             const isSvg = ext === ".svg";
             if (isSvg) {
-              const imageDir = path7.dirname(key);
+              const imageDir = path7.dirname(key.slice(1));
               const imagesPath = path7.join(process.cwd(), "public", "images", imageDir === "." ? "" : imageDir);
-              await fs7.mkdir(imagesPath, { recursive: true });
+              await fs6.mkdir(imagesPath, { recursive: true });
               const fileName = path7.basename(key);
               const destPath = path7.join(imagesPath, fileName);
-              await fs7.writeFile(destPath, buffer);
-              meta[imageKey] = {
+              await fs6.writeFile(destPath, buffer);
+              meta[key] = {
                 w: 0,
                 h: 0,
-                blur: ""
+                b: ""
               };
             } else {
-              const existingEntry = meta[imageKey];
-              const processedEntry = await processImage(buffer, imageKey);
-              if (existingEntry?.s) {
-                processedEntry.s = 1;
-              }
-              meta[imageKey] = processedEntry;
+              const processedEntry = await processImage(buffer, key);
+              meta[key] = processedEntry;
             }
-            processed.push(key);
+            processed.push(key.slice(1));
           } catch (error) {
             console.error(`Failed to process ${key}:`, error);
-            errors.push(key);
+            errors.push(key.slice(1));
           }
         }
         sendEvent({ type: "cleanup", message: "Removing orphaned thumbnails..." });
         const trackedPaths = /* @__PURE__ */ new Set();
         for (const imageKey of Object.keys(meta)) {
-          for (const thumbPath of getAllThumbnailPaths(imageKey)) {
-            trackedPaths.add(thumbPath);
+          if (!meta[imageKey].c) {
+            for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+              trackedPaths.add(thumbPath);
+            }
           }
         }
         async function findOrphans(dir, relativePath = "") {
           try {
-            const entries = await fs7.readdir(dir, { withFileTypes: true });
+            const entries = await fs6.readdir(dir, { withFileTypes: true });
             for (const entry of entries) {
               if (entry.name.startsWith(".")) continue;
               const fullPath = path7.join(dir, entry.name);
@@ -1024,7 +1004,7 @@ async function handleProcessAllStream() {
                 const publicPath = `/images/${relPath}`;
                 if (!trackedPaths.has(publicPath)) {
                   try {
-                    await fs7.unlink(fullPath);
+                    await fs6.unlink(fullPath);
                     orphansRemoved.push(publicPath);
                   } catch (err) {
                     console.error(`Failed to remove orphan ${publicPath}:`, err);
@@ -1036,10 +1016,13 @@ async function handleProcessAllStream() {
           }
         }
         const imagesDir = path7.join(process.cwd(), "public", "images");
-        await findOrphans(imagesDir);
+        try {
+          await findOrphans(imagesDir);
+        } catch {
+        }
         async function removeEmptyDirs(dir) {
           try {
-            const entries = await fs7.readdir(dir, { withFileTypes: true });
+            const entries = await fs6.readdir(dir, { withFileTypes: true });
             let isEmpty = true;
             for (const entry of entries) {
               if (entry.isDirectory()) {
@@ -1050,14 +1033,17 @@ async function handleProcessAllStream() {
               }
             }
             if (isEmpty && dir !== imagesDir) {
-              await fs7.rmdir(dir);
+              await fs6.rmdir(dir);
             }
             return isEmpty;
           } catch {
             return true;
           }
         }
-        await removeEmptyDirs(imagesDir);
+        try {
+          await removeEmptyDirs(imagesDir);
+        } catch {
+        }
         await saveMeta(meta);
         sendEvent({
           type: "complete",
@@ -1082,6 +1068,135 @@ async function handleProcessAllStream() {
   });
 }
 
+// src/handlers/scan.ts
+import { promises as fs7 } from "fs";
+import path8 from "path";
+import sharp3 from "sharp";
+async function handleScanStream() {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      const sendEvent = (data) => {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+
+`));
+      };
+      try {
+        const meta = await loadMeta();
+        const existingKeys = new Set(Object.keys(meta));
+        const added = [];
+        const renamed = [];
+        const errors = [];
+        const allFiles = [];
+        async function scanDir(dir, relativePath = "") {
+          try {
+            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 relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+              if (relPath === "images" || relPath.startsWith("images/")) continue;
+              if (entry.isDirectory()) {
+                await scanDir(fullPath, relPath);
+              } else if (isMediaFile(entry.name)) {
+                allFiles.push({ relativePath: relPath, fullPath });
+              }
+            }
+          } catch {
+          }
+        }
+        const publicDir = path8.join(process.cwd(), "public");
+        await scanDir(publicDir);
+        const total = allFiles.length;
+        sendEvent({ type: "start", total });
+        for (let i = 0; i < allFiles.length; i++) {
+          let { relativePath, fullPath } = allFiles[i];
+          let imageKey = "/" + relativePath;
+          sendEvent({
+            type: "progress",
+            current: i + 1,
+            total,
+            percent: Math.round((i + 1) / total * 100),
+            currentFile: relativePath
+          });
+          if (existingKeys.has(imageKey)) {
+            continue;
+          }
+          if (meta[imageKey]) {
+            const ext = path8.extname(relativePath);
+            const baseName = relativePath.slice(0, -ext.length);
+            let counter = 1;
+            let newKey = `/${baseName}-${counter}${ext}`;
+            while (meta[newKey]) {
+              counter++;
+              newKey = `/${baseName}-${counter}${ext}`;
+            }
+            const newRelativePath = `${baseName}-${counter}${ext}`;
+            const newFullPath = path8.join(process.cwd(), "public", newRelativePath);
+            try {
+              await fs7.rename(fullPath, newFullPath);
+              renamed.push({ from: relativePath, to: newRelativePath });
+              relativePath = newRelativePath;
+              fullPath = newFullPath;
+              imageKey = newKey;
+            } catch (err) {
+              console.error(`Failed to rename ${relativePath}:`, err);
+              errors.push(`Failed to rename ${relativePath}`);
+              continue;
+            }
+          }
+          try {
+            const isImage = isImageFile(relativePath);
+            if (isImage) {
+              const ext = path8.extname(relativePath).toLowerCase();
+              if (ext === ".svg") {
+                meta[imageKey] = { w: 0, h: 0 };
+              } else {
+                try {
+                  const metadata = await sharp3(fullPath).metadata();
+                  meta[imageKey] = {
+                    w: metadata.width || 0,
+                    h: metadata.height || 0
+                  };
+                } catch {
+                  meta[imageKey] = { w: 0, h: 0 };
+                }
+              }
+            } else {
+              meta[imageKey] = {};
+            }
+            existingKeys.add(imageKey);
+            added.push(imageKey);
+          } catch (error) {
+            console.error(`Failed to process ${relativePath}:`, error);
+            errors.push(relativePath);
+          }
+        }
+        await saveMeta(meta);
+        sendEvent({
+          type: "complete",
+          added: added.length,
+          renamed: renamed.length,
+          errors: errors.length,
+          renamedFiles: renamed
+        });
+      } catch (error) {
+        console.error("Scan failed:", error);
+        sendEvent({ type: "error", message: "Scan failed" });
+      } finally {
+        controller.close();
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive"
+    }
+  });
+}
+
 // src/handlers/index.ts
 async function GET(request) {
   if (process.env.NODE_ENV !== "development") {
@@ -1136,6 +1251,9 @@ async function POST(request) {
   if (route === "move") {
     return handleMove(request);
   }
+  if (route === "scan") {
+    return handleScanStream();
+  }
   return NextResponse4.json({ error: "Not found" }, { status: 404 });
 }
 async function DELETE(request) {