@gallop.software/studio 2.0.7 → 2.1.1

package/dist/{handlers/index.mjs → server/index.js}

@@ -1,14 +1,14 @@
-import {
-  getAllThumbnailPaths,
-  getThumbnailPath,
-  isProcessed
-} from "../chunk-TRYWHLJ2.mjs";
+// @ts-nocheck
 
-// src/handlers/index.ts
-import { NextResponse as NextResponse6 } from "next/server";
+// src/server/index.ts
+import express from "express";
+import { resolve, join } from "path";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+import { existsSync, readFileSync } from "fs";
+import { config as loadEnv } from "dotenv";
 
 // src/handlers/list.ts
-import { NextResponse } from "next/server";
 import { promises as fs4 } from "fs";
 import path4 from "path";
 
@@ -197,6 +197,34 @@ async function processImage(buffer, imageKey) {
 // src/handlers/utils/cdn.ts
 import { promises as fs3 } from "fs";
 import { S3Client, GetObjectCommand, PutObjectCommand, DeleteObjectCommand } from "@aws-sdk/client-s3";
+
+// src/types.ts
+function getThumbnailPath(originalPath, size) {
+  if (size === "full") {
+    const ext2 = originalPath.match(/\.\w+$/)?.[0] || ".jpg";
+    const base2 = originalPath.replace(/\.\w+$/, "");
+    const outputExt2 = ext2.toLowerCase() === ".png" ? ".png" : ".jpg";
+    return `/images${base2}${outputExt2}`;
+  }
+  const ext = originalPath.match(/\.\w+$/)?.[0] || ".jpg";
+  const base = originalPath.replace(/\.\w+$/, "");
+  const outputExt = ext.toLowerCase() === ".png" ? ".png" : ".jpg";
+  return `/images${base}-${size}${outputExt}`;
+}
+function getAllThumbnailPaths(originalPath) {
+  return [
+    getThumbnailPath(originalPath, "full"),
+    getThumbnailPath(originalPath, "lg"),
+    getThumbnailPath(originalPath, "md"),
+    getThumbnailPath(originalPath, "sm")
+  ];
+}
+function isProcessed(entry) {
+  if (!entry) return false;
+  return !!(entry.f || entry.lg || entry.md || entry.sm);
+}
+
+// src/handlers/utils/cdn.ts
 async function purgeCloudflareCache(urls) {
   const zoneId = process.env.CLOUDFLARE_ZONE_ID;
   const apiToken = process.env.CLOUDFLARE_API_TOKEN;
@@ -258,7 +286,7 @@ async function downloadFromCdn(originalPath) {
     } catch (error) {
       lastError = error;
       if (attempt < maxRetries - 1) {
-        await new Promise((resolve) => setTimeout(resolve, 500 * (attempt + 1)));
+        await new Promise((resolve2) => setTimeout(resolve2, 500 * (attempt + 1)));
       }
     }
   }
@@ -307,7 +335,7 @@ async function downloadFromRemoteUrl(url) {
     } catch (error) {
       lastError = error;
       if (attempt < maxRetries - 1) {
-        await new Promise((resolve) => setTimeout(resolve, 500 * (attempt + 1)));
+        await new Promise((resolve2) => setTimeout(resolve2, 500 * (attempt + 1)));
       }
     }
   }
@@ -372,6 +400,18 @@ async function deleteThumbnailsFromCdn(imageKey) {
   }
 }
 
+// src/handlers/utils/response.ts
+function jsonResponse(data, init) {
+  const headers = new Headers({
+    "Content-Type": "application/json",
+    ...init?.headers
+  });
+  return new Response(JSON.stringify(data), {
+    status: init?.status ?? 200,
+    headers
+  });
+}
+
 // src/handlers/list.ts
 function getExistingThumbnails(originalPath, entry) {
   const thumbnails = [];
@@ -410,7 +450,7 @@ function countFileTypes(folderPrefix, fileEntries, cdnUrls, r2PublicUrl) {
   return { cloudCount, remoteCount, localCount };
 }
 async function handleList(request) {
-  const searchParams = request.nextUrl.searchParams;
+  const searchParams = new URL(request.url).searchParams;
   const requestedPath = searchParams.get("path") || "public";
   try {
     const meta = await loadMeta();
@@ -515,7 +555,7 @@ async function handleList(request) {
           }
         }
       }
-      return NextResponse.json({ items });
+      return jsonResponse({ items });
     }
     const absoluteDir = getWorkspacePath(requestedPath);
     try {
@@ -580,7 +620,7 @@ async function handleList(request) {
       }
     }
     if (fileEntries.length === 0 && items.length === 0) {
-      return NextResponse.json({ items: [], isEmpty: true });
+      return jsonResponse({ items: [], isEmpty: true });
     }
     for (const [key, entry] of fileEntries) {
       if (!key.startsWith(pathPrefix) && pathPrefix !== "/") continue;
@@ -671,17 +711,17 @@ async function handleList(request) {
         });
       }
     }
-    return NextResponse.json({ items });
+    return jsonResponse({ items });
   } catch (error) {
     console.error("Failed to list directory:", error);
-    return NextResponse.json({ error: "Failed to list directory" }, { status: 500 });
+    return jsonResponse({ error: "Failed to list directory" }, { status: 500 });
   }
 }
 async function handleSearch(request) {
-  const searchParams = request.nextUrl.searchParams;
+  const searchParams = new URL(request.url).searchParams;
   const query = searchParams.get("q")?.toLowerCase() || "";
   if (query.length < 2) {
-    return NextResponse.json({ items: [] });
+    return jsonResponse({ items: [] });
   }
   try {
     const meta = await loadMeta();
@@ -741,10 +781,10 @@ async function handleSearch(request) {
         dimensions: entry.o ? { width: entry.o.w, height: entry.o.h } : void 0
       });
     }
-    return NextResponse.json({ items });
+    return jsonResponse({ items });
   } catch (error) {
     console.error("Failed to search:", error);
-    return NextResponse.json({ error: "Failed to search" }, { status: 500 });
+    return jsonResponse({ error: "Failed to search" }, { status: 500 });
   }
 }
 async function handleListFolders() {
@@ -787,10 +827,10 @@ async function handleListFolders() {
         depth
       });
     }
-    return NextResponse.json({ folders });
+    return jsonResponse({ folders });
   } catch (error) {
     console.error("Failed to list folders:", error);
-    return NextResponse.json({ error: "Failed to list folders" }, { status: 500 });
+    return jsonResponse({ error: "Failed to list folders" }, { status: 500 });
   }
 }
 async function handleCountImages() {
@@ -804,21 +844,21 @@ async function handleCountImages() {
         allImages.push(key.slice(1));
       }
     }
-    return NextResponse.json({
+    return jsonResponse({
       count: allImages.length,
       images: allImages
     });
   } catch (error) {
     console.error("Failed to count images:", error);
-    return NextResponse.json({ error: "Failed to count images" }, { status: 500 });
+    return jsonResponse({ error: "Failed to count images" }, { status: 500 });
   }
 }
 async function handleFolderImages(request) {
   try {
-    const searchParams = request.nextUrl.searchParams;
+    const searchParams = new URL(request.url).searchParams;
     const foldersParam = searchParams.get("folders");
     if (!foldersParam) {
-      return NextResponse.json({ error: "No folders provided" }, { status: 400 });
+      return jsonResponse({ error: "No folders provided" }, { status: 400 });
     }
     const folders = foldersParam.split(",");
     const meta = await loadMeta();
@@ -836,19 +876,18 @@ async function handleFolderImages(request) {
         }
       }
     }
-    return NextResponse.json({
+    return jsonResponse({
       count: allFiles.length,
       images: allFiles
       // Keep as 'images' for backwards compatibility
     });
   } catch (error) {
     console.error("Failed to get folder files:", error);
-    return NextResponse.json({ error: "Failed to get folder files" }, { status: 500 });
+    return jsonResponse({ error: "Failed to get folder files" }, { status: 500 });
   }
 }
 
 // src/handlers/files.ts
-import { NextResponse as NextResponse2 } from "next/server";
 import { promises as fs5 } from "fs";
 import path5 from "path";
 import sharp2 from "sharp";
@@ -858,7 +897,7 @@ async function handleUpload(request) {
     const file = formData.get("file");
     const targetPath = formData.get("path") || "public";
     if (!file) {
-      return NextResponse2.json({ error: "No file provided" }, { status: 400 });
+      return jsonResponse({ error: "No file provided" }, { status: 400 });
     }
     const bytes = await file.arrayBuffer();
     const buffer = Buffer.from(bytes);
@@ -874,7 +913,7 @@ async function handleUpload(request) {
       relativeDir = targetPath.replace("public/", "");
     }
     if (relativeDir === "images" || relativeDir.startsWith("images/")) {
-      return NextResponse2.json(
+      return jsonResponse(
         { error: "Cannot upload to images/ folder. Upload to public/ instead - thumbnails are generated automatically." },
         { status: 400 }
       );
@@ -897,7 +936,7 @@ async function handleUpload(request) {
     await fs5.mkdir(uploadDir, { recursive: true });
     await fs5.writeFile(path5.join(uploadDir, actualFileName), buffer);
     if (!isMedia) {
-      return NextResponse2.json({
+      return jsonResponse({
         success: true,
         message: "File uploaded (not a media file)",
         path: `public/${relativeDir ? relativeDir + "/" : ""}${actualFileName}`
@@ -916,7 +955,7 @@ async function handleUpload(request) {
       meta[imageKey] = {};
     }
     await saveMeta(meta);
-    return NextResponse2.json({
+    return jsonResponse({
       success: true,
       imageKey,
       message: 'File uploaded. Run "Process Images" to generate thumbnails.'
@@ -924,14 +963,14 @@ async function handleUpload(request) {
   } catch (error) {
     console.error("Failed to upload:", error);
     const message = error instanceof Error ? error.message : "Unknown error";
-    return NextResponse2.json({ error: `Failed to upload file: ${message}` }, { status: 500 });
+    return jsonResponse({ error: `Failed to upload file: ${message}` }, { status: 500 });
   }
 }
 async function handleDelete(request) {
   try {
     const { paths } = await request.json();
     if (!paths || !Array.isArray(paths) || paths.length === 0) {
-      return NextResponse2.json({ error: "No paths provided" }, { status: 400 });
+      return jsonResponse({ error: "No paths provided" }, { status: 400 });
     }
     const meta = await loadMeta();
     const deleted = [];
@@ -1007,68 +1046,68 @@ async function handleDelete(request) {
       }
     }
     await saveMeta(meta);
-    return NextResponse2.json({
+    return jsonResponse({
       success: true,
       deleted,
       errors: errors.length > 0 ? errors : void 0
     });
   } catch (error) {
     console.error("Failed to delete:", error);
-    return NextResponse2.json({ error: "Failed to delete files" }, { status: 500 });
+    return jsonResponse({ error: "Failed to delete files" }, { status: 500 });
   }
 }
 async function handleCreateFolder(request) {
   try {
     const { parentPath, name } = await request.json();
     if (!name || typeof name !== "string") {
-      return NextResponse2.json({ error: "Folder name is required" }, { status: 400 });
+      return jsonResponse({ error: "Folder name is required" }, { status: 400 });
     }
     const sanitizedName = name.replace(/[<>:"/\\|?*]/g, "").trim();
     if (!sanitizedName) {
-      return NextResponse2.json({ error: "Invalid folder name" }, { status: 400 });
+      return jsonResponse({ error: "Invalid folder name" }, { status: 400 });
     }
     const safePath = (parentPath || "public").replace(/\.\./g, "");
     const folderPath = getWorkspacePath(safePath, sanitizedName);
     if (!folderPath.startsWith(getPublicPath())) {
-      return NextResponse2.json({ error: "Invalid path" }, { status: 400 });
+      return jsonResponse({ error: "Invalid path" }, { status: 400 });
     }
     try {
       await fs5.access(folderPath);
-      return NextResponse2.json({ error: "A folder with this name already exists" }, { status: 400 });
+      return jsonResponse({ error: "A folder with this name already exists" }, { status: 400 });
     } catch {
     }
     await fs5.mkdir(folderPath, { recursive: true });
-    return NextResponse2.json({ success: true, path: path5.join(safePath, sanitizedName) });
+    return jsonResponse({ success: true, path: path5.join(safePath, sanitizedName) });
   } catch (error) {
     console.error("Failed to create folder:", error);
-    return NextResponse2.json({ error: "Failed to create folder" }, { status: 500 });
+    return jsonResponse({ error: "Failed to create folder" }, { status: 500 });
   }
 }
 async function handleRename(request) {
   try {
     const { oldPath, newName } = await request.json();
     if (!oldPath || !newName) {
-      return NextResponse2.json({ error: "Path and new name are required" }, { status: 400 });
+      return jsonResponse({ error: "Path and new name are required" }, { status: 400 });
     }
     const sanitizedName = newName.replace(/[<>:"/\\|?*]/g, "").trim();
     if (!sanitizedName) {
-      return NextResponse2.json({ error: "Invalid name" }, { status: 400 });
+      return jsonResponse({ error: "Invalid name" }, { status: 400 });
     }
     const safePath = oldPath.replace(/\.\./g, "");
     const absoluteOldPath = getWorkspacePath(safePath);
     const parentDir = path5.dirname(absoluteOldPath);
     const absoluteNewPath = path5.join(parentDir, sanitizedName);
     if (!absoluteOldPath.startsWith(getPublicPath())) {
-      return NextResponse2.json({ error: "Invalid path" }, { status: 400 });
+      return jsonResponse({ error: "Invalid path" }, { status: 400 });
     }
     try {
       await fs5.access(absoluteOldPath);
     } catch {
-      return NextResponse2.json({ error: "File or folder not found" }, { status: 404 });
+      return jsonResponse({ error: "File or folder not found" }, { status: 404 });
     }
     try {
       await fs5.access(absoluteNewPath);
-      return NextResponse2.json({ error: "An item with this name already exists" }, { status: 400 });
+      return jsonResponse({ error: "An item with this name already exists" }, { status: 400 });
     } catch {
     }
     const stats = await fs5.stat(absoluteOldPath);
@@ -1100,10 +1139,10 @@ async function handleRename(request) {
       await saveMeta(meta);
     }
     const newPath = path5.join(path5.dirname(safePath), sanitizedName);
-    return NextResponse2.json({ success: true, newPath });
+    return jsonResponse({ success: true, newPath });
   } catch (error) {
     console.error("Failed to rename:", error);
-    return NextResponse2.json({ error: "Failed to rename" }, { status: 500 });
+    return jsonResponse({ error: "Failed to rename" }, { status: 500 });
   }
 }
 async function handleMoveStream(request) {
@@ -1287,7 +1326,6 @@ async function handleMoveStream(request) {
 }
 
 // src/handlers/images.ts
-import { NextResponse as NextResponse3 } from "next/server";
 import { promises as fs6 } from "fs";
 import path6 from "path";
 import { S3Client as S3Client2, PutObjectCommand as PutObjectCommand2 } from "@aws-sdk/client-s3";
@@ -1298,7 +1336,7 @@ async function handleSync(request) {
   const bucketName = process.env.CLOUDFLARE_R2_BUCKET_NAME;
   const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/\s*$/, "");
   if (!accountId || !accessKeyId || !secretAccessKey || !bucketName || !publicUrl) {
-    return NextResponse3.json(
+    return jsonResponse(
       { error: "R2 not configured. Set CLOUDFLARE_R2_* environment variables." },
       { status: 400 }
     );
@@ -1306,7 +1344,7 @@ async function handleSync(request) {
   try {
     const { imageKeys } = await request.json();
     if (!imageKeys || !Array.isArray(imageKeys) || imageKeys.length === 0) {
-      return NextResponse3.json({ error: "No image keys provided" }, { status: 400 });
+      return jsonResponse({ error: "No image keys provided" }, { status: 400 });
     }
     const meta = await loadMeta();
     const cdnUrls = getCdnUrls(meta);
@@ -1401,91 +1439,14 @@ async function handleSync(request) {
     if (urlsToPurge.length > 0) {
       await purgeCloudflareCache(urlsToPurge);
     }
-    return NextResponse3.json({
+    return jsonResponse({
       success: true,
       pushed,
       errors: errors.length > 0 ? errors : void 0
     });
   } catch (error) {
     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 (let imageKey of imageKeys) {
-      if (!imageKey.startsWith("/")) {
-        imageKey = `/${imageKey}`;
-      }
-      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 = getPublicPath(imageKey);
-        try {
-          buffer = await fs6.readFile(originalPath);
-        } catch {
-          if (isInOurR2) {
-            buffer = await downloadFromCdn(imageKey);
-            const dir = path6.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 = path6.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 (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);
-      } catch (error) {
-        console.error(`Failed to reprocess ${imageKey}:`, error);
-        errors.push(imageKey);
-      }
-    }
-    await saveMeta(meta);
-    if (urlsToPurge.length > 0) {
-      await purgeCloudflareCache(urlsToPurge);
-    }
-    return NextResponse3.json({
-      success: true,
-      processed,
-      errors: errors.length > 0 ? errors : void 0
-    });
-  } catch (error) {
-    console.error("Failed to reprocess:", error);
-    return NextResponse3.json({ error: "Failed to reprocess images" }, { status: 500 });
+    return jsonResponse({ error: "Failed to push to CDN" }, { status: 500 });
   }
 }
 async function handleUnprocessStream(request) {
@@ -1496,10 +1457,10 @@ async function handleUnprocessStream(request) {
     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 });
+      return jsonResponse({ error: "No image keys provided" }, { status: 400 });
     }
   } catch {
-    return NextResponse3.json({ error: "Invalid request body" }, { status: 400 });
+    return jsonResponse({ error: "Invalid request body" }, { status: 400 });
   }
   const stream = new ReadableStream({
     async start(controller) {
@@ -1605,10 +1566,10 @@ async function handleReprocessStream(request) {
     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 });
+      return jsonResponse({ error: "No image keys provided" }, { status: 400 });
     }
   } catch {
-    return NextResponse3.json({ error: "Invalid request body" }, { status: 400 });
+    return jsonResponse({ error: "Invalid request body" }, { status: 400 });
   }
   const stream = new ReadableStream({
     async start(controller) {
@@ -1735,203 +1696,10 @@ async function handleReprocessStream(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) {
-      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 orphansRemoved = [];
-        const urlsToPurge = [];
-        let alreadyProcessed = 0;
-        const imagesToProcess = [];
-        for (const [key, entry] of getFileEntries(meta)) {
-          const fileName = path6.basename(key);
-          if (!isImageFile(fileName)) continue;
-          if (!isProcessed(entry)) {
-            imagesToProcess.push({ key, entry });
-          } else {
-            alreadyProcessed++;
-          }
-        }
-        const total = imagesToProcess.length;
-        sendEvent({ type: "start", total });
-        for (let i = 0; i < imagesToProcess.length; i++) {
-          const { key, entry } = imagesToProcess[i];
-          const fullPath = getPublicPath(key);
-          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,
-            total,
-            percent: Math.round((i + 1) / total * 100),
-            currentFile: key.slice(1)
-            // Remove leading /
-          });
-          try {
-            let buffer;
-            if (isInOurR2) {
-              buffer = await downloadFromCdn(key);
-              const dir = path6.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 = path6.dirname(fullPath);
-              await fs6.mkdir(dir, { recursive: true });
-              await fs6.writeFile(fullPath, buffer);
-            } else {
-              buffer = await fs6.readFile(fullPath);
-            }
-            const ext = path6.extname(key).toLowerCase();
-            const isSvg = ext === ".svg";
-            if (isSvg) {
-              const imageDir = path6.dirname(key.slice(1));
-              const imagesPath = getPublicPath("images", imageDir === "." ? "" : imageDir);
-              await fs6.mkdir(imagesPath, { recursive: true });
-              const fileName = path6.basename(key);
-              const destPath = path6.join(imagesPath, fileName);
-              await fs6.writeFile(destPath, buffer);
-              meta[key] = {
-                ...entry,
-                o: { w: 0, h: 0 },
-                b: "",
-                f: { w: 0, h: 0 }
-                // SVG has "full" to indicate processed
-              };
-              if (isRemote) {
-                delete meta[key].c;
-              }
-            } else {
-              const processedEntry = await processImage(buffer, key);
-              meta[key] = {
-                ...processedEntry,
-                ...isInOurR2 ? { c: existingCdnIndex } : {}
-              };
-            }
-            if (isInOurR2) {
-              await uploadToCdn(key);
-              for (const thumbPath of getAllThumbnailPaths(key)) {
-                urlsToPurge.push(`${publicUrl}${thumbPath}`);
-              }
-              await deleteLocalThumbnails(key);
-              try {
-                await fs6.unlink(fullPath);
-              } catch {
-              }
-            }
-            processed.push(key.slice(1));
-          } catch (error) {
-            console.error(`Failed to process ${key}:`, error);
-            errors.push(key.slice(1));
-          }
-        }
-        sendEvent({ type: "cleanup", message: "Removing orphaned thumbnails..." });
-        const trackedPaths = /* @__PURE__ */ new Set();
-        for (const [imageKey, entry] of getFileEntries(meta)) {
-          if (entry.c === void 0) {
-            for (const thumbPath of getAllThumbnailPaths(imageKey)) {
-              trackedPaths.add(thumbPath);
-            }
-          }
-        }
-        async function findOrphans(dir, relativePath = "") {
-          try {
-            const entries = await fs6.readdir(dir, { withFileTypes: true });
-            for (const fsEntry of entries) {
-              if (fsEntry.name.startsWith(".")) continue;
-              const entryFullPath = path6.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(entryFullPath);
-                    orphansRemoved.push(publicPath);
-                  } catch (err) {
-                    console.error(`Failed to remove orphan ${publicPath}:`, err);
-                  }
-                }
-              }
-            }
-          } catch {
-          }
-        }
-        const imagesDir = getPublicPath("images");
-        try {
-          await findOrphans(imagesDir);
-        } catch {
-        }
-        async function removeEmptyDirs(dir) {
-          try {
-            const entries = await fs6.readdir(dir, { withFileTypes: true });
-            let isEmpty = true;
-            for (const fsEntry of entries) {
-              if (fsEntry.isDirectory()) {
-                const subDirEmpty = await removeEmptyDirs(path6.join(dir, fsEntry.name));
-                if (!subDirEmpty) isEmpty = false;
-              } else {
-                isEmpty = false;
-              }
-            }
-            if (isEmpty && dir !== imagesDir) {
-              await fs6.rmdir(dir);
-            }
-            return isEmpty;
-          } catch {
-            return true;
-          }
-        }
-        try {
-          await removeEmptyDirs(imagesDir);
-        } catch {
-        }
-        await saveMeta(meta);
-        if (urlsToPurge.length > 0) {
-          await purgeCloudflareCache(urlsToPurge);
-        }
-        sendEvent({
-          type: "complete",
-          processed: processed.length,
-          alreadyProcessed,
-          orphansRemoved: orphansRemoved.length,
-          errors: errors.length
-        });
-      } catch (error) {
-        console.error("Failed to process all:", error);
-        sendEvent({ type: "error", message: "Failed to process images" });
-      } finally {
-        controller.close();
-      }
-    }
-  });
-  return new Response(stream, {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      "Connection": "keep-alive"
-    }
-  });
-}
 async function handleDownloadStream(request) {
   const { imageKeys } = await request.json();
   if (!imageKeys || !Array.isArray(imageKeys) || imageKeys.length === 0) {
-    return NextResponse3.json({ error: "No image keys provided" }, { status: 400 });
+    return jsonResponse({ error: "No image keys provided" }, { status: 400 });
   }
   const stream = new ReadableStream({
     async start(controller) {
@@ -2026,7 +1794,6 @@ async function handleDownloadStream(request) {
 }
 
 // src/handlers/scan.ts
-import { NextResponse as NextResponse4 } from "next/server";
 import { promises as fs7 } from "fs";
 import path7 from "path";
 import sharp3 from "sharp";
@@ -2200,7 +1967,7 @@ async function handleDeleteOrphans(request) {
   try {
     const { paths } = await request.json();
     if (!paths || !Array.isArray(paths) || paths.length === 0) {
-      return NextResponse4.json({ error: "No paths provided" }, { status: 400 });
+      return jsonResponse({ error: "No paths provided" }, { status: 400 });
     }
     const deleted = [];
     const errors = [];
@@ -2243,14 +2010,14 @@ async function handleDeleteOrphans(request) {
       await removeEmptyDirs(imagesDir);
     } catch {
     }
-    return NextResponse4.json({
+    return jsonResponse({
       success: true,
       deleted: deleted.length,
       errors: errors.length
     });
   } catch (error) {
     console.error("Failed to delete orphans:", error);
-    return NextResponse4.json({ error: "Failed to delete orphaned files" }, { status: 500 });
+    return jsonResponse({ error: "Failed to delete orphaned files" }, { status: 500 });
   }
 }
 
@@ -2379,7 +2146,6 @@ async function handleUpdateCdns(request) {
 }
 
 // src/handlers/favicon.ts
-import { NextResponse as NextResponse5 } from "next/server";
 import sharp5 from "sharp";
 import path8 from "path";
 import fs8 from "fs/promises";
@@ -2395,14 +2161,14 @@ async function handleGenerateFavicon(request) {
     const body = await request.json();
     imagePath = body.imagePath;
     if (!imagePath) {
-      return NextResponse5.json({ error: "No image path provided" }, { status: 400 });
+      return jsonResponse({ error: "No image path provided" }, { status: 400 });
     }
   } catch {
-    return NextResponse5.json({ error: "Invalid request body" }, { status: 400 });
+    return jsonResponse({ error: "Invalid request body" }, { status: 400 });
   }
   const fileName = path8.basename(imagePath).toLowerCase();
   if (fileName !== "favicon.png" && fileName !== "favicon.jpg") {
-    return NextResponse5.json({
+    return jsonResponse({
       error: "Source file must be named favicon.png or favicon.jpg"
     }, { status: 400 });
   }
@@ -2410,19 +2176,19 @@ async function handleGenerateFavicon(request) {
   try {
     await fs8.access(sourcePath);
   } catch {
-    return NextResponse5.json({ error: "Source file not found" }, { status: 404 });
+    return jsonResponse({ error: "Source file not found" }, { status: 404 });
   }
   let metadata;
   try {
     metadata = await sharp5(sourcePath).metadata();
   } catch {
-    return NextResponse5.json({ error: "Source file is not a valid image" }, { status: 400 });
+    return jsonResponse({ error: "Source file is not a valid image" }, { status: 400 });
   }
   const outputDir = getSrcAppPath();
   try {
     await fs8.access(outputDir);
   } catch {
-    return NextResponse5.json({
+    return jsonResponse({
       error: "Output directory src/app/ not found"
     }, { status: 500 });
   }
@@ -2490,98 +2256,147 @@ async function handleGenerateFavicon(request) {
   });
 }
 
-// src/handlers/index.ts
-async function GET(request) {
-  if (process.env.NODE_ENV !== "development") {
-    return NextResponse6.json({ error: "Not available in production" }, { status: 403 });
-  }
-  const pathname = request.nextUrl.pathname;
-  const route = pathname.replace(/^\/api\/studio\/?/, "");
-  if (route === "list-folders") {
-    return handleListFolders();
-  }
-  if (route === "list" || route.startsWith("list")) {
-    return handleList(request);
-  }
-  if (route === "count-images") {
-    return handleCountImages();
-  }
-  if (route === "folder-images") {
-    return handleFolderImages(request);
-  }
-  if (route === "search") {
-    return handleSearch(request);
-  }
-  if (route === "cdns") {
-    return handleGetCdns();
-  }
-  return NextResponse6.json({ error: "Not found" }, { status: 404 });
+// src/server/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+async function startServer(options) {
+  const { port, workspace, open } = options;
+  const app = express();
+  process.env.STUDIO_WORKSPACE = workspace;
+  const envLocalPath = join(workspace, ".env.local");
+  const envPath = join(workspace, ".env");
+  if (existsSync(envLocalPath)) {
+    loadEnv({ path: envLocalPath });
+    console.log("Loaded environment from .env.local");
+  } else if (existsSync(envPath)) {
+    loadEnv({ path: envPath });
+    console.log("Loaded environment from .env");
+  }
+  app.use(express.json({ limit: "50mb" }));
+  app.use(express.urlencoded({ extended: true, limit: "50mb" }));
+  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/create-folder", wrapHandler(handleCreateFolder));
+  app.post("/api/studio/rename", wrapHandler(handleRename));
+  app.post("/api/studio/move", wrapHandler(handleMoveStream, true));
+  app.post("/api/studio/sync", wrapHandler(handleSync, 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));
+  app.post("/api/studio/scan", wrapHandler(handleScanStream, true));
+  app.post("/api/studio/delete-orphans", wrapHandler(handleDeleteOrphans));
+  app.post("/api/studio/import", wrapHandler(handleImportUrls, true));
+  app.post("/api/studio/cdns", wrapHandler(handleUpdateCdns));
+  app.post("/api/studio/generate-favicon", wrapHandler(handleGenerateFavicon, true));
+  app.delete("/api/studio/delete", wrapHandler(handleDelete));
+  app.use("/public", express.static(join(workspace, "public")));
+  const clientDir = resolve(__dirname, "../client");
+  app.get("/", (req, res) => {
+    const htmlPath = join(clientDir, "index.html");
+    if (existsSync(htmlPath)) {
+      let html = readFileSync(htmlPath, "utf-8");
+      const script = `<script>window.__STUDIO_WORKSPACE__ = ${JSON.stringify(workspace)};</script>`;
+      html = html.replace("</head>", `${script}</head>`);
+      res.type("html").send(html);
+    } else {
+      res.status(404).send("Client not built. Run npm run build first.");
+    }
+  });
+  app.use(express.static(clientDir));
+  app.listen(port, () => {
+    console.log(`
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502  Studio - Media Manager             \u2502
+\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524
+\u2502  Workspace: ${workspace.length > 24 ? "..." + workspace.slice(-21) : workspace.padEnd(24)}\u2502
+\u2502  URL: http://localhost:${port}         \u2502
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+`);
+    if (open) {
+      import("open").then((mod) => {
+        mod.default(`http://localhost:${port}`);
+      }).catch(() => {
+      });
+    }
+  });
 }
-async function POST(request) {
-  if (process.env.NODE_ENV !== "development") {
-    return NextResponse6.json({ error: "Not available in production" }, { status: 403 });
-  }
-  const pathname = request.nextUrl.pathname;
-  const route = pathname.replace(/^\/api\/studio\/?/, "");
-  if (route === "upload") {
-    return handleUpload(request);
-  }
-  if (route === "delete") {
-    return handleDelete(request);
-  }
-  if (route === "sync") {
-    return handleSync(request);
-  }
-  if (route === "reprocess") {
-    return handleReprocess(request);
-  }
-  if (route === "reprocess-stream") {
-    return handleReprocessStream(request);
-  }
-  if (route === "unprocess-stream") {
-    return handleUnprocessStream(request);
-  }
-  if (route === "process-all") {
-    return handleProcessAllStream();
-  }
-  if (route === "download-stream") {
-    return handleDownloadStream(request);
-  }
-  if (route === "create-folder") {
-    return handleCreateFolder(request);
-  }
-  if (route === "rename") {
-    return handleRename(request);
-  }
-  if (route === "move") {
-    return handleMoveStream(request);
-  }
-  if (route === "scan") {
-    return handleScanStream();
-  }
-  if (route === "delete-orphans") {
-    return handleDeleteOrphans(request);
-  }
-  if (route === "import") {
-    return handleImportUrls(request);
-  }
-  if (route === "cdns") {
-    return handleUpdateCdns(request);
+function wrapHandler(handler, streaming = false) {
+  return async (req, res) => {
+    try {
+      const request = createFetchRequest(req);
+      const response = await handler(request);
+      if (streaming) {
+        await sendStreamingResponse(res, response);
+      } else {
+        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();
+  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);
+      }
+    }
   }
-  if (route === "generate-favicon") {
-    return handleGenerateFavicon(request);
+  const init = {
+    method: req.method,
+    headers
+  };
+  if (req.method !== "GET" && req.method !== "HEAD") {
+    if (req.body) {
+      init.body = JSON.stringify(req.body);
+    }
   }
-  return NextResponse6.json({ error: "Not found" }, { status: 404 });
+  return new globalThis.Request(url.toString(), init);
+}
+async function sendResponse(res, response) {
+  res.status(response.status);
+  response.headers.forEach((value, key) => {
+    res.setHeader(key, value);
+  });
+  const body = await response.text();
+  res.send(body);
 }
-async function DELETE(request) {
-  if (process.env.NODE_ENV !== "development") {
-    return NextResponse6.json({ error: "Not available in production" }, { status: 403 });
+async function sendStreamingResponse(res, response) {
+  res.status(response.status);
+  response.headers.forEach((value, key) => {
+    res.setHeader(key, value);
+  });
+  if (response.body) {
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        res.write(decoder.decode(value, { stream: true }));
+      }
+      res.end();
+    } catch (error) {
+      console.error("Streaming error:", error);
+      res.end();
+    }
+  } else {
+    const body = await response.text();
+    res.send(body);
   }
-  return handleDelete(request);
 }
 export {
-  DELETE,
-  GET,
-  POST
+  startServer
 };
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.js.map