@gallop.software/studio 0.1.59 → 0.1.60

package/dist/handlers.mjs

@@ -31,6 +31,9 @@ async function GET(request) {
   if (route === "search") {
     return handleSearch(request);
   }
+  if (route === "list-folders") {
+    return handleListFolders();
+  }
   return NextResponse.json({ error: "Not found" }, { status: 404 });
 }
 async function POST(request) {
@@ -54,6 +57,15 @@ async function POST(request) {
   if (route === "process-all") {
     return handleProcessAllStream();
   }
+  if (route === "create-folder") {
+    return handleCreateFolder(request);
+  }
+  if (route === "rename") {
+    return handleRename(request);
+  }
+  if (route === "move") {
+    return handleMove(request);
+  }
   return NextResponse.json({ error: "Not found" }, { status: 404 });
 }
 async function DELETE(request) {
@@ -1069,6 +1081,237 @@ async function deleteLocalFiles(entry) {
     }
   }
 }
+async function handleCreateFolder(request) {
+  try {
+    const { parentPath, name } = await request.json();
+    if (!name || typeof name !== "string") {
+      return NextResponse.json({ error: "Folder name is required" }, { status: 400 });
+    }
+    const sanitizedName = name.replace(/[<>:"/\\|?*]/g, "").trim();
+    if (!sanitizedName) {
+      return NextResponse.json({ error: "Invalid folder name" }, { status: 400 });
+    }
+    const safePath = (parentPath || "public").replace(/\.\./g, "");
+    const folderPath = path.join(process.cwd(), safePath, sanitizedName);
+    if (!folderPath.startsWith(path.join(process.cwd(), "public"))) {
+      return NextResponse.json({ error: "Invalid path" }, { status: 400 });
+    }
+    try {
+      await fs.access(folderPath);
+      return NextResponse.json({ error: "A folder with this name already exists" }, { status: 400 });
+    } catch {
+    }
+    await fs.mkdir(folderPath, { recursive: true });
+    return NextResponse.json({ success: true, path: path.join(safePath, sanitizedName) });
+  } catch (error) {
+    console.error("Failed to create folder:", error);
+    return NextResponse.json({ error: "Failed to create folder" }, { status: 500 });
+  }
+}
+async function handleRename(request) {
+  try {
+    const { oldPath, newName } = await request.json();
+    if (!oldPath || !newName) {
+      return NextResponse.json({ error: "Path and new name are required" }, { status: 400 });
+    }
+    const sanitizedName = newName.replace(/[<>:"/\\|?*]/g, "").trim();
+    if (!sanitizedName) {
+      return NextResponse.json({ error: "Invalid name" }, { status: 400 });
+    }
+    const safePath = oldPath.replace(/\.\./g, "");
+    const absoluteOldPath = path.join(process.cwd(), safePath);
+    const parentDir = path.dirname(absoluteOldPath);
+    const absoluteNewPath = path.join(parentDir, sanitizedName);
+    if (!absoluteOldPath.startsWith(path.join(process.cwd(), "public"))) {
+      return NextResponse.json({ error: "Invalid path" }, { status: 400 });
+    }
+    try {
+      await fs.access(absoluteOldPath);
+    } catch {
+      return NextResponse.json({ error: "File or folder not found" }, { status: 404 });
+    }
+    try {
+      await fs.access(absoluteNewPath);
+      return NextResponse.json({ error: "An item with this name already exists" }, { status: 400 });
+    } catch {
+    }
+    const stats = await fs.stat(absoluteOldPath);
+    const isFile = stats.isFile();
+    const isImage = isFile && isImageFile(path.basename(oldPath));
+    await fs.rename(absoluteOldPath, absoluteNewPath);
+    if (isImage) {
+      const meta = await loadMeta();
+      const oldRelativePath = safePath.replace(/^public\//, "");
+      const newRelativePath = path.join(path.dirname(oldRelativePath), sanitizedName);
+      for (const [key, entry] of Object.entries(meta.images)) {
+        if (entry.original.path === `/${oldRelativePath}`) {
+          entry.original.path = `/${newRelativePath}`;
+          const oldExt = path.extname(path.basename(oldPath));
+          const oldBaseName = path.basename(oldPath, oldExt);
+          const newExt = path.extname(sanitizedName);
+          const newBaseName = path.basename(sanitizedName, newExt);
+          const oldDirRelative = path.dirname(oldRelativePath);
+          const thumbnailDir = path.join(process.cwd(), "public", "images", oldDirRelative);
+          for (const [sizeName, sizeData] of Object.entries(entry.sizes)) {
+            const suffix = DEFAULT_SIZES[sizeName]?.suffix || `-${sizeName}`;
+            const oldThumbName = `${oldBaseName}${suffix}${oldExt === ".png" ? ".png" : ".jpg"}`;
+            const newThumbName = `${newBaseName}${suffix}${newExt === ".png" ? ".png" : ".jpg"}`;
+            const oldThumbPath = path.join(thumbnailDir, oldThumbName);
+            const newThumbPath = path.join(thumbnailDir, newThumbName);
+            try {
+              await fs.rename(oldThumbPath, newThumbPath);
+              sizeData.path = `/images/${oldDirRelative}/${newThumbName}`.replace(/\/+/g, "/");
+            } catch {
+            }
+          }
+          const newKey = `/${newRelativePath}`;
+          delete meta.images[key];
+          meta.images[newKey] = entry;
+          break;
+        }
+      }
+      await saveMeta(meta);
+    }
+    const newPath = path.join(path.dirname(safePath), sanitizedName);
+    return NextResponse.json({ success: true, newPath });
+  } catch (error) {
+    console.error("Failed to rename:", error);
+    return NextResponse.json({ error: "Failed to rename" }, { status: 500 });
+  }
+}
+async function handleMove(request) {
+  try {
+    const { paths, destination } = await request.json();
+    if (!paths || !Array.isArray(paths) || paths.length === 0) {
+      return NextResponse.json({ error: "Paths are required" }, { status: 400 });
+    }
+    if (!destination || typeof destination !== "string") {
+      return NextResponse.json({ error: "Destination is required" }, { status: 400 });
+    }
+    const safeDestination = destination.replace(/\.\./g, "");
+    const absoluteDestination = path.join(process.cwd(), safeDestination);
+    if (!absoluteDestination.startsWith(path.join(process.cwd(), "public"))) {
+      return NextResponse.json({ error: "Invalid destination" }, { status: 400 });
+    }
+    if (safeDestination === "public/images" || safeDestination.startsWith("public/images/")) {
+      return NextResponse.json({ error: "Cannot move items to the protected images folder" }, { status: 400 });
+    }
+    try {
+      const destStats = await fs.stat(absoluteDestination);
+      if (!destStats.isDirectory()) {
+        return NextResponse.json({ error: "Destination is not a folder" }, { status: 400 });
+      }
+    } catch {
+      return NextResponse.json({ error: "Destination folder not found" }, { status: 404 });
+    }
+    const moved = [];
+    const errors = [];
+    const meta = await loadMeta();
+    let metaChanged = false;
+    for (const itemPath of paths) {
+      const safePath = itemPath.replace(/\.\./g, "");
+      const absolutePath = path.join(process.cwd(), safePath);
+      const itemName = path.basename(safePath);
+      const newAbsolutePath = path.join(absoluteDestination, itemName);
+      if (absoluteDestination.startsWith(absolutePath + path.sep)) {
+        errors.push(`Cannot move ${itemName} into itself`);
+        continue;
+      }
+      try {
+        await fs.access(absolutePath);
+      } catch {
+        errors.push(`${itemName} not found`);
+        continue;
+      }
+      try {
+        await fs.access(newAbsolutePath);
+        errors.push(`${itemName} already exists in destination`);
+        continue;
+      } catch {
+      }
+      try {
+        await fs.rename(absolutePath, newAbsolutePath);
+        const stats = await fs.stat(newAbsolutePath);
+        if (stats.isFile() && isImageFile(itemName)) {
+          const oldRelativePath = safePath.replace(/^public\//, "");
+          const newRelativePath = path.join(safeDestination.replace(/^public\//, ""), itemName);
+          for (const [key, entry] of Object.entries(meta.images)) {
+            if (entry.original.path === `/${oldRelativePath}`) {
+              entry.original.path = `/${newRelativePath}`;
+              const oldDir = path.dirname(oldRelativePath);
+              const newDir = path.dirname(newRelativePath);
+              const ext = path.extname(itemName);
+              const baseName = path.basename(itemName, ext);
+              const oldThumbDir = path.join(process.cwd(), "public", "images", oldDir);
+              const newThumbDir = path.join(process.cwd(), "public", "images", newDir);
+              await fs.mkdir(newThumbDir, { recursive: true });
+              for (const [sizeName, sizeData] of Object.entries(entry.sizes)) {
+                const suffix = DEFAULT_SIZES[sizeName]?.suffix || `-${sizeName}`;
+                const thumbName = `${baseName}${suffix}${ext === ".png" ? ".png" : ".jpg"}`;
+                const oldThumbPath = path.join(oldThumbDir, thumbName);
+                const newThumbPath = path.join(newThumbDir, thumbName);
+                try {
+                  await fs.rename(oldThumbPath, newThumbPath);
+                  sizeData.path = `/images/${newDir}/${thumbName}`.replace(/\/+/g, "/");
+                } catch {
+                }
+              }
+              const newKey = `/${newRelativePath}`;
+              delete meta.images[key];
+              meta.images[newKey] = entry;
+              metaChanged = true;
+              break;
+            }
+          }
+        }
+        moved.push(itemPath);
+      } catch (error) {
+        errors.push(`Failed to move ${itemName}`);
+      }
+    }
+    if (metaChanged) {
+      await saveMeta(meta);
+    }
+    return NextResponse.json({
+      success: errors.length === 0,
+      moved,
+      errors: errors.length > 0 ? errors : void 0
+    });
+  } catch (error) {
+    console.error("Failed to move:", error);
+    return NextResponse.json({ error: "Failed to move items" }, { status: 500 });
+  }
+}
+async function handleListFolders() {
+  try {
+    const publicDir = path.join(process.cwd(), "public");
+    const folders = [];
+    async function scanDir(dir, relativePath, depth) {
+      try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory()) continue;
+          if (entry.name.startsWith(".")) continue;
+          if (relativePath === "" && entry.name === "images") continue;
+          const folderRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+          folders.push({
+            path: `public/${folderRelativePath}`,
+            name: entry.name,
+            depth
+          });
+          await scanDir(path.join(dir, entry.name), folderRelativePath, depth + 1);
+        }
+      } catch {
+      }
+    }
+    folders.push({ path: "public", name: "public", depth: 0 });
+    await scanDir(publicDir, "", 1);
+    return NextResponse.json({ folders });
+  } catch (error) {
+    console.error("Failed to list folders:", error);
+    return NextResponse.json({ error: "Failed to list folders" }, { status: 500 });
+  }
+}
 export {
   DELETE,
   GET,