@gallop.software/studio 0.1.105 → 0.1.107

package/dist/handlers/index.js

@@ -210,6 +210,56 @@ async function deleteLocalThumbnails(imageKey) {
     }
   }
 }
+async function downloadFromRemoteUrl(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download from ${url}: ${response.status}`);
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  return Buffer.from(arrayBuffer);
+}
+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 = _path2.default.join(process.cwd(), "public", imageKey);
+  const fileBuffer = await _fs.promises.readFile(localPath);
+  await r2.send(
+    new (0, _clients3.PutObjectCommand)({
+      Bucket: bucketName,
+      Key: imageKey.replace(/^\//, ""),
+      Body: fileBuffer,
+      ContentType: getContentType(imageKey)
+    })
+  );
+}
+async function deleteFromCdn(imageKey, hasThumbnails) {
+  const bucketName = process.env.CLOUDFLARE_R2_BUCKET_NAME;
+  if (!bucketName) throw new Error("R2 bucket not configured");
+  const r2 = getR2Client();
+  try {
+    await r2.send(
+      new (0, _clients3.DeleteObjectCommand)({
+        Bucket: bucketName,
+        Key: imageKey.replace(/^\//, "")
+      })
+    );
+  } catch (e4) {
+  }
+  if (hasThumbnails) {
+    for (const thumbPath of _chunkLEOQKJCLjs.getAllThumbnailPaths.call(void 0, imageKey)) {
+      try {
+        await r2.send(
+          new (0, _clients3.DeleteObjectCommand)({
+            Bucket: bucketName,
+            Key: thumbPath.replace(/^\//, "")
+          })
+        );
+      } catch (e5) {
+      }
+    }
+  }
+}
 
 // src/handlers/list.ts
 async function handleList(request) {
@@ -273,7 +323,7 @@ async function handleList(request) {
               await _fs.promises.access(localThumbPath);
               thumbnail = thumbPath;
               hasThumbnail = true;
-            } catch (e4) {
+            } catch (e6) {
               thumbnail = key;
               hasThumbnail = false;
             }
@@ -292,7 +342,7 @@ async function handleList(request) {
             const filePath = _path2.default.join(process.cwd(), "public", key);
             const stats = await _fs.promises.stat(filePath);
             fileSize = stats.size;
-          } catch (e5) {
+          } catch (e7) {
           }
         }
         items.push({
@@ -352,7 +402,7 @@ async function handleSearch(request) {
             await _fs.promises.access(localThumbPath);
             thumbnail = thumbPath;
             hasThumbnail = true;
-          } catch (e6) {
+          } catch (e8) {
             thumbnail = key;
             hasThumbnail = false;
           }
@@ -534,7 +584,7 @@ async function handleUpload(request) {
           w: metadata.width || 0,
           h: metadata.height || 0
         };
-      } catch (e7) {
+      } catch (e9) {
         meta[imageKey] = { w: 0, h: 0 };
       }
     } else {
@@ -583,7 +633,7 @@ async function handleDelete(request) {
                     const absoluteThumbPath = _path2.default.join(process.cwd(), "public", thumbPath);
                     try {
                       await _fs.promises.unlink(absoluteThumbPath);
-                    } catch (e8) {
+                    } catch (e10) {
                     }
                   }
                 }
@@ -599,14 +649,14 @@ async function handleDelete(request) {
                   const absoluteThumbPath = _path2.default.join(process.cwd(), "public", thumbPath);
                   try {
                     await _fs.promises.unlink(absoluteThumbPath);
-                  } catch (e9) {
+                  } catch (e11) {
                   }
                 }
               }
               delete meta[imageKey];
             }
           }
-        } catch (e10) {
+        } catch (e12) {
           if (entry) {
             delete meta[imageKey];
           } else {
@@ -659,7 +709,7 @@ async function handleCreateFolder(request) {
     try {
       await _fs.promises.access(folderPath);
       return _server.NextResponse.json({ error: "A folder with this name already exists" }, { status: 400 });
-    } catch (e11) {
+    } catch (e13) {
     }
     await _fs.promises.mkdir(folderPath, { recursive: true });
     return _server.NextResponse.json({ success: true, path: _path2.default.join(safePath, sanitizedName) });
@@ -687,13 +737,13 @@ async function handleRename(request) {
     }
     try {
       await _fs.promises.access(absoluteOldPath);
-    } catch (e12) {
+    } catch (e14) {
       return _server.NextResponse.json({ error: "File or folder not found" }, { status: 404 });
     }
     try {
       await _fs.promises.access(absoluteNewPath);
       return _server.NextResponse.json({ error: "An item with this name already exists" }, { status: 400 });
-    } catch (e13) {
+    } catch (e15) {
     }
     const stats = await _fs.promises.stat(absoluteOldPath);
     const isFile = stats.isFile();
@@ -715,7 +765,7 @@ async function handleRename(request) {
           await _fs.promises.mkdir(_path2.default.dirname(newThumbPath), { recursive: true });
           try {
             await _fs.promises.rename(oldThumbPath, newThumbPath);
-          } catch (e14) {
+          } catch (e16) {
           }
         }
         delete meta[oldKey];
@@ -744,49 +794,103 @@ async function handleMove(request) {
     if (!absoluteDestination.startsWith(_path2.default.join(process.cwd(), "public"))) {
       return _server.NextResponse.json({ error: "Invalid destination" }, { status: 400 });
     }
-    try {
-      const destStats = await _fs.promises.stat(absoluteDestination);
-      if (!destStats.isDirectory()) {
-        return _server.NextResponse.json({ error: "Destination is not a folder" }, { status: 400 });
-      }
-    } catch (e15) {
-      return _server.NextResponse.json({ error: "Destination folder not found" }, { status: 404 });
-    }
+    await _fs.promises.mkdir(absoluteDestination, { recursive: true });
     const moved = [];
     const errors = [];
     const meta = await loadMeta();
+    const cdnUrls = getCdnUrls(meta);
+    const r2PublicUrl = _optionalChain([process, 'access', _14 => _14.env, 'access', _15 => _15.CLOUDFLARE_R2_PUBLIC_URL, 'optionalAccess', _16 => _16.replace, 'call', _17 => _17(/\/$/, "")]) || "";
     let metaChanged = false;
     for (const itemPath of paths) {
       const safePath = itemPath.replace(/\.\./g, "");
-      const absolutePath = _path2.default.join(process.cwd(), safePath);
       const itemName = _path2.default.basename(safePath);
       const newAbsolutePath = _path2.default.join(absoluteDestination, itemName);
-      if (absoluteDestination.startsWith(absolutePath + _path2.default.sep)) {
-        errors.push(`Cannot move ${itemName} into itself`);
-        continue;
-      }
-      try {
-        await _fs.promises.access(absolutePath);
-      } catch (e16) {
-        errors.push(`${itemName} not found`);
-        continue;
-      }
-      try {
-        await _fs.promises.access(newAbsolutePath);
+      const oldRelativePath = safePath.replace(/^public\//, "");
+      const newRelativePath = _path2.default.join(safeDestination.replace(/^public\//, ""), itemName);
+      const oldKey = "/" + oldRelativePath;
+      const newKey = "/" + newRelativePath;
+      if (meta[newKey]) {
         errors.push(`${itemName} already exists in destination`);
         continue;
-      } catch (e17) {
       }
+      const entry = meta[oldKey];
+      const isImage = isImageFile(itemName);
+      const isInCloud = _optionalChain([entry, 'optionalAccess', _18 => _18.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 = _optionalChain([entry, 'optionalAccess', _19 => _19.p]) === 1;
       try {
-        await _fs.promises.rename(absolutePath, newAbsolutePath);
-        const stats = await _fs.promises.stat(newAbsolutePath);
-        if (stats.isFile() && isImageFile(itemName)) {
-          const oldRelativePath = safePath.replace(/^public\//, "");
-          const newRelativePath = _path2.default.join(safeDestination.replace(/^public\//, ""), itemName);
-          const oldKey = "/" + oldRelativePath;
-          const newKey = "/" + newRelativePath;
-          if (meta[oldKey]) {
-            const entry = meta[oldKey];
+        if (isRemote && isImage) {
+          const remoteUrl = `${fileCdnUrl}${oldKey}`;
+          const buffer = await downloadFromRemoteUrl(remoteUrl);
+          await _fs.promises.mkdir(_path2.default.dirname(newAbsolutePath), { recursive: true });
+          await _fs.promises.writeFile(newAbsolutePath, buffer);
+          const newEntry = {
+            w: _optionalChain([entry, 'optionalAccess', _20 => _20.w]),
+            h: _optionalChain([entry, 'optionalAccess', _21 => _21.h]),
+            b: _optionalChain([entry, 'optionalAccess', _22 => _22.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 _fs.promises.mkdir(_path2.default.dirname(newAbsolutePath), { recursive: true });
+          await _fs.promises.writeFile(newAbsolutePath, buffer);
+          const newEntry = {
+            w: _optionalChain([entry, 'optionalAccess', _23 => _23.w]),
+            h: _optionalChain([entry, 'optionalAccess', _24 => _24.h]),
+            b: _optionalChain([entry, 'optionalAccess', _25 => _25.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 _fs.promises.unlink(newAbsolutePath);
+          } catch (e17) {
+          }
+          if (hasProcessedThumbnails) {
+            await deleteLocalThumbnails(newKey);
+          }
+          newEntry.c = _optionalChain([entry, 'optionalAccess', _26 => _26.c]);
+          delete meta[oldKey];
+          meta[newKey] = newEntry;
+          metaChanged = true;
+          moved.push(itemPath);
+        } else {
+          const absolutePath = _path2.default.join(process.cwd(), safePath);
+          if (absoluteDestination.startsWith(absolutePath + _path2.default.sep)) {
+            errors.push(`Cannot move ${itemName} into itself`);
+            continue;
+          }
+          try {
+            await _fs.promises.access(absolutePath);
+          } catch (e18) {
+            errors.push(`${itemName} not found`);
+            continue;
+          }
+          try {
+            await _fs.promises.access(newAbsolutePath);
+            errors.push(`${itemName} already exists in destination`);
+            continue;
+          } catch (e19) {
+          }
+          await _fs.promises.rename(absolutePath, newAbsolutePath);
+          const stats = await _fs.promises.stat(newAbsolutePath);
+          if (stats.isFile() && isImage && entry) {
             const oldThumbPaths = _chunkLEOQKJCLjs.getAllThumbnailPaths.call(void 0, oldKey);
             const newThumbPaths = _chunkLEOQKJCLjs.getAllThumbnailPaths.call(void 0, newKey);
             for (let i = 0; i < oldThumbPaths.length; i++) {
@@ -795,16 +899,28 @@ async function handleMove(request) {
               await _fs.promises.mkdir(_path2.default.dirname(newThumbPath), { recursive: true });
               try {
                 await _fs.promises.rename(oldThumbPath, newThumbPath);
-              } catch (e18) {
+              } catch (e20) {
               }
             }
             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;
+              }
+            }
           }
+          moved.push(itemPath);
         }
-        moved.push(itemPath);
-      } catch (e19) {
+      } catch (err) {
+        console.error(`Failed to move ${itemName}:`, err);
         errors.push(`Failed to move ${itemName}`);
       }
     }
@@ -895,7 +1011,7 @@ async function handleSync(request) {
                 ContentType: getContentType(thumbPath)
               })
             );
-          } catch (e20) {
+          } catch (e21) {
           }
         }
         entry.c = cdnIndex;
@@ -903,12 +1019,12 @@ async function handleSync(request) {
           const localPath = _path2.default.join(process.cwd(), "public", thumbPath);
           try {
             await _fs.promises.unlink(localPath);
-          } catch (e21) {
+          } catch (e22) {
           }
         }
         try {
           await _fs.promises.unlink(originalLocalPath);
-        } catch (e22) {
+        } catch (e23) {
         }
         pushed.push(imageKey);
       } catch (error) {
@@ -940,12 +1056,12 @@ async function handleReprocess(request) {
       try {
         let buffer;
         const entry = getMetaEntry(meta, imageKey);
-        const isPushedToCloud = _optionalChain([entry, 'optionalAccess', _14 => _14.c]) !== void 0;
-        const existingCdnIndex = _optionalChain([entry, 'optionalAccess', _15 => _15.c]);
+        const isPushedToCloud = _optionalChain([entry, 'optionalAccess', _27 => _27.c]) !== void 0;
+        const existingCdnIndex = _optionalChain([entry, 'optionalAccess', _28 => _28.c]);
         const originalPath = _path2.default.join(process.cwd(), "public", imageKey);
         try {
           buffer = await _fs.promises.readFile(originalPath);
-        } catch (e23) {
+        } catch (e24) {
           if (isPushedToCloud) {
             buffer = await downloadFromCdn(imageKey);
             const dir = _path2.default.dirname(originalPath);
@@ -962,7 +1078,7 @@ async function handleReprocess(request) {
           await deleteLocalThumbnails(imageKey);
           try {
             await _fs.promises.unlink(originalPath);
-          } catch (e24) {
+          } catch (e25) {
           }
         }
         meta[imageKey] = updatedEntry;
@@ -1062,7 +1178,7 @@ async function handleProcessAllStream() {
               await deleteLocalThumbnails(key);
               try {
                 await _fs.promises.unlink(fullPath);
-              } catch (e25) {
+              } catch (e26) {
               }
             }
             processed.push(key.slice(1));
@@ -1101,13 +1217,13 @@ async function handleProcessAllStream() {
                 }
               }
             }
-          } catch (e26) {
+          } catch (e27) {
           }
         }
         const imagesDir = _path2.default.join(process.cwd(), "public", "images");
         try {
           await findOrphans(imagesDir);
-        } catch (e27) {
+        } catch (e28) {
         }
         async function removeEmptyDirs(dir) {
           try {
@@ -1125,13 +1241,13 @@ async function handleProcessAllStream() {
               await _fs.promises.rmdir(dir);
             }
             return isEmpty;
-          } catch (e28) {
+          } catch (e29) {
             return true;
           }
         }
         try {
           await removeEmptyDirs(imagesDir);
-        } catch (e29) {
+        } catch (e30) {
         }
         await saveMeta(meta);
         sendEvent({
@@ -1194,7 +1310,7 @@ async function handleScanStream() {
                 allFiles.push({ relativePath: relPath, fullPath });
               }
             }
-          } catch (e30) {
+          } catch (e31) {
           }
         }
         const publicDir = _path2.default.join(process.cwd(), "public");
@@ -1254,7 +1370,7 @@ async function handleScanStream() {
                     h: metadata.height || 0,
                     b: blurhash
                   };
-                } catch (e31) {
+                } catch (e32) {
                   meta[imageKey] = { w: 0, h: 0 };
                 }
               }