@gallop.software/studio 0.1.107 → 0.1.109

package/dist/handlers/index.mjs

@@ -270,14 +270,37 @@ async function handleList(request) {
     const fileEntries = getFileEntries(meta);
     const cdnUrls = getCdnUrls(meta);
     const r2PublicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/$/, "") || "";
-    if (fileEntries.length === 0) {
-      return NextResponse.json({ items: [], isEmpty: true });
-    }
     const relativePath = requestedPath.replace(/^public\/?/, "");
     const pathPrefix = relativePath ? `/${relativePath}/` : "/";
     const items = [];
     const seenFolders = /* @__PURE__ */ new Set();
     const metaKeys = fileEntries.map(([key]) => key);
+    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 (!seenFolders.has(entry.name)) {
+            seenFolders.add(entry.name);
+            const folderPrefix = pathPrefix === "/" ? `/${entry.name}/` : `${pathPrefix}${entry.name}/`;
+            let fileCount = 0;
+            for (const k of metaKeys) {
+              if (k.startsWith(folderPrefix)) fileCount++;
+            }
+            items.push({
+              name: entry.name,
+              path: relativePath ? `public/${relativePath}/${entry.name}` : `public/${entry.name}`,
+              type: "folder",
+              fileCount
+            });
+          }
+        }
+      }
+    } catch {
+    }
+    if (fileEntries.length === 0 && items.length === 0) {
+      return NextResponse.json({ items: [], isEmpty: true });
+    }
     for (const [key, entry] of fileEntries) {
       if (!key.startsWith(pathPrefix) && pathPrefix !== "/") continue;
       if (pathPrefix === "/" && !key.startsWith("/")) continue;
@@ -780,162 +803,189 @@ async function handleRename(request) {
     return NextResponse2.json({ error: "Failed to rename" }, { status: 500 });
   }
 }
-async function handleMove(request) {
-  try {
-    const { paths, destination } = await request.json();
-    if (!paths || !Array.isArray(paths) || paths.length === 0) {
-      return NextResponse2.json({ error: "Paths are required" }, { status: 400 });
-    }
-    if (!destination || typeof destination !== "string") {
-      return NextResponse2.json({ error: "Destination is required" }, { status: 400 });
-    }
-    const safeDestination = destination.replace(/\.\./g, "");
-    const absoluteDestination = path6.join(process.cwd(), safeDestination);
-    if (!absoluteDestination.startsWith(path6.join(process.cwd(), "public"))) {
-      return NextResponse2.json({ error: "Invalid destination" }, { status: 400 });
-    }
-    await fs5.mkdir(absoluteDestination, { recursive: true });
-    const moved = [];
-    const errors = [];
-    const meta = await loadMeta();
-    const cdnUrls = getCdnUrls(meta);
-    const r2PublicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/$/, "") || "";
-    let metaChanged = false;
-    for (const itemPath of paths) {
-      const safePath = itemPath.replace(/\.\./g, "");
-      const itemName = path6.basename(safePath);
-      const newAbsolutePath = path6.join(absoluteDestination, itemName);
-      const oldRelativePath = safePath.replace(/^public\//, "");
-      const newRelativePath = path6.join(safeDestination.replace(/^public\//, ""), itemName);
-      const oldKey = "/" + oldRelativePath;
-      const newKey = "/" + newRelativePath;
-      if (meta[newKey]) {
-        errors.push(`${itemName} already exists in destination`);
-        continue;
-      }
-      const entry = meta[oldKey];
-      const isImage = isImageFile(itemName);
-      const isInCloud = entry?.c !== void 0;
-      const fileCdnUrl = isInCloud && entry.c !== void 0 ? cdnUrls[entry.c] : void 0;
-      const isRemote = isInCloud && (!r2PublicUrl || fileCdnUrl !== r2PublicUrl);
-      const isPushedToR2 = isInCloud && r2PublicUrl && fileCdnUrl === r2PublicUrl;
-      const hasProcessedThumbnails = entry?.p === 1;
+async function handleMoveStream(request) {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      const sendEvent = (data) => {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+
+`));
+      };
       try {
-        if (isRemote && isImage) {
-          const remoteUrl = `${fileCdnUrl}${oldKey}`;
-          const buffer = await downloadFromRemoteUrl(remoteUrl);
-          await fs5.mkdir(path6.dirname(newAbsolutePath), { recursive: true });
-          await fs5.writeFile(newAbsolutePath, buffer);
-          const newEntry = {
-            w: entry?.w,
-            h: entry?.h,
-            b: entry?.b
-            // Don't copy p since remote images don't have local thumbnails
-            // Don't copy c since it's now local
-          };
-          delete meta[oldKey];
-          meta[newKey] = newEntry;
-          metaChanged = true;
-          moved.push(itemPath);
-        } else if (isPushedToR2 && isImage) {
-          const buffer = await downloadFromCdn(oldKey);
-          await fs5.mkdir(path6.dirname(newAbsolutePath), { recursive: true });
-          await fs5.writeFile(newAbsolutePath, buffer);
-          const newEntry = {
-            w: entry?.w,
-            h: entry?.h,
-            b: entry?.b
-          };
-          if (hasProcessedThumbnails) {
-            const processedEntry = await processImage(buffer, newKey);
-            newEntry.w = processedEntry.w;
-            newEntry.h = processedEntry.h;
-            newEntry.b = processedEntry.b;
-            newEntry.p = 1;
-          }
-          await uploadOriginalToCdn(newKey);
-          if (hasProcessedThumbnails) {
-            await uploadToCdn(newKey);
-          }
-          await deleteFromCdn(oldKey, hasProcessedThumbnails);
-          try {
-            await fs5.unlink(newAbsolutePath);
-          } catch {
-          }
-          if (hasProcessedThumbnails) {
-            await deleteLocalThumbnails(newKey);
-          }
-          newEntry.c = entry?.c;
-          delete meta[oldKey];
-          meta[newKey] = newEntry;
-          metaChanged = true;
-          moved.push(itemPath);
-        } else {
-          const absolutePath = path6.join(process.cwd(), safePath);
-          if (absoluteDestination.startsWith(absolutePath + path6.sep)) {
-            errors.push(`Cannot move ${itemName} into itself`);
-            continue;
-          }
-          try {
-            await fs5.access(absolutePath);
-          } catch {
-            errors.push(`${itemName} not found`);
-            continue;
-          }
-          try {
-            await fs5.access(newAbsolutePath);
+        const { paths, destination } = await request.json();
+        if (!paths || !Array.isArray(paths) || paths.length === 0) {
+          sendEvent({ type: "error", message: "Paths are required" });
+          controller.close();
+          return;
+        }
+        if (!destination || typeof destination !== "string") {
+          sendEvent({ type: "error", message: "Destination is required" });
+          controller.close();
+          return;
+        }
+        const safeDestination = destination.replace(/\.\./g, "");
+        const absoluteDestination = path6.join(process.cwd(), safeDestination);
+        if (!absoluteDestination.startsWith(path6.join(process.cwd(), "public"))) {
+          sendEvent({ type: "error", message: "Invalid destination" });
+          controller.close();
+          return;
+        }
+        await fs5.mkdir(absoluteDestination, { recursive: true });
+        const meta = await loadMeta();
+        const cdnUrls = getCdnUrls(meta);
+        const r2PublicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/$/, "") || "";
+        const moved = [];
+        const errors = [];
+        const total = paths.length;
+        sendEvent({ type: "start", total });
+        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 oldRelativePath = safePath.replace(/^public\//, "");
+          const newRelativePath = path6.join(safeDestination.replace(/^public\//, ""), itemName);
+          const oldKey = "/" + oldRelativePath;
+          const newKey = "/" + newRelativePath;
+          sendEvent({
+            type: "progress",
+            current: i + 1,
+            total,
+            percent: Math.round((i + 1) / total * 100),
+            currentFile: itemName
+          });
+          if (meta[newKey]) {
             errors.push(`${itemName} already exists in destination`);
             continue;
-          } catch {
           }
-          await fs5.rename(absolutePath, newAbsolutePath);
-          const stats = await fs5.stat(newAbsolutePath);
-          if (stats.isFile() && isImage && entry) {
-            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 entry = meta[oldKey];
+          const isImage = isImageFile(itemName);
+          const isInCloud = entry?.c !== void 0;
+          const fileCdnUrl = isInCloud && entry.c !== void 0 ? cdnUrls[entry.c] : void 0;
+          const isRemote = isInCloud && (!r2PublicUrl || fileCdnUrl !== r2PublicUrl);
+          const isPushedToR2 = isInCloud && r2PublicUrl && fileCdnUrl === r2PublicUrl;
+          const hasProcessedThumbnails = entry?.p === 1;
+          try {
+            if (isRemote && isImage) {
+              const remoteUrl = `${fileCdnUrl}${oldKey}`;
+              const buffer = await downloadFromRemoteUrl(remoteUrl);
+              await fs5.mkdir(path6.dirname(newAbsolutePath), { recursive: true });
+              await fs5.writeFile(newAbsolutePath, buffer);
+              const newEntry = {
+                w: entry?.w,
+                h: entry?.h,
+                b: entry?.b
+              };
+              delete meta[oldKey];
+              meta[newKey] = newEntry;
+              moved.push(itemPath);
+            } else if (isPushedToR2 && isImage) {
+              const buffer = await downloadFromCdn(oldKey);
+              await fs5.mkdir(path6.dirname(newAbsolutePath), { recursive: true });
+              await fs5.writeFile(newAbsolutePath, buffer);
+              const newEntry = {
+                w: entry?.w,
+                h: entry?.h,
+                b: entry?.b
+              };
+              if (hasProcessedThumbnails) {
+                const processedEntry = await processImage(buffer, newKey);
+                newEntry.w = processedEntry.w;
+                newEntry.h = processedEntry.h;
+                newEntry.b = processedEntry.b;
+                newEntry.p = 1;
+              }
+              await uploadOriginalToCdn(newKey);
+              if (hasProcessedThumbnails) {
+                await uploadToCdn(newKey);
+              }
+              await deleteFromCdn(oldKey, hasProcessedThumbnails);
               try {
-                await fs5.rename(oldThumbPath, newThumbPath);
+                await fs5.unlink(newAbsolutePath);
               } catch {
               }
-            }
-            delete meta[oldKey];
-            meta[newKey] = entry;
-            metaChanged = true;
-          } else if (stats.isDirectory()) {
-            const oldPrefix = oldKey + "/";
-            const newPrefix = newKey + "/";
-            for (const key of Object.keys(meta)) {
-              if (key.startsWith(oldPrefix)) {
-                const newMetaKey = newPrefix + key.slice(oldPrefix.length);
-                meta[newMetaKey] = meta[key];
-                delete meta[key];
-                metaChanged = true;
+              if (hasProcessedThumbnails) {
+                await deleteLocalThumbnails(newKey);
+              }
+              newEntry.c = entry?.c;
+              delete meta[oldKey];
+              meta[newKey] = newEntry;
+              moved.push(itemPath);
+            } else {
+              const absolutePath = path6.join(process.cwd(), safePath);
+              if (absoluteDestination.startsWith(absolutePath + path6.sep)) {
+                errors.push(`Cannot move ${itemName} into itself`);
+                continue;
+              }
+              try {
+                await fs5.access(absolutePath);
+              } catch {
+                errors.push(`${itemName} not found`);
+                continue;
+              }
+              try {
+                await fs5.access(newAbsolutePath);
+                errors.push(`${itemName} already exists in destination`);
+                continue;
+              } catch {
               }
+              await fs5.rename(absolutePath, newAbsolutePath);
+              const stats = await fs5.stat(newAbsolutePath);
+              if (stats.isFile() && isImage && entry) {
+                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 });
+                  try {
+                    await fs5.rename(oldThumbPath, newThumbPath);
+                  } catch {
+                  }
+                }
+                delete meta[oldKey];
+                meta[newKey] = entry;
+              } else if (stats.isDirectory()) {
+                const oldPrefix = oldKey + "/";
+                const newPrefix = newKey + "/";
+                for (const key of Object.keys(meta)) {
+                  if (key.startsWith(oldPrefix)) {
+                    const newMetaKey = newPrefix + key.slice(oldPrefix.length);
+                    meta[newMetaKey] = meta[key];
+                    delete meta[key];
+                  }
+                }
+              }
+              moved.push(itemPath);
             }
+          } catch (err) {
+            console.error(`Failed to move ${itemName}:`, err);
+            errors.push(`Failed to move ${itemName}`);
           }
-          moved.push(itemPath);
         }
-      } catch (err) {
-        console.error(`Failed to move ${itemName}:`, err);
-        errors.push(`Failed to move ${itemName}`);
+        await saveMeta(meta);
+        sendEvent({
+          type: "complete",
+          moved: moved.length,
+          errors: errors.length,
+          errorMessages: errors
+        });
+      } catch (error) {
+        console.error("Failed to move:", error);
+        sendEvent({ type: "error", message: "Failed to move items" });
+      } finally {
+        controller.close();
       }
     }
-    if (metaChanged) {
-      await saveMeta(meta);
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive"
     }
-    return NextResponse2.json({
-      success: errors.length === 0,
-      moved,
-      errors: errors.length > 0 ? errors : void 0
-    });
-  } catch (error) {
-    console.error("Failed to move:", error);
-    return NextResponse2.json({ error: "Failed to move items" }, { status: 500 });
-  }
+  });
 }
 
 // src/handlers/images.ts
@@ -1591,7 +1641,7 @@ async function POST(request) {
     return handleRename(request);
   }
   if (route === "move") {
-    return handleMove(request);
+    return handleMoveStream(request);
   }
   if (route === "scan") {
     return handleScanStream();