@gallop.software/studio 0.1.116 → 1.0.1

package/dist/handlers/index.mjs

@@ -1,10 +1,10 @@
 import {
   getAllThumbnailPaths,
   getThumbnailPath
-} from "../chunk-RDNC5ABF.mjs";
+} from "../chunk-FDWPNRNZ.mjs";
 
 // src/handlers/index.ts
-import { NextResponse as NextResponse4 } from "next/server";
+import { NextResponse as NextResponse5 } from "next/server";
 
 // src/handlers/list.ts
 import { NextResponse } from "next/server";
@@ -309,25 +309,58 @@ async function handleList(request) {
     const items = [];
     const seenFolders = /* @__PURE__ */ new Set();
     const metaKeys = fileEntries.map(([key]) => key);
+    const isInsideImagesFolder = relativePath === "images" || relativePath.startsWith("images/");
     const absoluteDir = path5.join(process.cwd(), requestedPath);
     try {
       const dirEntries = await fs4.readdir(absoluteDir, { withFileTypes: true });
       for (const entry of dirEntries) {
-        if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "images") {
+        if (entry.name.startsWith(".")) continue;
+        if (entry.isDirectory()) {
           if (!seenFolders.has(entry.name)) {
             seenFolders.add(entry.name);
-            const folderPrefix = pathPrefix === "/" ? `/${entry.name}/` : `${pathPrefix}${entry.name}/`;
+            const isImagesFolder = entry.name === "images" && !relativePath;
+            const folderPath = relativePath ? `public/${relativePath}/${entry.name}` : `public/${entry.name}`;
             let fileCount = 0;
-            for (const k of metaKeys) {
-              if (k.startsWith(folderPrefix)) fileCount++;
+            if (isInsideImagesFolder || isImagesFolder) {
+              const subDir = path5.join(absoluteDir, entry.name);
+              try {
+                const subEntries = await fs4.readdir(subDir);
+                fileCount = subEntries.filter((f) => !f.startsWith(".")).length;
+              } catch {
+              }
+            } else {
+              const folderPrefix = pathPrefix === "/" ? `/${entry.name}/` : `${pathPrefix}${entry.name}/`;
+              for (const k of metaKeys) {
+                if (k.startsWith(folderPrefix)) fileCount++;
+              }
             }
             items.push({
               name: entry.name,
-              path: relativePath ? `public/${relativePath}/${entry.name}` : `public/${entry.name}`,
+              path: folderPath,
               type: "folder",
-              fileCount
+              fileCount,
+              isProtected: isImagesFolder || isInsideImagesFolder
             });
           }
+        } else if (isInsideImagesFolder) {
+          const filePath = relativePath ? `public/${relativePath}/${entry.name}` : `public/${entry.name}`;
+          const fullPath = path5.join(absoluteDir, entry.name);
+          let fileSize;
+          try {
+            const stats = await fs4.stat(fullPath);
+            fileSize = stats.size;
+          } catch {
+          }
+          const isImage = isImageFile(entry.name);
+          items.push({
+            name: entry.name,
+            path: filePath,
+            type: "file",
+            size: fileSize,
+            thumbnail: isImage ? `/${relativePath}/${entry.name}` : void 0,
+            hasThumbnail: false,
+            isProtected: true
+          });
         }
       }
     } catch {
@@ -354,7 +387,8 @@ async function handleList(request) {
             name: folderName,
             path: relativePath ? `public/${relativePath}/${folderName}` : `public/${folderName}`,
             type: "folder",
-            fileCount
+            fileCount,
+            isProtected: isInsideImagesFolder
           });
         }
       } else {
@@ -413,6 +447,7 @@ async function handleList(request) {
           cdnPushed: isPushedToCloud,
           cdnBaseUrl: fileCdnUrl,
           isRemote,
+          isProtected: isInsideImagesFolder,
           dimensions: entry.w && entry.h ? { width: entry.w, height: entry.h } : void 0
         });
       }
@@ -1429,6 +1464,7 @@ async function handleProcessAllStream() {
 }
 
 // src/handlers/scan.ts
+import { NextResponse as NextResponse4 } from "next/server";
 import { promises as fs7 } from "fs";
 import path8 from "path";
 import sharp3 from "sharp";
@@ -1444,11 +1480,12 @@ async function handleScanStream() {
       };
       try {
         const meta = await loadMeta();
-        const existingCount = Object.keys(meta).length;
+        const existingCount = Object.keys(meta).filter((k) => !k.startsWith("_")).length;
         const existingKeys = new Set(Object.keys(meta));
         const added = [];
         const renamed = [];
         const errors = [];
+        const orphanedFiles = [];
         const allFiles = [];
         async function scanDir(dir, relativePath = "") {
           try {
@@ -1538,6 +1575,40 @@ async function handleScanStream() {
             errors.push(relativePath);
           }
         }
+        sendEvent({ type: "cleanup", message: "Checking for orphaned thumbnails..." });
+        const expectedThumbnails = /* @__PURE__ */ new Set();
+        const fileEntries = getFileEntries(meta);
+        for (const [imageKey, entry] of fileEntries) {
+          if (entry.c === void 0 && entry.p === 1) {
+            for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+              expectedThumbnails.add(thumbPath);
+            }
+          }
+        }
+        async function findOrphans(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 (entry.isDirectory()) {
+                await findOrphans(fullPath, relPath);
+              } else if (isImageFile(entry.name)) {
+                const publicPath = `/images/${relPath}`;
+                if (!expectedThumbnails.has(publicPath)) {
+                  orphanedFiles.push(publicPath);
+                }
+              }
+            }
+          } catch {
+          }
+        }
+        const imagesDir = path8.join(process.cwd(), "public", "images");
+        try {
+          await findOrphans(imagesDir);
+        } catch {
+        }
         await saveMeta(meta);
         sendEvent({
           type: "complete",
@@ -1545,7 +1616,8 @@ async function handleScanStream() {
           added: added.length,
           renamed: renamed.length,
           errors: errors.length,
-          renamedFiles: renamed
+          renamedFiles: renamed,
+          orphanedFiles: orphanedFiles.length > 0 ? orphanedFiles : void 0
         });
       } catch (error) {
         console.error("Scan failed:", error);
@@ -1563,6 +1635,63 @@ async function handleScanStream() {
     }
   });
 }
+async function handleDeleteOrphans(request) {
+  try {
+    const { paths } = await request.json();
+    if (!paths || !Array.isArray(paths) || paths.length === 0) {
+      return NextResponse4.json({ error: "No paths provided" }, { status: 400 });
+    }
+    const deleted = [];
+    const errors = [];
+    for (const orphanPath of paths) {
+      if (!orphanPath.startsWith("/images/")) {
+        errors.push(`Invalid path: ${orphanPath}`);
+        continue;
+      }
+      const fullPath = path8.join(process.cwd(), "public", orphanPath);
+      try {
+        await fs7.unlink(fullPath);
+        deleted.push(orphanPath);
+      } catch (err) {
+        console.error(`Failed to delete ${orphanPath}:`, err);
+        errors.push(orphanPath);
+      }
+    }
+    const imagesDir = path8.join(process.cwd(), "public", "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));
+            if (!subDirEmpty) isEmpty = false;
+          } else {
+            isEmpty = false;
+          }
+        }
+        if (isEmpty && dir !== imagesDir) {
+          await fs7.rmdir(dir);
+        }
+        return isEmpty;
+      } catch {
+        return true;
+      }
+    }
+    try {
+      await removeEmptyDirs(imagesDir);
+    } catch {
+    }
+    return NextResponse4.json({
+      success: true,
+      deleted: deleted.length,
+      errors: errors.length
+    });
+  } catch (error) {
+    console.error("Failed to delete orphans:", error);
+    return NextResponse4.json({ error: "Failed to delete orphaned files" }, { status: 500 });
+  }
+}
 
 // src/handlers/import.ts
 import sharp4 from "sharp";
@@ -1693,7 +1822,7 @@ async function handleUpdateCdns(request) {
 // src/handlers/index.ts
 async function GET(request) {
   if (process.env.NODE_ENV !== "development") {
-    return NextResponse4.json({ error: "Not available in production" }, { status: 403 });
+    return NextResponse5.json({ error: "Not available in production" }, { status: 403 });
   }
   const pathname = request.nextUrl.pathname;
   const route = pathname.replace(/^\/api\/studio\/?/, "");
@@ -1715,11 +1844,11 @@ async function GET(request) {
   if (route === "cdns") {
     return handleGetCdns();
   }
-  return NextResponse4.json({ error: "Not found" }, { status: 404 });
+  return NextResponse5.json({ error: "Not found" }, { status: 404 });
 }
 async function POST(request) {
   if (process.env.NODE_ENV !== "development") {
-    return NextResponse4.json({ error: "Not available in production" }, { status: 403 });
+    return NextResponse5.json({ error: "Not available in production" }, { status: 403 });
   }
   const pathname = request.nextUrl.pathname;
   const route = pathname.replace(/^\/api\/studio\/?/, "");
@@ -1750,17 +1879,20 @@ async function POST(request) {
   if (route === "scan") {
     return handleScanStream();
   }
+  if (route === "delete-orphans") {
+    return handleDeleteOrphans(request);
+  }
   if (route === "import") {
     return handleImportUrls(request);
   }
   if (route === "cdns") {
     return handleUpdateCdns(request);
   }
-  return NextResponse4.json({ error: "Not found" }, { status: 404 });
+  return NextResponse5.json({ error: "Not found" }, { status: 404 });
 }
 async function DELETE(request) {
   if (process.env.NODE_ENV !== "development") {
-    return NextResponse4.json({ error: "Not available in production" }, { status: 403 });
+    return NextResponse5.json({ error: "Not available in production" }, { status: 403 });
   }
   return handleDelete(request);
 }