npm - @gallop.software/studio - Versions diffs - 2.3.61 → 2.3.62 - Mend

@gallop.software/studio 2.3.61 → 2.3.62

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/client/assets/index-B_wl32tp.js +79 -0
package/dist/client/index.html +1 -1
package/dist/server/index.js +208 -0
package/dist/server/index.js.map +1 -1
package/package.json +1 -1

package/dist/client/index.html CHANGED Viewed

@@ -11,7 +11,7 @@
         font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
       }
     </style>
-    <script type="module" crossorigin src="/assets/index-C6_03alH.js"></script>
+    <script type="module" crossorigin src="/assets/index-B_wl32tp.js"></script>
   </head>
   <body>
     <div id="root"></div>

package/dist/server/index.js CHANGED Viewed

@@ -1224,6 +1224,213 @@ async function handleSync(request) {
     return jsonResponse({ error: "Failed to push to CDN" }, { status: 500 });
   }
 }
+async function handleSyncStream(request) {
+  const accountId = process.env.CLOUDFLARE_R2_ACCOUNT_ID;
+  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?.replace(/\/\s*$/, "");
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      const sendEvent = (data) => {
+        try {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+`));
+        } catch {
+        }
+      };
+      try {
+        if (!accountId || !accessKeyId || !secretAccessKey || !bucketName || !publicUrl) {
+          sendEvent({ type: "error", message: "R2 not configured. Set CLOUDFLARE_R2_* environment variables." });
+          controller.close();
+          return;
+        }
+        const { imageKeys, operationId } = await request.json();
+        if (!imageKeys || !Array.isArray(imageKeys) || imageKeys.length === 0) {
+          sendEvent({ type: "error", message: "No image keys provided" });
+          controller.close();
+          return;
+        }
+        const isCancelled = () => operationId ? isOperationCancelled(operationId) : false;
+        const meta = await loadMeta();
+        const cdnUrls = getCdnUrls(meta);
+        const cdnIndex = getOrAddCdnIndex(meta, publicUrl);
+        const r2 = new S3Client2({
+          region: "auto",
+          endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
+          credentials: { accessKeyId, secretAccessKey }
+        });
+        const pushed = [];
+        const alreadyPushed = [];
+        const errors = [];
+        const sourceFolders = /* @__PURE__ */ new Set();
+        const total = imageKeys.length;
+        sendEvent({ type: "start", total });
+        for (let i = 0; i < imageKeys.length; i++) {
+          if (isCancelled()) {
+            await saveMeta(meta);
+            for (const folder of sourceFolders) {
+              await deleteEmptyFolders(folder);
+            }
+            if (operationId) clearCancelledOperation(operationId);
+            sendEvent({
+              type: "complete",
+              pushed: pushed.length,
+              alreadyPushed: alreadyPushed.length,
+              errors: errors.length,
+              message: `Stopped. ${pushed.length} file${pushed.length !== 1 ? "s" : ""} pushed.`,
+              cancelled: true
+            });
+            controller.close();
+            return;
+          }
+          let imageKey = imageKeys[i];
+          if (!imageKey.startsWith("/")) {
+            imageKey = `/${imageKey}`;
+          }
+          const entry = getMetaEntry(meta, imageKey);
+          if (!entry) {
+            errors.push(`Image not found in meta: ${imageKey}. Run Scan first.`);
+            sendEvent({
+              type: "progress",
+              current: i + 1,
+              total,
+              pushed: pushed.length,
+              percent: Math.round((i + 1) / total * 100),
+              currentFile: path6.basename(imageKey)
+            });
+            continue;
+          }
+          const existingCdnUrl = entry.c !== void 0 ? cdnUrls[entry.c] : void 0;
+          const isAlreadyInOurR2 = existingCdnUrl === publicUrl;
+          if (isAlreadyInOurR2) {
+            alreadyPushed.push(imageKey);
+            sendEvent({
+              type: "progress",
+              current: i + 1,
+              total,
+              pushed: pushed.length,
+              percent: Math.round((i + 1) / total * 100),
+              currentFile: path6.basename(imageKey)
+            });
+            continue;
+          }
+          const isRemote = entry.c !== void 0 && existingCdnUrl !== publicUrl;
+          try {
+            let originalBuffer;
+            if (isRemote) {
+              const remoteUrl = `${existingCdnUrl}${imageKey}`;
+              originalBuffer = await downloadFromRemoteUrl(remoteUrl);
+            } else {
+              const originalLocalPath = getPublicPath(imageKey);
+              try {
+                originalBuffer = await fs6.readFile(originalLocalPath);
+              } catch {
+                errors.push(`Original file not found: ${imageKey}`);
+                sendEvent({
+                  type: "progress",
+                  current: i + 1,
+                  total,
+                  pushed: pushed.length,
+                  percent: Math.round((i + 1) / total * 100),
+                  currentFile: path6.basename(imageKey)
+                });
+                continue;
+              }
+            }
+            await r2.send(
+              new PutObjectCommand2({
+                Bucket: bucketName,
+                Key: imageKey.replace(/^\//, ""),
+                Body: originalBuffer,
+                ContentType: getContentType(imageKey)
+              })
+            );
+            if (!isRemote && isProcessed(entry)) {
+              for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+                const localPath = getPublicPath(thumbPath);
+                try {
+                  const fileBuffer = await fs6.readFile(localPath);
+                  await r2.send(
+                    new PutObjectCommand2({
+                      Bucket: bucketName,
+                      Key: thumbPath.replace(/^\//, ""),
+                      Body: fileBuffer,
+                      ContentType: getContentType(thumbPath)
+                    })
+                  );
+                } catch {
+                }
+              }
+            }
+            entry.c = cdnIndex;
+            if (!isRemote) {
+              const originalLocalPath = getPublicPath(imageKey);
+              sourceFolders.add(path6.dirname(originalLocalPath));
+              for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+                const localPath = getPublicPath(thumbPath);
+                sourceFolders.add(path6.dirname(localPath));
+                try {
+                  await fs6.unlink(localPath);
+                } catch {
+                }
+              }
+              try {
+                await fs6.unlink(originalLocalPath);
+              } catch {
+              }
+            }
+            await saveMeta(meta);
+            pushed.push(imageKey);
+          } catch (error) {
+            console.error(`Failed to push ${imageKey}:`, error);
+            errors.push(`Failed to push: ${imageKey}`);
+          }
+          sendEvent({
+            type: "progress",
+            current: i + 1,
+            total,
+            pushed: pushed.length,
+            percent: Math.round((i + 1) / total * 100),
+            currentFile: path6.basename(imageKey)
+          });
+        }
+        for (const folder of sourceFolders) {
+          await deleteEmptyFolders(folder);
+        }
+        let message;
+        if (pushed.length === 0 && errors.length === 0) {
+          message = `${alreadyPushed.length} file${alreadyPushed.length !== 1 ? "s" : ""} already on CDN. 0 new files pushed.`;
+        } else if (alreadyPushed.length > 0 && errors.length === 0) {
+          message = `${pushed.length} file${pushed.length !== 1 ? "s" : ""} pushed. ${alreadyPushed.length} already on CDN.`;
+        }
+        if (operationId) clearCancelledOperation(operationId);
+        sendEvent({
+          type: "complete",
+          pushed: pushed.length,
+          alreadyPushed: alreadyPushed.length,
+          errors: errors.length,
+          errorMessages: errors.length > 0 ? errors : void 0,
+          message
+        });
+      } catch (error) {
+        console.error("Failed to push:", error);
+        sendEvent({ type: "error", message: "Failed to push to CDN" });
+      } finally {
+        controller.close();
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive"
+    }
+  });
+}
 async function handleUnprocessStream(request) {
   const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/\s*$/, "");
   const encoder = new TextEncoder();
@@ -3551,6 +3758,7 @@ async function startServer(options) {
   app.post("/api/studio/rename-stream", wrapHandler(handleRenameStream, true));
   app.post("/api/studio/move", wrapHandler(handleMoveStream, true));
   app.post("/api/studio/sync", wrapHandler(handleSync, true));
+  app.post("/api/studio/sync-stream", wrapHandler(handleSyncStream, true));
   app.post("/api/studio/reprocess-stream", wrapHandler(handleReprocessStream, true));
   app.post("/api/studio/unprocess-stream", wrapHandler(handleUnprocessStream, true));
   app.post("/api/studio/download-stream", wrapHandler(handleDownloadStream, true));