npm - @gallop.software/studio - Versions diffs - 2.1.20 → 2.2.0 - Mend

@gallop.software/studio 2.1.20 → 2.2.0

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-DoxGS88r.js +74 -0
package/dist/client/index.html +1 -1
package/dist/server/index.js +247 -7
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-5N7NEJ1M.js"></script>
+    <script type="module" crossorigin src="/assets/index-DoxGS88r.js"></script>
   </head>
   <body>
     <div id="root"></div>

package/dist/server/index.js CHANGED Viewed

@@ -434,6 +434,7 @@ function countFileTypes(folderPrefix, fileEntries, cdnUrls, r2PublicUrl) {
   let cloudCount = 0;
   let remoteCount = 0;
   let localCount = 0;
+  let updateCount = 0;
   for (const [key, entry] of fileEntries) {
     if (key.startsWith(folderPrefix)) {
       if (entry.c !== void 0) {
@@ -446,9 +447,12 @@ function countFileTypes(folderPrefix, fileEntries, cdnUrls, r2PublicUrl) {
       } else {
         localCount++;
       }
+      if (entry.u === 1) {
+        updateCount++;
+      }
     }
   }
-  return { cloudCount, remoteCount, localCount };
+  return { cloudCount, remoteCount, localCount, updateCount };
 }
 async function handleList(request) {
   const searchParams = new URL(request.url).searchParams;
@@ -611,6 +615,7 @@ async function handleList(request) {
             let cloudCount = 0;
             let remoteCount = 0;
             let localCount = 0;
+            let updateCount = 0;
             if (isImagesFolder) {
               for (const [key, metaEntry] of fileEntries) {
                 if (isProcessed(metaEntry)) {
@@ -637,6 +642,7 @@ async function handleList(request) {
               cloudCount = counts.cloudCount;
               remoteCount = counts.remoteCount;
               localCount = counts.localCount;
+              updateCount = counts.updateCount;
             }
             items.push({
               name: entry.name,
@@ -646,6 +652,7 @@ async function handleList(request) {
               cloudCount,
               remoteCount,
               localCount,
+              updateCount,
               isProtected: isImagesFolder
             });
           }
@@ -714,6 +721,7 @@ async function handleList(request) {
             cloudCount: counts.cloudCount,
             remoteCount: counts.remoteCount,
             localCount: counts.localCount,
+            updateCount: counts.updateCount,
             isProtected: isInsideImagesFolder
           });
         }
@@ -776,7 +784,8 @@ async function handleList(request) {
           cdnBaseUrl: fileCdnUrl,
           isRemote,
           isProtected: isInsideImagesFolder,
-          dimensions: entry.o ? { width: entry.o.w, height: entry.o.h } : void 0
+          dimensions: entry.o ? { width: entry.o.w, height: entry.o.h } : void 0,
+          hasUpdate: entry.u === 1
         });
       }
     }
@@ -848,7 +857,8 @@ async function handleSearch(request) {
         cdnPushed: isPushedToCloud,
         cdnBaseUrl: fileCdnUrl,
         isRemote,
-        dimensions: entry.o ? { width: entry.o.w, height: entry.o.h } : void 0
+        dimensions: entry.o ? { width: entry.o.w, height: entry.o.h } : void 0,
+        hasUpdate: entry.u === 1
       });
     }
     return jsonResponse({ items });
@@ -1957,6 +1967,179 @@ async function handleDownloadStream(request) {
     }
   });
 }
+async function handlePushUpdatesStream(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(/\/$/, "");
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      const sendEvent = (data) => {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+`));
+      };
+      try {
+        if (!accountId || !accessKeyId || !secretAccessKey || !bucketName || !publicUrl) {
+          sendEvent({ type: "error", message: "R2 not configured" });
+          controller.close();
+          return;
+        }
+        const { paths } = await request.json();
+        if (!paths || !Array.isArray(paths) || paths.length === 0) {
+          sendEvent({ type: "error", message: "No paths provided" });
+          controller.close();
+          return;
+        }
+        const s3 = new S3Client2({
+          region: "auto",
+          endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
+          credentials: { accessKeyId, secretAccessKey }
+        });
+        const meta = await loadMeta();
+        const cdnUrls = getCdnUrls(meta);
+        const r2PublicUrl = publicUrl.replace(/\/$/, "");
+        const pushed = [];
+        const skipped = [];
+        const errors = [];
+        const urlsToPurge = [];
+        const total = paths.length;
+        sendEvent({ type: "start", total });
+        for (let i = 0; i < paths.length; i++) {
+          const itemPath = paths[i];
+          const key = itemPath.startsWith("public/") ? "/" + itemPath.slice(7) : itemPath;
+          const entry = meta[key];
+          sendEvent({
+            type: "progress",
+            current: i + 1,
+            total,
+            percent: Math.round((i + 1) / total * 100),
+            currentFile: path7.basename(key)
+          });
+          if (!entry || entry.u !== 1) {
+            skipped.push(key);
+            continue;
+          }
+          const fileCdnUrl = entry.c !== void 0 ? cdnUrls[entry.c]?.replace(/\/$/, "") : void 0;
+          if (!fileCdnUrl || fileCdnUrl !== r2PublicUrl) {
+            skipped.push(key);
+            continue;
+          }
+          try {
+            const localPath = getPublicPath(key);
+            const buffer = await fs7.readFile(localPath);
+            const contentType = getContentType(path7.basename(key));
+            const uploadKey = key.startsWith("/") ? key.slice(1) : key;
+            await s3.send(new PutObjectCommand2({
+              Bucket: bucketName,
+              Key: uploadKey,
+              Body: buffer,
+              ContentType: contentType
+            }));
+            if (isProcessed(entry)) {
+              const processedEntry = await processImage(buffer, key);
+              Object.assign(entry, processedEntry);
+              await uploadToCdn(key);
+              await deleteLocalThumbnails(key);
+              for (const thumbPath of getAllThumbnailPaths(key)) {
+                urlsToPurge.push(`${publicUrl}${thumbPath}`);
+              }
+            }
+            await fs7.unlink(localPath);
+            delete entry.u;
+            urlsToPurge.push(`${publicUrl}${key}`);
+            pushed.push(key);
+          } catch (error) {
+            console.error(`Failed to push update for ${key}:`, error);
+            errors.push(key);
+          }
+        }
+        sendEvent({ type: "cleanup", message: "Cleaning up..." });
+        for (const itemPath of pushed) {
+          const localPath = getPublicPath(itemPath);
+          await deleteEmptyFolders(path7.dirname(localPath));
+        }
+        await saveMeta(meta);
+        if (urlsToPurge.length > 0) {
+          sendEvent({ type: "cleanup", message: "Purging CDN cache..." });
+          await purgeCloudflareCache(urlsToPurge);
+        }
+        let message = `Pushed ${pushed.length} update${pushed.length !== 1 ? "s" : ""} to cloud.`;
+        if (skipped.length > 0) {
+          message += ` ${skipped.length} file${skipped.length !== 1 ? "s" : ""} skipped.`;
+        }
+        if (errors.length > 0) {
+          message += ` ${errors.length} file${errors.length !== 1 ? "s" : ""} failed.`;
+        }
+        sendEvent({
+          type: "complete",
+          pushed: pushed.length,
+          skipped: skipped.length,
+          errors: errors.length,
+          message
+        });
+      } catch (error) {
+        console.error("Push updates error:", error);
+        sendEvent({ type: "error", message: "Failed to push updates" });
+      } finally {
+        controller.close();
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive"
+    }
+  });
+}
+async function handleCancelUpdates(request) {
+  try {
+    const { paths } = await request.json();
+    if (!paths || !Array.isArray(paths) || paths.length === 0) {
+      return jsonResponse({ error: "No paths provided" }, { status: 400 });
+    }
+    const meta = await loadMeta();
+    const cancelled = [];
+    const skipped = [];
+    const errors = [];
+    const foldersToClean = /* @__PURE__ */ new Set();
+    for (const itemPath of paths) {
+      const key = itemPath.startsWith("public/") ? "/" + itemPath.slice(7) : itemPath;
+      const entry = meta[key];
+      if (!entry || entry.u !== 1) {
+        skipped.push(key);
+        continue;
+      }
+      try {
+        const localPath = getPublicPath(key);
+        await fs7.unlink(localPath);
+        foldersToClean.add(path7.dirname(localPath));
+        delete entry.u;
+        cancelled.push(key);
+      } catch (error) {
+        console.error(`Failed to cancel update for ${key}:`, error);
+        errors.push(key);
+      }
+    }
+    for (const folder of foldersToClean) {
+      await deleteEmptyFolders(folder);
+    }
+    await saveMeta(meta);
+    return jsonResponse({
+      success: true,
+      cancelled: cancelled.length,
+      skipped: skipped.length,
+      errors: errors.length
+    });
+  } catch (error) {
+    console.error("Cancel updates error:", error);
+    return jsonResponse({ error: "Failed to cancel updates" }, { status: 500 });
+  }
+}
 // src/handlers/scan.ts
 import { promises as fs8 } from "fs";
@@ -1980,6 +2163,7 @@ async function handleScanStream() {
         const renamed = [];
         const errors = [];
         const orphanedFiles = [];
+        const pendingUpdates = [];
         const allFiles = [];
         async function scanDir(dir, relativePath = "") {
           try {
@@ -2013,6 +2197,11 @@ async function handleScanStream() {
             currentFile: relativePath
           });
           if (existingKeys.has(imageKey)) {
+            const entry = meta[imageKey];
+            if (entry?.c !== void 0 && !entry?.u) {
+              entry.u = 1;
+              pendingUpdates.push(imageKey);
+            }
             continue;
           }
           if (meta[imageKey]) {
@@ -2130,7 +2319,8 @@ async function handleScanStream() {
           renamed: renamed.length,
           errors: errors.length,
           renamedFiles: renamed,
-          orphanedFiles: orphanedFiles.length > 0 ? orphanedFiles : void 0
+          orphanedFiles: orphanedFiles.length > 0 ? orphanedFiles : void 0,
+          pendingUpdates: pendingUpdates.length
         });
       } catch (error) {
         console.error("Scan failed:", error);
@@ -2461,15 +2651,27 @@ async function startServer(options) {
   } else if (existsSync(envPath)) {
     loadEnv({ path: envPath, quiet: true });
   }
-  app.use(express.json({ limit: "50mb" }));
-  app.use(express.urlencoded({ extended: true, limit: "50mb" }));
+  app.use((req, res, next) => {
+    if (req.path === "/api/studio/upload") {
+      next();
+    } else {
+      express.json({ limit: "50mb" })(req, res, next);
+    }
+  });
+  app.use((req, res, next) => {
+    if (req.path === "/api/studio/upload") {
+      next();
+    } else {
+      express.urlencoded({ extended: true, limit: "50mb" })(req, res, next);
+    }
+  });
   app.get("/api/studio/list", wrapHandler(handleList));
   app.get("/api/studio/list-folders", wrapHandler(handleListFolders));
   app.get("/api/studio/search", wrapHandler(handleSearch));
   app.get("/api/studio/count-images", wrapHandler(handleCountImages));
   app.get("/api/studio/folder-images", wrapHandler(handleFolderImages));
   app.get("/api/studio/cdns", wrapHandler(handleGetCdns));
-  app.post("/api/studio/upload", wrapHandler(handleUpload));
+  app.post("/api/studio/upload", wrapRawHandler(handleUpload));
   app.post("/api/studio/create-folder", wrapHandler(handleCreateFolder));
   app.post("/api/studio/rename", wrapHandler(handleRename));
   app.post("/api/studio/move", wrapHandler(handleMoveStream, true));
@@ -2477,6 +2679,8 @@ async function startServer(options) {
   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));
+  app.post("/api/studio/push-updates-stream", wrapHandler(handlePushUpdatesStream, true));
+  app.post("/api/studio/cancel-updates", wrapHandler(handleCancelUpdates));
   app.post("/api/studio/scan", wrapHandler(handleScanStream, true));
   app.post("/api/studio/delete-orphans", wrapHandler(handleDeleteOrphans));
   app.post("/api/studio/import", wrapHandler(handleImportUrls, true));
@@ -2534,6 +2738,18 @@ function wrapHandler(handler, streaming = false) {
     }
   };
 }
+function wrapRawHandler(handler) {
+  return async (req, res) => {
+    try {
+      const request = await createRawFetchRequest(req);
+      const response = await handler(request);
+      await sendResponse(res, response);
+    } catch (error) {
+      console.error("Handler error:", error);
+      res.status(500).json({ error: "Internal server error" });
+    }
+  };
+}
 function createFetchRequest(req) {
   const url = new URL(req.url, `http://${req.headers.host}`);
   const headers = new Headers();
@@ -2557,6 +2773,30 @@ function createFetchRequest(req) {
   }
   return new globalThis.Request(url.toString(), init);
 }
+async function createRawFetchRequest(req) {
+  const url = new URL(req.url, `http://${req.headers.host}`);
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => headers.append(key, v));
+      } else {
+        headers.set(key, value);
+      }
+    }
+  }
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.from(chunk));
+  }
+  const body = Buffer.concat(chunks);
+  const init = {
+    method: req.method,
+    headers,
+    body
+  };
+  return new globalThis.Request(url.toString(), init);
+}
 async function sendResponse(res, response) {
   res.status(response.status);
   response.headers.forEach((value, key) => {