@gallop.software/studio 0.1.113 → 0.1.115

package/dist/handlers/index.js

@@ -160,6 +160,31 @@ async function processImage(buffer, imageKey) {
 
 
 var _clients3 = require('@aws-sdk/client-s3');
+async function purgeCloudflareCache(urls) {
+  const zoneId = process.env.CLOUDFLARE_ZONE_ID;
+  const apiToken = process.env.CLOUDFLARE_API_TOKEN;
+  if (!zoneId || !apiToken || urls.length === 0) {
+    return;
+  }
+  try {
+    const response = await fetch(
+      `https://api.cloudflare.com/client/v4/zones/${zoneId}/purge_cache`,
+      {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${apiToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ files: urls })
+      }
+    );
+    if (!response.ok) {
+      console.error("Cache purge failed:", await response.text());
+    }
+  } catch (error) {
+    console.error("Cache purge error:", error);
+  }
+}
 function getR2Client() {
   const accountId = process.env.CLOUDFLARE_R2_ACCOUNT_ID;
   const accessKeyId = process.env.CLOUDFLARE_R2_ACCESS_KEY_ID;
@@ -1022,7 +1047,7 @@ async function handleSync(request) {
   const accessKeyId = process.env.CLOUDFLARE_R2_ACCESS_KEY_ID;
   const secretAccessKey = process.env.CLOUDFLARE_R2_SECRET_ACCESS_KEY;
   const bucketName = process.env.CLOUDFLARE_R2_BUCKET_NAME;
-  const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL;
+  const publicUrl = _optionalChain([process, 'access', _27 => _27.env, 'access', _28 => _28.CLOUDFLARE_R2_PUBLIC_URL, 'optionalAccess', _29 => _29.replace, 'call', _30 => _30(/\/\s*$/, "")]);
   if (!accountId || !accessKeyId || !secretAccessKey || !bucketName || !publicUrl) {
     return _server.NextResponse.json(
       { error: "R2 not configured. Set CLOUDFLARE_R2_* environment variables." },
@@ -1035,6 +1060,7 @@ async function handleSync(request) {
       return _server.NextResponse.json({ error: "No image keys provided" }, { status: 400 });
     }
     const meta = await loadMeta();
+    const cdnUrls = getCdnUrls(meta);
     const cdnIndex = getOrAddCdnIndex(meta, publicUrl);
     const r2 = new (0, _clients3.S3Client)({
       region: "auto",
@@ -1043,63 +1069,80 @@ async function handleSync(request) {
     });
     const pushed = [];
     const errors = [];
+    const urlsToPurge = [];
     for (const imageKey of imageKeys) {
       const entry = getMetaEntry(meta, imageKey);
       if (!entry) {
         errors.push(`Image not found in meta: ${imageKey}. Run Scan first.`);
         continue;
       }
-      if (entry.c !== void 0) {
+      const existingCdnUrl = entry.c !== void 0 ? cdnUrls[entry.c] : void 0;
+      const isAlreadyInOurR2 = existingCdnUrl === publicUrl;
+      if (isAlreadyInOurR2) {
         pushed.push(imageKey);
         continue;
       }
-      if (!entry.p) {
+      const isRemote = entry.c !== void 0 && existingCdnUrl !== publicUrl;
+      if (!isRemote && !entry.p) {
         errors.push(`Image not processed: ${imageKey}. Run Process Images first.`);
         continue;
       }
       try {
-        const originalLocalPath = _path2.default.join(process.cwd(), "public", imageKey);
-        try {
-          const originalBuffer = await _fs.promises.readFile(originalLocalPath);
-          await r2.send(
-            new (0, _clients3.PutObjectCommand)({
-              Bucket: bucketName,
-              Key: imageKey.replace(/^\//, ""),
-              Body: originalBuffer,
-              ContentType: getContentType(imageKey)
-            })
-          );
-        } catch (err) {
-          errors.push(`Original file not found: ${imageKey}`);
-          continue;
-        }
-        for (const thumbPath of _chunkLEOQKJCLjs.getAllThumbnailPaths.call(void 0, imageKey)) {
-          const localPath = _path2.default.join(process.cwd(), "public", thumbPath);
+        let originalBuffer;
+        if (isRemote) {
+          const remoteUrl = `${existingCdnUrl}${imageKey}`;
+          originalBuffer = await downloadFromRemoteUrl(remoteUrl);
+        } else {
+          const originalLocalPath = _path2.default.join(process.cwd(), "public", imageKey);
           try {
-            const fileBuffer = await _fs.promises.readFile(localPath);
-            await r2.send(
-              new (0, _clients3.PutObjectCommand)({
-                Bucket: bucketName,
-                Key: thumbPath.replace(/^\//, ""),
-                Body: fileBuffer,
-                ContentType: getContentType(thumbPath)
-              })
-            );
+            originalBuffer = await _fs.promises.readFile(originalLocalPath);
           } catch (e23) {
+            errors.push(`Original file not found: ${imageKey}`);
+            continue;
+          }
+        }
+        await r2.send(
+          new (0, _clients3.PutObjectCommand)({
+            Bucket: bucketName,
+            Key: imageKey.replace(/^\//, ""),
+            Body: originalBuffer,
+            ContentType: getContentType(imageKey)
+          })
+        );
+        urlsToPurge.push(`${publicUrl}${imageKey}`);
+        if (!isRemote && entry.p) {
+          for (const thumbPath of _chunkLEOQKJCLjs.getAllThumbnailPaths.call(void 0, imageKey)) {
+            const localPath = _path2.default.join(process.cwd(), "public", thumbPath);
+            try {
+              const fileBuffer = await _fs.promises.readFile(localPath);
+              await r2.send(
+                new (0, _clients3.PutObjectCommand)({
+                  Bucket: bucketName,
+                  Key: thumbPath.replace(/^\//, ""),
+                  Body: fileBuffer,
+                  ContentType: getContentType(thumbPath)
+                })
+              );
+              urlsToPurge.push(`${publicUrl}${thumbPath}`);
+            } catch (e24) {
+            }
           }
         }
         entry.c = cdnIndex;
-        for (const thumbPath of _chunkLEOQKJCLjs.getAllThumbnailPaths.call(void 0, imageKey)) {
-          const localPath = _path2.default.join(process.cwd(), "public", thumbPath);
+        if (!isRemote) {
+          const originalLocalPath = _path2.default.join(process.cwd(), "public", imageKey);
+          for (const thumbPath of _chunkLEOQKJCLjs.getAllThumbnailPaths.call(void 0, imageKey)) {
+            const localPath = _path2.default.join(process.cwd(), "public", thumbPath);
+            try {
+              await _fs.promises.unlink(localPath);
+            } catch (e25) {
+            }
+          }
           try {
-            await _fs.promises.unlink(localPath);
-          } catch (e24) {
+            await _fs.promises.unlink(originalLocalPath);
+          } catch (e26) {
           }
         }
-        try {
-          await _fs.promises.unlink(originalLocalPath);
-        } catch (e25) {
-        }
         pushed.push(imageKey);
       } catch (error) {
         console.error(`Failed to push ${imageKey}:`, error);
@@ -1107,53 +1150,71 @@ async function handleSync(request) {
       }
     }
     await saveMeta(meta);
+    if (urlsToPurge.length > 0) {
+      await purgeCloudflareCache(urlsToPurge);
+    }
     return _server.NextResponse.json({
       success: true,
       pushed,
       errors: errors.length > 0 ? errors : void 0
     });
   } catch (error) {
-    console.error("Failed to sync:", error);
-    return _server.NextResponse.json({ error: "Failed to sync to CDN" }, { status: 500 });
+    console.error("Failed to push:", error);
+    return _server.NextResponse.json({ error: "Failed to push to CDN" }, { status: 500 });
   }
 }
 async function handleReprocess(request) {
+  const publicUrl = _optionalChain([process, 'access', _31 => _31.env, 'access', _32 => _32.CLOUDFLARE_R2_PUBLIC_URL, 'optionalAccess', _33 => _33.replace, 'call', _34 => _34(/\/\s*$/, "")]);
   try {
     const { imageKeys } = await request.json();
     if (!imageKeys || !Array.isArray(imageKeys) || imageKeys.length === 0) {
       return _server.NextResponse.json({ error: "No image keys provided" }, { status: 400 });
     }
     const meta = await loadMeta();
+    const cdnUrls = getCdnUrls(meta);
     const processed = [];
     const errors = [];
+    const urlsToPurge = [];
     for (const imageKey of imageKeys) {
       try {
         let buffer;
         const entry = getMetaEntry(meta, imageKey);
-        const isPushedToCloud = _optionalChain([entry, 'optionalAccess', _27 => _27.c]) !== void 0;
-        const existingCdnIndex = _optionalChain([entry, 'optionalAccess', _28 => _28.c]);
+        const existingCdnIndex = _optionalChain([entry, 'optionalAccess', _35 => _35.c]);
+        const existingCdnUrl = existingCdnIndex !== void 0 ? cdnUrls[existingCdnIndex] : void 0;
+        const isInOurR2 = existingCdnUrl === publicUrl;
+        const isRemote = existingCdnIndex !== void 0 && !isInOurR2;
         const originalPath = _path2.default.join(process.cwd(), "public", imageKey);
         try {
           buffer = await _fs.promises.readFile(originalPath);
-        } catch (e26) {
-          if (isPushedToCloud) {
+        } catch (e27) {
+          if (isInOurR2) {
             buffer = await downloadFromCdn(imageKey);
             const dir = _path2.default.dirname(originalPath);
             await _fs.promises.mkdir(dir, { recursive: true });
             await _fs.promises.writeFile(originalPath, buffer);
+          } else if (isRemote && existingCdnUrl) {
+            const remoteUrl = `${existingCdnUrl}${imageKey}`;
+            buffer = await downloadFromRemoteUrl(remoteUrl);
+            const dir = _path2.default.dirname(originalPath);
+            await _fs.promises.mkdir(dir, { recursive: true });
+            await _fs.promises.writeFile(originalPath, buffer);
           } else {
             throw new Error(`File not found: ${imageKey}`);
           }
         }
         const updatedEntry = await processImage(buffer, imageKey);
-        if (isPushedToCloud) {
+        if (isInOurR2) {
           updatedEntry.c = existingCdnIndex;
           await uploadToCdn(imageKey);
+          for (const thumbPath of _chunkLEOQKJCLjs.getAllThumbnailPaths.call(void 0, imageKey)) {
+            urlsToPurge.push(`${publicUrl}${thumbPath}`);
+          }
           await deleteLocalThumbnails(imageKey);
           try {
             await _fs.promises.unlink(originalPath);
-          } catch (e27) {
+          } catch (e28) {
           }
+        } else if (isRemote) {
         }
         meta[imageKey] = updatedEntry;
         processed.push(imageKey);
@@ -1163,6 +1224,9 @@ async function handleReprocess(request) {
       }
     }
     await saveMeta(meta);
+    if (urlsToPurge.length > 0) {
+      await purgeCloudflareCache(urlsToPurge);
+    }
     return _server.NextResponse.json({
       success: true,
       processed,
@@ -1174,6 +1238,7 @@ async function handleReprocess(request) {
   }
 }
 async function handleProcessAllStream() {
+  const publicUrl = _optionalChain([process, 'access', _36 => _36.env, 'access', _37 => _37.CLOUDFLARE_R2_PUBLIC_URL, 'optionalAccess', _38 => _38.replace, 'call', _39 => _39(/\/\s*$/, "")]);
   const encoder = new TextEncoder();
   const stream = new ReadableStream({
     async start(controller) {
@@ -1184,9 +1249,11 @@ async function handleProcessAllStream() {
       };
       try {
         const meta = await loadMeta();
+        const cdnUrls = getCdnUrls(meta);
         const processed = [];
         const errors = [];
         const orphansRemoved = [];
+        const urlsToPurge = [];
         let alreadyProcessed = 0;
         const imagesToProcess = [];
         for (const [key, entry] of getFileEntries(meta)) {
@@ -1203,8 +1270,10 @@ async function handleProcessAllStream() {
         for (let i = 0; i < imagesToProcess.length; i++) {
           const { key, entry } = imagesToProcess[i];
           const fullPath = _path2.default.join(process.cwd(), "public", key);
-          const isInCloud = entry.c !== void 0;
           const existingCdnIndex = entry.c;
+          const existingCdnUrl = existingCdnIndex !== void 0 ? cdnUrls[existingCdnIndex] : void 0;
+          const isInOurR2 = existingCdnUrl === publicUrl;
+          const isRemote = existingCdnIndex !== void 0 && !isInOurR2;
           sendEvent({
             type: "progress",
             current: i + 1,
@@ -1215,11 +1284,17 @@ async function handleProcessAllStream() {
           });
           try {
             let buffer;
-            if (isInCloud) {
+            if (isInOurR2) {
               buffer = await downloadFromCdn(key);
               const dir = _path2.default.dirname(fullPath);
               await _fs.promises.mkdir(dir, { recursive: true });
               await _fs.promises.writeFile(fullPath, buffer);
+            } else if (isRemote && existingCdnUrl) {
+              const remoteUrl = `${existingCdnUrl}${key}`;
+              buffer = await downloadFromRemoteUrl(remoteUrl);
+              const dir = _path2.default.dirname(fullPath);
+              await _fs.promises.mkdir(dir, { recursive: true });
+              await _fs.promises.writeFile(fullPath, buffer);
             } else {
               buffer = await _fs.promises.readFile(fullPath);
             }
@@ -1239,20 +1314,26 @@ async function handleProcessAllStream() {
                 b: "",
                 p: 1
               };
+              if (isRemote) {
+                delete meta[key].c;
+              }
             } else {
               const processedEntry = await processImage(buffer, key);
               meta[key] = {
                 ...processedEntry,
                 p: 1,
-                ...isInCloud ? { c: existingCdnIndex } : {}
+                ...isInOurR2 ? { c: existingCdnIndex } : {}
               };
             }
-            if (isInCloud) {
+            if (isInOurR2) {
               await uploadToCdn(key);
+              for (const thumbPath of _chunkLEOQKJCLjs.getAllThumbnailPaths.call(void 0, key)) {
+                urlsToPurge.push(`${publicUrl}${thumbPath}`);
+              }
               await deleteLocalThumbnails(key);
               try {
                 await _fs.promises.unlink(fullPath);
-              } catch (e28) {
+              } catch (e29) {
               }
             }
             processed.push(key.slice(1));
@@ -1273,17 +1354,17 @@ async function handleProcessAllStream() {
         async function findOrphans(dir, relativePath = "") {
           try {
             const entries = await _fs.promises.readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-              if (entry.name.startsWith(".")) continue;
-              const fullPath = _path2.default.join(dir, entry.name);
-              const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-              if (entry.isDirectory()) {
-                await findOrphans(fullPath, relPath);
-              } else if (isImageFile(entry.name)) {
+            for (const fsEntry of entries) {
+              if (fsEntry.name.startsWith(".")) continue;
+              const entryFullPath = _path2.default.join(dir, fsEntry.name);
+              const relPath = relativePath ? `${relativePath}/${fsEntry.name}` : fsEntry.name;
+              if (fsEntry.isDirectory()) {
+                await findOrphans(entryFullPath, relPath);
+              } else if (isImageFile(fsEntry.name)) {
                 const publicPath = `/images/${relPath}`;
                 if (!trackedPaths.has(publicPath)) {
                   try {
-                    await _fs.promises.unlink(fullPath);
+                    await _fs.promises.unlink(entryFullPath);
                     orphansRemoved.push(publicPath);
                   } catch (err) {
                     console.error(`Failed to remove orphan ${publicPath}:`, err);
@@ -1291,21 +1372,21 @@ async function handleProcessAllStream() {
                 }
               }
             }
-          } catch (e29) {
+          } catch (e30) {
           }
         }
         const imagesDir = _path2.default.join(process.cwd(), "public", "images");
         try {
           await findOrphans(imagesDir);
-        } catch (e30) {
+        } catch (e31) {
         }
         async function removeEmptyDirs(dir) {
           try {
             const entries = await _fs.promises.readdir(dir, { withFileTypes: true });
             let isEmpty = true;
-            for (const entry of entries) {
-              if (entry.isDirectory()) {
-                const subDirEmpty = await removeEmptyDirs(_path2.default.join(dir, entry.name));
+            for (const fsEntry of entries) {
+              if (fsEntry.isDirectory()) {
+                const subDirEmpty = await removeEmptyDirs(_path2.default.join(dir, fsEntry.name));
                 if (!subDirEmpty) isEmpty = false;
               } else {
                 isEmpty = false;
@@ -1315,15 +1396,18 @@ async function handleProcessAllStream() {
               await _fs.promises.rmdir(dir);
             }
             return isEmpty;
-          } catch (e31) {
+          } catch (e32) {
             return true;
           }
         }
         try {
           await removeEmptyDirs(imagesDir);
-        } catch (e32) {
+        } catch (e33) {
         }
         await saveMeta(meta);
+        if (urlsToPurge.length > 0) {
+          await purgeCloudflareCache(urlsToPurge);
+        }
         sendEvent({
           type: "complete",
           processed: processed.length,
@@ -1384,7 +1468,7 @@ async function handleScanStream() {
                 allFiles.push({ relativePath: relPath, fullPath });
               }
             }
-          } catch (e33) {
+          } catch (e34) {
           }
         }
         const publicDir = _path2.default.join(process.cwd(), "public");
@@ -1444,7 +1528,7 @@ async function handleScanStream() {
                     h: metadata.height || 0,
                     b: blurhash
                   };
-                } catch (e34) {
+                } catch (e35) {
                   meta[imageKey] = { w: 0, h: 0 };
                 }
               }