@gallop.software/studio 1.3.1 → 1.3.3

package/dist/handlers/index.mjs

@@ -1393,6 +1393,140 @@ async function handleReprocess(request) {
     return NextResponse3.json({ error: "Failed to reprocess images" }, { status: 500 });
   }
 }
+async function handleReprocessStream(request) {
+  const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/\s*$/, "");
+  const encoder = new TextEncoder();
+  let imageKeys;
+  try {
+    const body = await request.json();
+    imageKeys = body.imageKeys;
+    if (!imageKeys || !Array.isArray(imageKeys) || imageKeys.length === 0) {
+      return NextResponse3.json({ error: "No image keys provided" }, { status: 400 });
+    }
+  } catch {
+    return NextResponse3.json({ error: "Invalid request body" }, { status: 400 });
+  }
+  const stream = new ReadableStream({
+    async start(controller) {
+      const sendEvent = (data) => {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+
+`));
+      };
+      try {
+        const meta = await loadMeta();
+        const cdnUrls = getCdnUrls(meta);
+        const processed = [];
+        const errors = [];
+        const urlsToPurge = [];
+        const total = imageKeys.length;
+        sendEvent({ type: "start", total });
+        for (let i = 0; i < imageKeys.length; i++) {
+          let imageKey = imageKeys[i];
+          if (!imageKey.startsWith("/")) {
+            imageKey = `/${imageKey}`;
+          }
+          sendEvent({
+            type: "progress",
+            current: i + 1,
+            total,
+            percent: Math.round((i + 1) / total * 100),
+            message: `Processing ${imageKey.slice(1)}...`
+          });
+          try {
+            let buffer;
+            const entry = getMetaEntry(meta, imageKey);
+            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 (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 ext = path7.extname(imageKey).toLowerCase();
+            const isSvg = ext === ".svg";
+            if (isSvg) {
+              const imageDir = path7.dirname(imageKey.slice(1));
+              const imagesPath = path7.join(process.cwd(), "public", "images", imageDir === "." ? "" : imageDir);
+              await fs6.mkdir(imagesPath, { recursive: true });
+              const fileName = path7.basename(imageKey);
+              const destPath = path7.join(imagesPath, fileName);
+              await fs6.writeFile(destPath, buffer);
+              meta[imageKey] = {
+                ...entry,
+                o: { w: 0, h: 0 },
+                b: "",
+                f: { w: 0, h: 0 }
+              };
+              if (isRemote) {
+                delete meta[imageKey].c;
+              }
+            } else {
+              const updatedEntry = await processImage(buffer, imageKey);
+              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 {
+                }
+              }
+              meta[imageKey] = updatedEntry;
+            }
+            processed.push(imageKey);
+          } catch (error) {
+            console.error(`Failed to reprocess ${imageKey}:`, error);
+            errors.push(imageKey);
+          }
+        }
+        sendEvent({ type: "cleanup", message: "Saving metadata..." });
+        await saveMeta(meta);
+        if (urlsToPurge.length > 0) {
+          sendEvent({ type: "cleanup", message: "Purging CDN cache..." });
+          await purgeCloudflareCache(urlsToPurge);
+        }
+        sendEvent({
+          type: "complete",
+          processed: processed.length,
+          errors: errors.length,
+          message: `Processed ${processed.length} image${processed.length !== 1 ? "s" : ""}${errors.length > 0 ? `, ${errors.length} error${errors.length !== 1 ? "s" : ""}` : ""}`
+        });
+        controller.close();
+      } catch (error) {
+        console.error("Reprocess stream error:", error);
+        sendEvent({ type: "error", message: "Failed to process images" });
+        controller.close();
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
+}
 async function handleProcessAllStream() {
   const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/\s*$/, "");
   const encoder = new TextEncoder();
@@ -1985,6 +2119,9 @@ async function POST(request) {
   if (route === "reprocess") {
     return handleReprocess(request);
   }
+  if (route === "reprocess-stream") {
+    return handleReprocessStream(request);
+  }
   if (route === "process-all") {
     return handleProcessAllStream();
   }