@gallop.software/studio 0.1.113 → 0.1.115

package/dist/handlers/index.mjs

@@ -160,6 +160,31 @@ async function processImage(buffer, imageKey) {
 import { promises as fs3 } from "fs";
 import path4 from "path";
 import { S3Client, GetObjectCommand, PutObjectCommand, DeleteObjectCommand } from "@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 = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/\s*$/, "");
   if (!accountId || !accessKeyId || !secretAccessKey || !bucketName || !publicUrl) {
     return NextResponse3.json(
       { error: "R2 not configured. Set CLOUDFLARE_R2_* environment variables." },
@@ -1035,6 +1060,7 @@ async function handleSync(request) {
       return NextResponse3.json({ error: "No image keys provided" }, { status: 400 });
     }
     const meta = await loadMeta();
+    const cdnUrls = getCdnUrls(meta);
     const cdnIndex = getOrAddCdnIndex(meta, publicUrl);
     const r2 = new S3Client2({
       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 = 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);
+        let originalBuffer;
+        if (isRemote) {
+          const remoteUrl = `${existingCdnUrl}${imageKey}`;
+          originalBuffer = await downloadFromRemoteUrl(remoteUrl);
+        } else {
+          const originalLocalPath = path7.join(process.cwd(), "public", imageKey);
           try {
-            const fileBuffer = await fs6.readFile(localPath);
-            await r2.send(
-              new PutObjectCommand2({
-                Bucket: bucketName,
-                Key: thumbPath.replace(/^\//, ""),
-                Body: fileBuffer,
-                ContentType: getContentType(thumbPath)
-              })
-            );
+            originalBuffer = await fs6.readFile(originalLocalPath);
           } catch {
+            errors.push(`Original file not found: ${imageKey}`);
+            continue;
+          }
+        }
+        await r2.send(
+          new PutObjectCommand2({
+            Bucket: bucketName,
+            Key: imageKey.replace(/^\//, ""),
+            Body: originalBuffer,
+            ContentType: getContentType(imageKey)
+          })
+        );
+        urlsToPurge.push(`${publicUrl}${imageKey}`);
+        if (!isRemote && entry.p) {
+          for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+            const localPath = path7.join(process.cwd(), "public", thumbPath);
+            try {
+              const fileBuffer = await fs6.readFile(localPath);
+              await r2.send(
+                new PutObjectCommand2({
+                  Bucket: bucketName,
+                  Key: thumbPath.replace(/^\//, ""),
+                  Body: fileBuffer,
+                  ContentType: getContentType(thumbPath)
+                })
+              );
+              urlsToPurge.push(`${publicUrl}${thumbPath}`);
+            } catch {
+            }
           }
         }
         entry.c = cdnIndex;
-        for (const thumbPath of getAllThumbnailPaths(imageKey)) {
-          const localPath = path7.join(process.cwd(), "public", thumbPath);
+        if (!isRemote) {
+          const originalLocalPath = path7.join(process.cwd(), "public", imageKey);
+          for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+            const localPath = path7.join(process.cwd(), "public", thumbPath);
+            try {
+              await fs6.unlink(localPath);
+            } catch {
+            }
+          }
           try {
-            await fs6.unlink(localPath);
+            await fs6.unlink(originalLocalPath);
           } catch {
           }
         }
-        try {
-          await fs6.unlink(originalLocalPath);
-        } catch {
-        }
         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 NextResponse3.json({
       success: true,
       pushed,
       errors: errors.length > 0 ? errors : void 0
     });
   } catch (error) {
-    console.error("Failed to sync:", error);
-    return NextResponse3.json({ error: "Failed to sync to CDN" }, { status: 500 });
+    console.error("Failed to push:", error);
+    return NextResponse3.json({ error: "Failed to push to CDN" }, { status: 500 });
   }
 }
 async function handleReprocess(request) {
+  const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/\s*$/, "");
   try {
     const { imageKeys } = await request.json();
     if (!imageKeys || !Array.isArray(imageKeys) || imageKeys.length === 0) {
       return NextResponse3.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 = 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;
         const originalPath = path7.join(process.cwd(), "public", imageKey);
         try {
           buffer = await fs6.readFile(originalPath);
         } catch {
-          if (isPushedToCloud) {
+          if (isInOurR2) {
             buffer = await downloadFromCdn(imageKey);
             const dir = path7.dirname(originalPath);
             await fs6.mkdir(dir, { recursive: true });
             await fs6.writeFile(originalPath, buffer);
+          } else if (isRemote && existingCdnUrl) {
+            const remoteUrl = `${existingCdnUrl}${imageKey}`;
+            buffer = await downloadFromRemoteUrl(remoteUrl);
+            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 (isPushedToCloud) {
+        if (isInOurR2) {
           updatedEntry.c = existingCdnIndex;
           await uploadToCdn(imageKey);
+          for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+            urlsToPurge.push(`${publicUrl}${thumbPath}`);
+          }
           await deleteLocalThumbnails(imageKey);
           try {
             await fs6.unlink(originalPath);
           } catch {
           }
+        } 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 NextResponse3.json({
       success: true,
       processed,
@@ -1174,6 +1238,7 @@ async function handleReprocess(request) {
   }
 }
 async function handleProcessAllStream() {
+  const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/\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 = path7.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 = path7.dirname(fullPath);
               await fs6.mkdir(dir, { recursive: true });
               await fs6.writeFile(fullPath, buffer);
+            } else if (isRemote && existingCdnUrl) {
+              const remoteUrl = `${existingCdnUrl}${key}`;
+              buffer = await downloadFromRemoteUrl(remoteUrl);
+              const dir = path7.dirname(fullPath);
+              await fs6.mkdir(dir, { recursive: true });
+              await fs6.writeFile(fullPath, buffer);
             } else {
               buffer = await fs6.readFile(fullPath);
             }
@@ -1239,16 +1314,22 @@ 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 getAllThumbnailPaths(key)) {
+                urlsToPurge.push(`${publicUrl}${thumbPath}`);
+              }
               await deleteLocalThumbnails(key);
               try {
                 await fs6.unlink(fullPath);
@@ -1273,17 +1354,17 @@ async function handleProcessAllStream() {
         async function findOrphans(dir, relativePath = "") {
           try {
             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);
-              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 = path7.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 fs6.unlink(fullPath);
+                    await fs6.unlink(entryFullPath);
                     orphansRemoved.push(publicPath);
                   } catch (err) {
                     console.error(`Failed to remove orphan ${publicPath}:`, err);
@@ -1303,9 +1384,9 @@ async function handleProcessAllStream() {
           try {
             const entries = await fs6.readdir(dir, { withFileTypes: true });
             let isEmpty = true;
-            for (const entry of entries) {
-              if (entry.isDirectory()) {
-                const subDirEmpty = await removeEmptyDirs(path7.join(dir, entry.name));
+            for (const fsEntry of entries) {
+              if (fsEntry.isDirectory()) {
+                const subDirEmpty = await removeEmptyDirs(path7.join(dir, fsEntry.name));
                 if (!subDirEmpty) isEmpty = false;
               } else {
                 isEmpty = false;
@@ -1324,6 +1405,9 @@ async function handleProcessAllStream() {
         } catch {
         }
         await saveMeta(meta);
+        if (urlsToPurge.length > 0) {
+          await purgeCloudflareCache(urlsToPurge);
+        }
         sendEvent({
           type: "complete",
           processed: processed.length,