simple-photo-gallery 2.0.9 → 2.0.10-rc.1

package/dist/index.js

@@ -3,74 +3,19 @@ import process3, { stdout } from 'process';
 import { Command } from 'commander';
 import { LogLevels, createConsola } from 'consola';
 import { execSync, spawn } from 'child_process';
-import fs6, { promises } from 'fs';
-import path4 from 'path';
-import { z } from 'zod';
+import fs8, { promises } from 'fs';
+import path7 from 'path';
 import { Buffer } from 'buffer';
 import sharp2 from 'sharp';
-import ExifReader from 'exifreader';
 import { encode } from 'blurhash';
+import ExifReader from 'exifreader';
+import { z } from 'zod';
 import ffprobe from 'node-ffprobe';
 import os from 'os';
 import Conf from 'conf';
 import axios from 'axios';
 import { compareSemVer, parseSemVer } from 'semver-parser';
 
-var ThumbnailSchema = z.object({
-  path: z.string(),
-  pathRetina: z.string(),
-  width: z.number(),
-  height: z.number(),
-  blurHash: z.string().optional()
-});
-var MediaFileSchema = z.object({
-  type: z.enum(["image", "video"]),
-  path: z.string(),
-  alt: z.string().optional(),
-  width: z.number(),
-  height: z.number(),
-  thumbnail: ThumbnailSchema.optional(),
-  lastMediaTimestamp: z.string().optional()
-});
-var GallerySectionSchema = z.object({
-  title: z.string().optional(),
-  description: z.string().optional(),
-  images: z.array(MediaFileSchema)
-});
-var SubGallerySchema = z.object({
-  title: z.string(),
-  headerImage: z.string(),
-  path: z.string()
-});
-var GalleryMetadataSchema = z.object({
-  image: z.string().optional(),
-  imageWidth: z.number().optional(),
-  imageHeight: z.number().optional(),
-  ogUrl: z.string().optional(),
-  ogType: z.string().optional(),
-  ogSiteName: z.string().optional(),
-  twitterSite: z.string().optional(),
-  twitterCreator: z.string().optional(),
-  author: z.string().optional(),
-  keywords: z.string().optional(),
-  canonicalUrl: z.string().optional(),
-  language: z.string().optional(),
-  robots: z.string().optional()
-});
-var GalleryDataSchema = z.object({
-  title: z.string(),
-  description: z.string(),
-  url: z.string().optional(),
-  headerImage: z.string(),
-  thumbnailSize: z.number().optional(),
-  metadata: GalleryMetadataSchema,
-  galleryOutputPath: z.string().optional(),
-  mediaBaseUrl: z.string().optional(),
-  analyticsScript: z.string().optional(),
-  sections: z.array(GallerySectionSchema),
-  subGalleries: z.object({ title: z.string(), galleries: z.array(SubGallerySchema) })
-});
-
 // src/config/index.ts
 var DEFAULT_THUMBNAIL_SIZE = 300;
 var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".gif", ".webp", ".tiff", ".tif", ".svg", ".avif"]);
@@ -138,13 +83,22 @@ async function createImageThumbnails(image, metadata, outputPath, outputPathReti
   return { width, height };
 }
 
+// src/utils/blurhash.ts
+async function generateBlurHash(imagePath, componentX = 4, componentY = 3) {
+  const image = await loadImage(imagePath);
+  const { data, info } = await image.resize(32, 32, { fit: "inside" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  const pixels = new Uint8ClampedArray(data.buffer);
+  return encode(pixels, info.width, info.height, componentX, componentY);
+}
+
 // src/modules/build/utils/index.ts
-path4.dirname(new URL(import.meta.url).pathname);
+path7.dirname(new URL(import.meta.url).pathname);
 async function createGallerySocialMediaCardImage(headerPhotoPath, title, ouputPath, ui) {
   ui.start(`Creating social media card image`);
-  if (fs6.existsSync(ouputPath)) {
+  const headerBasename = path7.basename(headerPhotoPath, path7.extname(headerPhotoPath));
+  if (fs8.existsSync(ouputPath)) {
     ui.success(`Social media card image already exists`);
-    return;
+    return headerBasename;
   }
   const image = await loadImage(headerPhotoPath);
   const resizedImageBuffer = await image.resize(1200, 631, { fit: "cover" }).jpeg({ quality: 90 }).toBuffer();
@@ -164,76 +118,115 @@ async function createGallerySocialMediaCardImage(headerPhotoPath, title, ouputPa
   const finalImageBuffer = await sharp2(resizedImageBuffer).composite([{ input: Buffer.from(svgText), top: 0, left: 0 }]).jpeg({ quality: 90 }).toBuffer();
   await sharp2(finalImageBuffer).toFile(outputPath);
   ui.success(`Created social media card image successfully`);
+  return headerBasename;
 }
 async function createOptimizedHeaderImage(headerPhotoPath, outputFolder, ui) {
   ui.start(`Creating optimized header images`);
   const image = await loadImage(headerPhotoPath);
+  const headerBasename = path7.basename(headerPhotoPath, path7.extname(headerPhotoPath));
+  const generatedFiles = [];
+  ui.debug("Generating blurhash for header image");
+  const blurHash = await generateBlurHash(headerPhotoPath);
   const landscapeYFactor = 3 / 4;
   for (const width of HEADER_IMAGE_LANDSCAPE_WIDTHS) {
     ui.debug(`Creating landscape header image ${width}`);
-    if (fs6.existsSync(path4.join(outputFolder, `header_landscape_${width}.avif`))) {
+    const avifFilename = `${headerBasename}_landscape_${width}.avif`;
+    const jpgFilename = `${headerBasename}_landscape_${width}.jpg`;
+    if (fs8.existsSync(path7.join(outputFolder, avifFilename))) {
       ui.debug(`Landscape header image ${width} AVIF already exists`);
     } else {
       await cropAndResizeImage(
         image.clone(),
-        path4.join(outputFolder, `header_landscape_${width}.avif`),
+        path7.join(outputFolder, avifFilename),
         width,
         width * landscapeYFactor,
         "avif"
       );
     }
-    if (fs6.existsSync(path4.join(outputFolder, `header_landscape_${width}.jpg`))) {
+    generatedFiles.push(avifFilename);
+    if (fs8.existsSync(path7.join(outputFolder, jpgFilename))) {
       ui.debug(`Landscape header image ${width} JPG already exists`);
     } else {
-      await cropAndResizeImage(
-        image.clone(),
-        path4.join(outputFolder, `header_landscape_${width}.jpg`),
-        width,
-        width * landscapeYFactor,
-        "jpg"
-      );
+      await cropAndResizeImage(image.clone(), path7.join(outputFolder, jpgFilename), width, width * landscapeYFactor, "jpg");
     }
+    generatedFiles.push(jpgFilename);
   }
   const portraitYFactor = 4 / 3;
   for (const width of HEADER_IMAGE_PORTRAIT_WIDTHS) {
     ui.debug(`Creating portrait header image ${width}`);
-    if (fs6.existsSync(path4.join(outputFolder, `header_portrait_${width}.avif`))) {
+    const avifFilename = `${headerBasename}_portrait_${width}.avif`;
+    const jpgFilename = `${headerBasename}_portrait_${width}.jpg`;
+    if (fs8.existsSync(path7.join(outputFolder, avifFilename))) {
       ui.debug(`Portrait header image ${width} AVIF already exists`);
     } else {
-      await cropAndResizeImage(
-        image.clone(),
-        path4.join(outputFolder, `header_portrait_${width}.avif`),
-        width,
-        width * portraitYFactor,
-        "avif"
-      );
+      await cropAndResizeImage(image.clone(), path7.join(outputFolder, avifFilename), width, width * portraitYFactor, "avif");
     }
-    if (fs6.existsSync(path4.join(outputFolder, `header_portrait_${width}.jpg`))) {
+    generatedFiles.push(avifFilename);
+    if (fs8.existsSync(path7.join(outputFolder, jpgFilename))) {
       ui.debug(`Portrait header image ${width} JPG already exists`);
     } else {
-      await cropAndResizeImage(
-        image.clone(),
-        path4.join(outputFolder, `header_portrait_${width}.jpg`),
-        width,
-        width * portraitYFactor,
-        "jpg"
-      );
+      await cropAndResizeImage(image.clone(), path7.join(outputFolder, jpgFilename), width, width * portraitYFactor, "jpg");
     }
+    generatedFiles.push(jpgFilename);
   }
   ui.success(`Created optimized header image successfully`);
+  return { headerBasename, generatedFiles, blurHash };
+}
+function hasOldHeaderImages(outputFolder, currentHeaderBasename) {
+  if (!fs8.existsSync(outputFolder)) {
+    return false;
+  }
+  const files = fs8.readdirSync(outputFolder);
+  for (const file of files) {
+    const landscapeMatch = file.match(/^(.+)_landscape_\d+\.(avif|jpg)$/);
+    const portraitMatch = file.match(/^(.+)_portrait_\d+\.(avif|jpg)$/);
+    if (landscapeMatch && landscapeMatch[1] !== currentHeaderBasename || portraitMatch && portraitMatch[1] !== currentHeaderBasename) {
+      return true;
+    }
+  }
+  return false;
+}
+function cleanupOldHeaderImages(outputFolder, currentHeaderBasename, ui) {
+  ui.start(`Cleaning up old header images`);
+  if (!fs8.existsSync(outputFolder)) {
+    ui.debug(`Output folder ${outputFolder} does not exist, skipping cleanup`);
+    return;
+  }
+  const files = fs8.readdirSync(outputFolder);
+  let deletedCount = 0;
+  for (const file of files) {
+    const landscapeMatch = file.match(/^(.+)_landscape_\d+\.(avif|jpg)$/);
+    const portraitMatch = file.match(/^(.+)_portrait_\d+\.(avif|jpg)$/);
+    if (landscapeMatch && landscapeMatch[1] !== currentHeaderBasename) {
+      const filePath = path7.join(outputFolder, file);
+      ui.debug(`Deleting old landscape header image: ${file}`);
+      fs8.unlinkSync(filePath);
+      deletedCount++;
+    } else if (portraitMatch && portraitMatch[1] !== currentHeaderBasename) {
+      const filePath = path7.join(outputFolder, file);
+      ui.debug(`Deleting old portrait header image: ${file}`);
+      fs8.unlinkSync(filePath);
+      deletedCount++;
+    }
+  }
+  if (deletedCount > 0) {
+    ui.success(`Deleted ${deletedCount} old header image(s)`);
+  } else {
+    ui.debug(`No old header images to clean up`);
+  }
 }
 function findGalleries(basePath, recursive) {
   const galleryDirs = [];
-  const galleryJsonPath = path4.join(basePath, "gallery", "gallery.json");
-  if (fs6.existsSync(galleryJsonPath)) {
+  const galleryJsonPath = path7.join(basePath, "gallery", "gallery.json");
+  if (fs8.existsSync(galleryJsonPath)) {
     galleryDirs.push(basePath);
   }
   if (recursive) {
     try {
-      const entries = fs6.readdirSync(basePath, { withFileTypes: true });
+      const entries = fs8.readdirSync(basePath, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory() && entry.name !== "gallery") {
-          const subPath = path4.join(basePath, entry.name);
+          const subPath = path7.join(basePath, entry.name);
           const subResults = findGalleries(subPath, recursive);
           galleryDirs.push(...subResults);
         }
@@ -261,16 +254,335 @@ function parseTelemetryOption(value) {
   }
   return value;
 }
+var ThumbnailSchema = z.object({
+  path: z.string(),
+  pathRetina: z.string(),
+  width: z.number(),
+  height: z.number(),
+  blurHash: z.string().optional()
+});
+var MediaFileSchema = z.object({
+  type: z.enum(["image", "video"]),
+  filename: z.string(),
+  alt: z.string().optional(),
+  width: z.number(),
+  height: z.number(),
+  thumbnail: ThumbnailSchema.optional(),
+  lastMediaTimestamp: z.string().optional()
+});
+var MediaFileDeprecatedSchema = z.object({
+  type: z.enum(["image", "video"]),
+  path: z.string(),
+  alt: z.string().optional(),
+  width: z.number(),
+  height: z.number(),
+  thumbnail: ThumbnailSchema.optional(),
+  lastMediaTimestamp: z.string().optional()
+});
+var GallerySectionSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  images: z.array(MediaFileSchema)
+});
+var GallerySectionDeprecatedSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  images: z.array(MediaFileDeprecatedSchema)
+});
+var SubGallerySchema = z.object({
+  title: z.string(),
+  headerImage: z.string(),
+  path: z.string()
+});
+var GalleryMetadataSchema = z.object({
+  image: z.string().optional(),
+  imageWidth: z.number().optional(),
+  imageHeight: z.number().optional(),
+  ogUrl: z.string().optional(),
+  ogType: z.string().optional(),
+  ogSiteName: z.string().optional(),
+  twitterSite: z.string().optional(),
+  twitterCreator: z.string().optional(),
+  author: z.string().optional(),
+  keywords: z.string().optional(),
+  canonicalUrl: z.string().optional(),
+  language: z.string().optional(),
+  robots: z.string().optional()
+});
+var GalleryDataSchema = z.object({
+  title: z.string(),
+  description: z.string(),
+  mediaBasePath: z.string().optional(),
+  url: z.string().optional(),
+  headerImage: z.string(),
+  headerImageBlurHash: z.string().optional(),
+  thumbnailSize: z.number().optional(),
+  metadata: GalleryMetadataSchema,
+  mediaBaseUrl: z.string().optional(),
+  analyticsScript: z.string().optional(),
+  sections: z.array(GallerySectionSchema),
+  subGalleries: z.object({ title: z.string(), galleries: z.array(SubGallerySchema) })
+});
+var GalleryDataDeprecatedSchema = z.object({
+  title: z.string(),
+  description: z.string(),
+  url: z.string().optional(),
+  headerImage: z.string(),
+  thumbnailSize: z.number().optional(),
+  metadata: GalleryMetadataSchema,
+  mediaBaseUrl: z.string().optional(),
+  analyticsScript: z.string().optional(),
+  sections: z.array(GallerySectionDeprecatedSchema),
+  subGalleries: z.object({ title: z.string(), galleries: z.array(SubGallerySchema) })
+});
+
+// src/utils/gallery.ts
+function parseGalleryJson(galleryJsonPath, ui) {
+  let galleryContent;
+  try {
+    galleryContent = fs8.readFileSync(galleryJsonPath, "utf8");
+  } catch (error) {
+    ui.error("Error parsing gallery.json: file not found");
+    throw error;
+  }
+  let galleryJSON;
+  try {
+    galleryJSON = JSON.parse(galleryContent);
+  } catch (error) {
+    ui.error("Error parsing gallery.json: invalid JSON");
+    throw error;
+  }
+  try {
+    return GalleryDataSchema.parse(galleryJSON);
+  } catch (error) {
+    try {
+      const deprecatedGalleryData = GalleryDataDeprecatedSchema.parse(galleryJSON);
+      return migrateGalleryJson(deprecatedGalleryData, galleryJsonPath, ui);
+    } catch {
+      ui.error("Error parsing gallery.json: invalid gallery data");
+      throw error;
+    }
+  }
+}
+function migrateGalleryJson(deprecatedGalleryData, galleryJsonPath, ui) {
+  ui.start("Old gallery.json format detected. Migrating gallery.json to the new data format.");
+  let mediaBasePath;
+  const imagePath = deprecatedGalleryData.sections[0].images[0].path;
+  if (imagePath && imagePath !== path7.join("..", path7.basename(imagePath))) {
+    mediaBasePath = path7.resolve(path7.join(path7.dirname(galleryJsonPath)), path7.dirname(imagePath));
+  }
+  const sections = deprecatedGalleryData.sections.map((section) => ({
+    ...section,
+    images: section.images.map((image) => ({
+      ...image,
+      path: void 0,
+      filename: path7.basename(image.path)
+    }))
+  }));
+  const galleryData = {
+    ...deprecatedGalleryData,
+    headerImage: path7.basename(deprecatedGalleryData.headerImage),
+    sections,
+    mediaBasePath
+  };
+  ui.debug("Backing up old gallery.json file");
+  fs8.copyFileSync(galleryJsonPath, `${galleryJsonPath}.old`);
+  ui.debug("Writing gallery data to gallery.json file");
+  fs8.writeFileSync(galleryJsonPath, JSON.stringify(galleryData, null, 2));
+  ui.success("Gallery data migrated to the new data format successfully.");
+  return galleryData;
+}
+function getMediaFileType(fileName) {
+  const ext = path7.extname(fileName).toLowerCase();
+  if (IMAGE_EXTENSIONS.has(ext)) return "image";
+  if (VIDEO_EXTENSIONS.has(ext)) return "video";
+  return null;
+}
+function capitalizeTitle(folderName) {
+  return folderName.replace("-", " ").replace("_", " ").split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+
+// src/modules/init/index.ts
+async function scanDirectory(dirPath, ui) {
+  const mediaFiles = [];
+  const subGalleryDirectories = [];
+  try {
+    const entries = await promises.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        const mediaType = getMediaFileType(entry.name);
+        if (mediaType) {
+          const mediaFile = {
+            type: mediaType,
+            filename: entry.name,
+            width: 0,
+            height: 0
+          };
+          mediaFiles.push(mediaFile);
+        }
+      } else if (entry.isDirectory() && entry.name !== "gallery") {
+        subGalleryDirectories.push(path7.join(dirPath, entry.name));
+      }
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("ENOENT")) {
+      ui.error(`Directory does not exist: ${dirPath}`);
+    } else if (error instanceof Error && error.message.includes("ENOTDIR")) {
+      ui.error(`Path is not a directory: ${dirPath}`);
+    } else {
+      ui.error(`Error scanning directory ${dirPath}:`, error);
+    }
+    throw error;
+  }
+  return { mediaFiles, subGalleryDirectories };
+}
+async function getGallerySettingsFromUser(galleryName, defaultImage, ui) {
+  ui.info(`Enter gallery settings for the gallery in folder "${galleryName}"`);
+  const title = await ui.prompt("Enter gallery title", { type: "text", default: "My Gallery", placeholder: "My Gallery" });
+  const description = await ui.prompt("Enter gallery description", {
+    type: "text",
+    default: "My gallery with fantastic photos.",
+    placeholder: "My gallery with fantastic photos."
+  });
+  const url = await ui.prompt("Enter the URL where the gallery will be hosted (important for social media image)", {
+    type: "text",
+    default: "",
+    placeholder: ""
+  });
+  const headerImage = await ui.prompt("Enter the name of the header image", {
+    type: "text",
+    default: defaultImage,
+    placeholder: defaultImage
+  });
+  return { title, description, url, headerImage };
+}
+async function createGalleryJson(mediaFiles, galleryJsonPath, scanPath, subGalleries = [], useDefaultSettings, ui) {
+  const galleryDir = path7.dirname(galleryJsonPath);
+  const isSameLocation = path7.relative(scanPath, path7.join(galleryDir, "..")) === "";
+  const mediaBasePath = isSameLocation ? void 0 : scanPath;
+  const relativeSubGalleries = subGalleries.map((subGallery) => ({
+    ...subGallery,
+    headerImage: subGallery.headerImage ? path7.relative(galleryDir, subGallery.headerImage) : ""
+  }));
+  let galleryData = {
+    title: "My Gallery",
+    description: "My gallery with fantastic photos.",
+    headerImage: mediaFiles[0]?.filename || "",
+    mediaBasePath,
+    metadata: {},
+    sections: [
+      {
+        images: mediaFiles
+      }
+    ],
+    subGalleries: {
+      title: "Sub Galleries",
+      galleries: relativeSubGalleries
+    }
+  };
+  if (!useDefaultSettings) {
+    galleryData = {
+      ...galleryData,
+      ...await getGallerySettingsFromUser(
+        path7.basename(path7.join(galleryDir, "..")),
+        path7.basename(mediaFiles[0]?.filename || ""),
+        ui
+      )
+    };
+  }
+  await promises.writeFile(galleryJsonPath, JSON.stringify(galleryData, null, 2));
+}
+async function galleryExists(outputPath) {
+  const galleryPath = path7.join(outputPath, "gallery");
+  const galleryJsonPath = path7.join(galleryPath, "gallery.json");
+  try {
+    await promises.access(galleryJsonPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function processDirectory(scanPath, outputPath, recursive, useDefaultSettings, force, ui) {
+  ui.start(`Scanning ${scanPath}`);
+  let totalFiles = 0;
+  let totalGalleries = 1;
+  const subGalleries = [];
+  const { mediaFiles, subGalleryDirectories } = await scanDirectory(scanPath, ui);
+  totalFiles += mediaFiles.length;
+  if (recursive) {
+    for (const subGalleryDir of subGalleryDirectories) {
+      const result2 = await processDirectory(
+        subGalleryDir,
+        path7.join(outputPath, path7.basename(subGalleryDir)),
+        recursive,
+        useDefaultSettings,
+        force,
+        ui
+      );
+      totalFiles += result2.totalFiles;
+      totalGalleries += result2.totalGalleries;
+      if (result2.subGallery) {
+        subGalleries.push(result2.subGallery);
+      }
+    }
+  }
+  if (mediaFiles.length > 0 || subGalleries.length > 0) {
+    const galleryPath = path7.join(outputPath, "gallery");
+    const galleryJsonPath = path7.join(galleryPath, "gallery.json");
+    const exists = await galleryExists(outputPath);
+    if (exists && !force) {
+      const shouldOverride = await ui.prompt(`Gallery already exists at ${galleryJsonPath}. Do you want to override it?`, {
+        type: "confirm",
+        default: false
+      });
+      if (!shouldOverride) {
+        ui.info("Skipping gallery creation");
+        return { totalFiles: 0, totalGalleries: 0 };
+      }
+    }
+    try {
+      await promises.mkdir(galleryPath, { recursive: true });
+      await createGalleryJson(mediaFiles, galleryJsonPath, scanPath, subGalleries, useDefaultSettings, ui);
+      ui.success(
+        `Create gallery with ${mediaFiles.length} files and ${subGalleries.length} subgalleries at: ${galleryJsonPath}`
+      );
+    } catch (error) {
+      ui.error(`Error creating gallery.json at ${galleryJsonPath}`);
+      throw error;
+    }
+  }
+  const result = { totalFiles, totalGalleries };
+  if (mediaFiles.length > 0 || subGalleries.length > 0) {
+    const dirName = path7.basename(scanPath);
+    result.subGallery = {
+      title: capitalizeTitle(dirName),
+      headerImage: mediaFiles[0]?.filename || "",
+      path: path7.join("..", dirName)
+    };
+  }
+  return result;
+}
+async function init(options, ui) {
+  try {
+    const scanPath = path7.resolve(options.photos);
+    const outputPath = options.gallery ? path7.resolve(options.gallery) : scanPath;
+    const result = await processDirectory(scanPath, outputPath, options.recursive, options.default, options.force, ui);
+    ui.box(
+      `Created ${result.totalGalleries} ${result.totalGalleries === 1 ? "gallery" : "galleries"} with ${result.totalFiles} media ${result.totalFiles === 1 ? "file" : "files"}`
+    );
+    return {
+      processedMediaCount: result.totalFiles,
+      processedGalleryCount: result.totalGalleries
+    };
+  } catch (error) {
+    ui.error("Error initializing gallery");
+    throw error;
+  }
+}
 async function getFileMtime(filePath) {
   const stats = await promises.stat(filePath);
   return stats.mtime;
 }
-async function generateBlurHash(imagePath, componentX = 4, componentY = 3) {
-  const image = await loadImage(imagePath);
-  const { data, info } = await image.resize(32, 32, { fit: "inside" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
-  const pixels = new Uint8ClampedArray(data.buffer);
-  return encode(pixels, info.width, info.height, componentX, componentY);
-}
 async function getVideoDimensions(filePath) {
   const data = await ffprobe(filePath);
   const videoStream = data.streams.find((stream) => stream.codec_type === "video");
@@ -331,7 +643,7 @@ async function createVideoThumbnails(inputPath, videoDimensions, outputPath, out
 // src/modules/thumbnails/index.ts
 async function processImage(imagePath, thumbnailPath, thumbnailPathRetina, thumbnailSize, lastMediaTimestamp) {
   const fileMtime = await getFileMtime(imagePath);
-  if (lastMediaTimestamp && fileMtime <= lastMediaTimestamp && fs6.existsSync(thumbnailPath)) {
+  if (lastMediaTimestamp && fileMtime <= lastMediaTimestamp && fs8.existsSync(thumbnailPath)) {
     return void 0;
   }
   const { image, metadata } = await loadImageWithMetadata(imagePath);
@@ -353,7 +665,7 @@ async function processImage(imagePath, thumbnailPath, thumbnailPathRetina, thumb
   const blurHash = await generateBlurHash(thumbnailPath);
   return {
     type: "image",
-    path: imagePath,
+    filename: path7.basename(imagePath),
     alt: description,
     width: imageDimensions.width,
     height: imageDimensions.height,
@@ -369,7 +681,7 @@ async function processImage(imagePath, thumbnailPath, thumbnailPathRetina, thumb
 }
 async function processVideo(videoPath, thumbnailPath, thumbnailPathRetina, thumbnailSize, verbose, lastMediaTimestamp) {
   const fileMtime = await getFileMtime(videoPath);
-  if (lastMediaTimestamp && fileMtime <= lastMediaTimestamp && fs6.existsSync(thumbnailPath)) {
+  if (lastMediaTimestamp && fileMtime <= lastMediaTimestamp && fs8.existsSync(thumbnailPath)) {
     return void 0;
   }
   const videoDimensions = await getVideoDimensions(videoPath);
@@ -384,7 +696,7 @@ async function processVideo(videoPath, thumbnailPath, thumbnailPathRetina, thumb
   const blurHash = await generateBlurHash(thumbnailPath);
   return {
     type: "video",
-    path: videoPath,
+    filename: path7.basename(videoPath),
     alt: void 0,
     width: videoDimensions.width,
     height: videoDimensions.height,
@@ -398,24 +710,24 @@ async function processVideo(videoPath, thumbnailPath, thumbnailPathRetina, thumb
     lastMediaTimestamp: fileMtime.toISOString()
   };
 }
-async function processMediaFile(mediaFile, galleryDir, thumbnailsPath, thumbnailSize, ui) {
+async function processMediaFile(mediaFile, mediaBasePath, galleryDir, thumbnailsPath, thumbnailSize, ui) {
   try {
-    const galleryJsonDir = path4.join(galleryDir, "gallery");
-    const filePath = path4.resolve(path4.join(galleryJsonDir, mediaFile.path));
-    const fileName = path4.basename(filePath);
-    const fileNameWithoutExt = path4.parse(fileName).name;
+    const filePath = path7.resolve(path7.join(mediaBasePath, mediaFile.filename));
+    const fileName = mediaFile.filename;
+    const fileNameWithoutExt = path7.parse(fileName).name;
+    const galleryJsonDir = path7.join(galleryDir, "gallery");
     const thumbnailFileName = `${fileNameWithoutExt}.avif`;
-    const thumbnailPath = path4.join(thumbnailsPath, thumbnailFileName);
+    const thumbnailPath = path7.join(thumbnailsPath, thumbnailFileName);
     const thumbnailPathRetina = thumbnailPath.replace(".avif", "@2x.avif");
-    const relativeThumbnailPath = path4.relative(galleryJsonDir, thumbnailPath);
-    const relativeThumbnailRetinaPath = path4.relative(galleryJsonDir, thumbnailPathRetina);
+    const relativeThumbnailPath = path7.relative(galleryJsonDir, thumbnailPath);
+    const relativeThumbnailRetinaPath = path7.relative(galleryJsonDir, thumbnailPathRetina);
     const lastMediaTimestamp = mediaFile.lastMediaTimestamp ? new Date(mediaFile.lastMediaTimestamp) : void 0;
     const verbose = ui.level === LogLevels.debug;
     ui.debug(`  Processing ${mediaFile.type}: ${fileName}`);
     const updatedMediaFile = await (mediaFile.type === "image" ? processImage(filePath, thumbnailPath, thumbnailPathRetina, thumbnailSize, lastMediaTimestamp) : processVideo(filePath, thumbnailPath, thumbnailPathRetina, thumbnailSize, verbose, lastMediaTimestamp));
     if (!updatedMediaFile) {
       ui.debug(`  Skipping ${fileName} because it has already been processed`);
-      if (mediaFile.thumbnail && !mediaFile.thumbnail.blurHash && fs6.existsSync(thumbnailPath)) {
+      if (mediaFile.thumbnail && !mediaFile.thumbnail.blurHash && fs8.existsSync(thumbnailPath)) {
         try {
           const blurHash = await generateBlurHash(thumbnailPath);
           return {
@@ -431,34 +743,41 @@ async function processMediaFile(mediaFile, galleryDir, thumbnailsPath, thumbnail
       }
       return mediaFile;
     }
-    updatedMediaFile.path = mediaFile.path;
+    updatedMediaFile.filename = mediaFile.filename;
     if (updatedMediaFile.thumbnail) {
       updatedMediaFile.thumbnail.path = relativeThumbnailPath;
       updatedMediaFile.thumbnail.pathRetina = relativeThumbnailRetinaPath;
     }
     return updatedMediaFile;
   } catch (error) {
-    handleFileProcessingError(error, path4.basename(mediaFile.path), ui);
-    return mediaFile;
+    handleFileProcessingError(error, mediaFile.filename, ui);
+    return { ...mediaFile, thumbnail: void 0 };
   }
 }
 async function processGalleryThumbnails(galleryDir, ui) {
-  const galleryJsonPath = path4.join(galleryDir, "gallery", "gallery.json");
-  const thumbnailsPath = path4.join(galleryDir, "gallery", "images");
+  const galleryJsonPath = path7.join(galleryDir, "gallery", "gallery.json");
+  const thumbnailsPath = path7.join(galleryDir, "gallery", "images");
   ui.start(`Creating thumbnails: ${galleryDir}`);
   try {
-    fs6.mkdirSync(thumbnailsPath, { recursive: true });
-    const galleryContent = fs6.readFileSync(galleryJsonPath, "utf8");
-    const galleryData = GalleryDataSchema.parse(JSON.parse(galleryContent));
+    fs8.mkdirSync(thumbnailsPath, { recursive: true });
+    const galleryData = parseGalleryJson(galleryJsonPath, ui);
     const thumbnailSize = galleryData.thumbnailSize || DEFAULT_THUMBNAIL_SIZE;
+    const mediaBasePath = galleryData.mediaBasePath ?? path7.join(galleryDir);
     let processedCount = 0;
     for (const section of galleryData.sections) {
       for (const [index, mediaFile] of section.images.entries()) {
-        section.images[index] = await processMediaFile(mediaFile, galleryDir, thumbnailsPath, thumbnailSize, ui);
+        section.images[index] = await processMediaFile(
+          mediaFile,
+          mediaBasePath,
+          galleryDir,
+          thumbnailsPath,
+          thumbnailSize,
+          ui
+        );
       }
       processedCount += section.images.length;
     }
-    fs6.writeFileSync(galleryJsonPath, JSON.stringify(galleryData, null, 2));
+    fs8.writeFileSync(galleryJsonPath, JSON.stringify(galleryData, null, 2));
     ui.success(`Created thumbnails for ${processedCount} media files`);
     return processedCount;
   } catch (error) {
@@ -493,68 +812,113 @@ async function thumbnails(options, ui) {
 }
 
 // src/modules/build/index.ts
-function checkFileIsOneFolderUp(filePath) {
-  const normalizedPath = path4.normalize(filePath);
-  const pathParts = normalizedPath.split(path4.sep);
-  return pathParts.length === 2 && pathParts[0] === "..";
-}
 function copyPhotos(galleryData, galleryDir, ui) {
   for (const section of galleryData.sections) {
     for (const image of section.images) {
-      if (!checkFileIsOneFolderUp(image.path)) {
-        const sourcePath = path4.join(galleryDir, "gallery", image.path);
-        const fileName = path4.basename(image.path);
-        const destPath = path4.join(galleryDir, fileName);
+      if (galleryData.mediaBasePath) {
+        const sourcePath = path7.join(galleryData.mediaBasePath, image.filename);
+        const destPath = path7.join(galleryDir, image.filename);
         ui.debug(`Copying photo to ${destPath}`);
-        fs6.copyFileSync(sourcePath, destPath);
+        fs8.copyFileSync(sourcePath, destPath);
       }
     }
   }
 }
+async function scanAndAppendNewFiles(galleryDir, galleryJsonPath, galleryData, ui) {
+  const scanPath = galleryData.mediaBasePath || galleryDir;
+  ui.debug(`Scanning ${scanPath} for new media files`);
+  let scanResult;
+  try {
+    scanResult = await scanDirectory(scanPath, ui);
+  } catch {
+    ui.debug(`Could not scan directory ${scanPath}`);
+    return galleryData;
+  }
+  const existingFilenames = new Set(
+    galleryData.sections.flatMap((section) => section.images.map((image) => image.filename))
+  );
+  const newMediaFiles = scanResult.mediaFiles.filter((file) => !existingFilenames.has(file.filename));
+  if (newMediaFiles.length > 0) {
+    ui.info(`Found ${newMediaFiles.length} new media ${newMediaFiles.length === 1 ? "file" : "files"}`);
+    if (galleryData.sections.length === 0) {
+      galleryData.sections.push({ images: [] });
+    }
+    const lastSectionIndex = galleryData.sections.length - 1;
+    const lastSection = galleryData.sections[lastSectionIndex];
+    lastSection.images.push(...newMediaFiles);
+    ui.debug("Updating gallery.json with new files");
+    fs8.writeFileSync(galleryJsonPath, JSON.stringify(galleryData, null, 2));
+    ui.success(`Added ${newMediaFiles.length} new ${newMediaFiles.length === 1 ? "file" : "files"} to gallery.json`);
+  } else {
+    ui.debug("No new media files found");
+  }
+  return galleryData;
+}
 async function buildGallery(galleryDir, templateDir, ui, baseUrl) {
   ui.start(`Building gallery ${galleryDir}`);
-  await processGalleryThumbnails(galleryDir, ui);
-  const galleryJsonPath = path4.join(galleryDir, "gallery", "gallery.json");
-  const galleryContent = fs6.readFileSync(galleryJsonPath, "utf8");
-  const galleryData = GalleryDataSchema.parse(JSON.parse(galleryContent));
-  const socialMediaCardImagePath = path4.join(galleryDir, "gallery", "images", "social-media-card.jpg");
-  const headerImagePath = path4.resolve(path4.join(galleryDir, "gallery"), galleryData.headerImage);
+  const galleryJsonPath = path7.join(galleryDir, "gallery", "gallery.json");
+  let galleryData = parseGalleryJson(galleryJsonPath, ui);
+  galleryData = await scanAndAppendNewFiles(galleryDir, galleryJsonPath, galleryData, ui);
+  const socialMediaCardImagePath = path7.join(galleryDir, "gallery", "images", "social-media-card.jpg");
+  const mediaBasePath = galleryData.mediaBasePath;
+  const mediaBaseUrl = baseUrl || galleryData.mediaBaseUrl;
+  const headerImagePath = mediaBasePath ? path7.join(mediaBasePath, galleryData.headerImage) : path7.resolve(galleryDir, galleryData.headerImage);
+  const imagesFolder = path7.join(galleryDir, "gallery", "images");
+  const currentHeaderBasename = path7.basename(headerImagePath, path7.extname(headerImagePath));
+  if (!fs8.existsSync(imagesFolder)) {
+    fs8.mkdirSync(imagesFolder, { recursive: true });
+  }
+  const headerImageChanged = hasOldHeaderImages(imagesFolder, currentHeaderBasename);
+  if (headerImageChanged) {
+    ui.info("Header image changed, cleaning up old assets");
+    cleanupOldHeaderImages(imagesFolder, currentHeaderBasename, ui);
+    if (fs8.existsSync(socialMediaCardImagePath)) {
+      fs8.unlinkSync(socialMediaCardImagePath);
+      ui.debug("Deleted old social media card");
+    }
+  }
   await createGallerySocialMediaCardImage(headerImagePath, galleryData.title, socialMediaCardImagePath, ui);
-  galleryData.metadata.image = galleryData.metadata.image || `${galleryData.url || ""}/${path4.relative(galleryDir, socialMediaCardImagePath)}`;
-  fs6.writeFileSync(galleryJsonPath, JSON.stringify(galleryData, null, 2));
-  await createOptimizedHeaderImage(headerImagePath, path4.join(galleryDir, "gallery", "images"), ui);
-  if (!baseUrl) {
-    const shouldCopyPhotos = galleryData.sections.some(
-      (section) => section.images.some((image) => !checkFileIsOneFolderUp(image.path))
-    );
-    if (shouldCopyPhotos && await ui.prompt("All photos need to be copied. Are you sure you want to continue?", { type: "confirm" })) {
+  galleryData.metadata.image = galleryData.metadata.image || `${galleryData.url || ""}/${path7.relative(galleryDir, socialMediaCardImagePath)}`;
+  fs8.writeFileSync(galleryJsonPath, JSON.stringify(galleryData, null, 2));
+  const { blurHash } = await createOptimizedHeaderImage(headerImagePath, imagesFolder, ui);
+  if (galleryData.headerImageBlurHash !== blurHash) {
+    ui.debug("Updating gallery.json with header image blurhash");
+    galleryData.headerImageBlurHash = blurHash;
+    fs8.writeFileSync(galleryJsonPath, JSON.stringify(galleryData, null, 2));
+  }
+  if (!mediaBaseUrl && mediaBasePath) {
+    const shouldCopyPhotos = await ui.prompt("All photos need to be copied. Are you sure you want to continue?", {
+      type: "confirm"
+    });
+    if (shouldCopyPhotos) {
       ui.debug("Copying photos");
       copyPhotos(galleryData, galleryDir, ui);
     }
   }
-  if (baseUrl) {
+  if (mediaBaseUrl && galleryData.mediaBaseUrl !== mediaBaseUrl) {
     ui.debug("Updating gallery.json with baseUrl");
-    galleryData.mediaBaseUrl = baseUrl;
-    fs6.writeFileSync(galleryJsonPath, JSON.stringify(galleryData, null, 2));
+    galleryData.mediaBaseUrl = mediaBaseUrl;
+    fs8.writeFileSync(galleryJsonPath, JSON.stringify(galleryData, null, 2));
   }
+  await processGalleryThumbnails(galleryDir, ui);
   ui.debug("Building gallery from template");
   try {
     process3.env.GALLERY_JSON_PATH = galleryJsonPath;
-    process3.env.GALLERY_OUTPUT_DIR = path4.join(galleryDir, "gallery");
+    process3.env.GALLERY_OUTPUT_DIR = path7.join(galleryDir, "gallery");
     execSync("npx astro build", { cwd: templateDir, stdio: ui.level === LogLevels.debug ? "inherit" : "ignore" });
   } catch (error) {
     ui.error(`Build failed for ${galleryDir}`);
     throw error;
   }
-  const outputDir = path4.join(galleryDir, "gallery");
-  const buildDir = path4.join(outputDir, "_build");
+  const outputDir = path7.join(galleryDir, "gallery");
+  const buildDir = path7.join(outputDir, "_build");
   ui.debug(`Copying build output to ${outputDir}`);
-  fs6.cpSync(buildDir, outputDir, { recursive: true });
+  fs8.cpSync(buildDir, outputDir, { recursive: true });
   ui.debug("Moving index.html to gallery directory");
-  fs6.copyFileSync(path4.join(outputDir, "index.html"), path4.join(galleryDir, "index.html"));
-  fs6.rmSync(path4.join(outputDir, "index.html"));
+  fs8.copyFileSync(path7.join(outputDir, "index.html"), path7.join(galleryDir, "index.html"));
+  fs8.rmSync(path7.join(outputDir, "index.html"));
   ui.debug("Cleaning up build directory");
-  fs6.rmSync(buildDir, { recursive: true, force: true });
+  fs8.rmSync(buildDir, { recursive: true, force: true });
   ui.success(`Gallery built successfully`);
 }
 async function build(options, ui) {
@@ -565,11 +929,11 @@ async function build(options, ui) {
       return { processedGalleryCount: 0 };
     }
     const themePath = await import.meta.resolve("@simple-photo-gallery/theme-modern/package.json");
-    const themeDir = path4.dirname(new URL(themePath).pathname);
+    const themeDir = path7.dirname(new URL(themePath).pathname);
     let totalGalleries = 0;
     for (const dir of galleryDirs) {
-      const baseUrl = options.baseUrl ? `${options.baseUrl}${path4.relative(options.gallery, dir)}` : void 0;
-      await buildGallery(path4.resolve(dir), themeDir, ui, baseUrl);
+      const baseUrl = options.baseUrl ? `${options.baseUrl}${path7.relative(options.gallery, dir)}` : void 0;
+      await buildGallery(path7.resolve(dir), themeDir, ui, baseUrl);
       ++totalGalleries;
     }
     ui.box(`Built ${totalGalleries} ${totalGalleries === 1 ? "gallery" : "galleries"} successfully`);
@@ -585,20 +949,20 @@ async function build(options, ui) {
 }
 async function cleanGallery(galleryDir, ui) {
   let filesRemoved = 0;
-  const indexHtmlPath = path4.join(galleryDir, "index.html");
-  if (fs6.existsSync(indexHtmlPath)) {
+  const indexHtmlPath = path7.join(galleryDir, "index.html");
+  if (fs8.existsSync(indexHtmlPath)) {
     try {
-      fs6.rmSync(indexHtmlPath);
+      fs8.rmSync(indexHtmlPath);
       ui.debug(`Removed: ${indexHtmlPath}`);
       filesRemoved++;
     } catch (error) {
       ui.warn(`Failed to remove index.html: ${error}`);
     }
   }
-  const galleryPath = path4.join(galleryDir, "gallery");
-  if (fs6.existsSync(galleryPath)) {
+  const galleryPath = path7.join(galleryDir, "gallery");
+  if (fs8.existsSync(galleryPath)) {
     try {
-      fs6.rmSync(galleryPath, { recursive: true, force: true });
+      fs8.rmSync(galleryPath, { recursive: true, force: true });
       ui.debug(`Removed directory: ${galleryPath}`);
       filesRemoved++;
     } catch (error) {
@@ -614,8 +978,8 @@ async function cleanGallery(galleryDir, ui) {
 }
 async function clean(options, ui) {
   try {
-    const basePath = path4.resolve(options.gallery);
-    if (!fs6.existsSync(basePath)) {
+    const basePath = path7.resolve(options.gallery);
+    if (!fs8.existsSync(basePath)) {
       ui.error(`Directory does not exist: ${basePath}`);
       return { processedGalleryCount: 0 };
     }
@@ -634,174 +998,6 @@ async function clean(options, ui) {
     throw error;
   }
 }
-function getMediaFileType(fileName) {
-  const ext = path4.extname(fileName).toLowerCase();
-  if (IMAGE_EXTENSIONS.has(ext)) return "image";
-  if (VIDEO_EXTENSIONS.has(ext)) return "video";
-  return null;
-}
-function capitalizeTitle(folderName) {
-  return folderName.replace("-", " ").replace("_", " ").split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-}
-
-// src/modules/init/index.ts
-async function scanDirectory(dirPath, ui) {
-  const mediaFiles = [];
-  const subGalleryDirectories = [];
-  try {
-    const entries = await promises.readdir(dirPath, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isFile()) {
-        const fullPath = path4.join(dirPath, entry.name);
-        const mediaType = getMediaFileType(entry.name);
-        if (mediaType) {
-          const mediaFile = {
-            type: mediaType,
-            path: fullPath,
-            width: 0,
-            height: 0
-          };
-          mediaFiles.push(mediaFile);
-        }
-      } else if (entry.isDirectory() && entry.name !== "gallery") {
-        subGalleryDirectories.push(path4.join(dirPath, entry.name));
-      }
-    }
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("ENOENT")) {
-      ui.error(`Directory does not exist: ${dirPath}`);
-    } else if (error instanceof Error && error.message.includes("ENOTDIR")) {
-      ui.error(`Path is not a directory: ${dirPath}`);
-    } else {
-      ui.error(`Error scanning directory ${dirPath}:`, error);
-    }
-    throw error;
-  }
-  return { mediaFiles, subGalleryDirectories };
-}
-async function getGallerySettingsFromUser(galleryName, defaultImage, ui) {
-  ui.info(`Enter gallery settings for the gallery in folder "${galleryName}"`);
-  const title = await ui.prompt("Enter gallery title", { type: "text", default: "My Gallery", placeholder: "My Gallery" });
-  const description = await ui.prompt("Enter gallery description", {
-    type: "text",
-    default: "My gallery with fantastic photos.",
-    placeholder: "My gallery with fantastic photos."
-  });
-  const url = await ui.prompt("Enter the URL where the gallery will be hosted (important for social media image)", {
-    type: "text",
-    default: "",
-    placeholder: ""
-  });
-  const headerImageName = await ui.prompt("Enter the name of the header image", {
-    type: "text",
-    default: defaultImage,
-    placeholder: defaultImage
-  });
-  const headerImage = path4.join("..", headerImageName);
-  return { title, description, url, headerImage };
-}
-async function createGalleryJson(mediaFiles, galleryJsonPath, subGalleries = [], useDefaultSettings, ui) {
-  const galleryDir = path4.dirname(galleryJsonPath);
-  const relativeMediaFiles = mediaFiles.map((file) => ({
-    ...file,
-    path: path4.relative(galleryDir, file.path)
-  }));
-  const relativeSubGalleries = subGalleries.map((subGallery) => ({
-    ...subGallery,
-    headerImage: subGallery.headerImage ? path4.relative(galleryDir, subGallery.headerImage) : ""
-  }));
-  let galleryData = {
-    title: "My Gallery",
-    description: "My gallery with fantastic photos.",
-    headerImage: relativeMediaFiles[0]?.path || "",
-    metadata: {},
-    sections: [
-      {
-        images: relativeMediaFiles
-      }
-    ],
-    subGalleries: {
-      title: "Sub Galleries",
-      galleries: relativeSubGalleries
-    }
-  };
-  if (!useDefaultSettings) {
-    galleryData = {
-      ...galleryData,
-      ...await getGallerySettingsFromUser(
-        path4.basename(path4.join(galleryDir, "..")),
-        path4.basename(mediaFiles[0]?.path || ""),
-        ui
-      )
-    };
-  }
-  await promises.writeFile(galleryJsonPath, JSON.stringify(galleryData, null, 2));
-}
-async function processDirectory(scanPath, outputPath, recursive, useDefaultSettings, ui) {
-  ui.start(`Scanning ${scanPath}`);
-  let totalFiles = 0;
-  let totalGalleries = 1;
-  const subGalleries = [];
-  const { mediaFiles, subGalleryDirectories } = await scanDirectory(scanPath, ui);
-  totalFiles += mediaFiles.length;
-  if (recursive) {
-    for (const subGalleryDir of subGalleryDirectories) {
-      const result2 = await processDirectory(
-        subGalleryDir,
-        path4.join(outputPath, path4.basename(subGalleryDir)),
-        recursive,
-        useDefaultSettings,
-        ui
-      );
-      totalFiles += result2.totalFiles;
-      totalGalleries += result2.totalGalleries;
-      if (result2.subGallery) {
-        subGalleries.push(result2.subGallery);
-      }
-    }
-  }
-  if (mediaFiles.length > 0 || subGalleries.length > 0) {
-    const galleryPath = path4.join(outputPath, "gallery");
-    const galleryJsonPath = path4.join(galleryPath, "gallery.json");
-    try {
-      await promises.mkdir(galleryPath, { recursive: true });
-      await createGalleryJson(mediaFiles, galleryJsonPath, subGalleries, useDefaultSettings, ui);
-      ui.success(
-        `Create gallery with ${mediaFiles.length} files and ${subGalleries.length} subgalleries at: ${galleryJsonPath}`
-      );
-    } catch (error) {
-      ui.error(`Error creating gallery.json at ${galleryJsonPath}`);
-      throw error;
-    }
-  }
-  const result = { totalFiles, totalGalleries };
-  if (mediaFiles.length > 0 || subGalleries.length > 0) {
-    const dirName = path4.basename(scanPath);
-    result.subGallery = {
-      title: capitalizeTitle(dirName),
-      headerImage: mediaFiles[0]?.path || "",
-      path: path4.join("..", dirName)
-    };
-  }
-  return result;
-}
-async function init(options, ui) {
-  try {
-    const scanPath = path4.resolve(options.photos);
-    const outputPath = options.gallery ? path4.resolve(options.gallery) : scanPath;
-    const result = await processDirectory(scanPath, outputPath, options.recursive, options.default, ui);
-    ui.box(
-      `Created ${result.totalGalleries} ${result.totalGalleries === 1 ? "gallery" : "galleries"} with ${result.totalFiles} media ${result.totalFiles === 1 ? "file" : "files"}`
-    );
-    return {
-      processedMediaCount: result.totalFiles,
-      processedGalleryCount: result.totalGalleries
-    };
-  } catch (error) {
-    ui.error("Error initializing gallery");
-    throw error;
-  }
-}
 
 // src/modules/telemetry/index.ts
 async function telemetry(options, ui, telemetryService2) {
@@ -1040,7 +1236,7 @@ async function waitForUpdateCheck(checkPromise) {
 // package.json
 var package_default = {
   name: "simple-photo-gallery",
-  version: "2.0.9"};
+  version: "2.0.10-rc.1"};
 
 // src/index.ts
 var program = new Command();
@@ -1108,7 +1304,7 @@ program.command("init").description("Initialize a gallery by scaning a folder fo
 ).option(
   "-g, --gallery <path>",
   "Path to the directory where the gallery will be initialized. Default: same directory as the photos folder"
-).option("-r, --recursive", "Recursively create galleries from all photos subdirectories", false).option("-d, --default", "Use default gallery settings instead of asking the user", false).action(withCommandContext((options, ui) => init(options, ui)));
+).option("-r, --recursive", "Recursively create galleries from all photos subdirectories", false).option("-d, --default", "Use default gallery settings instead of asking the user", false).option("-f, --force", "Force override existing galleries without asking", false).action(withCommandContext((options, ui) => init(options, ui)));
 program.command("thumbnails").description("Create thumbnails for all media files in the gallery").option("-g, --gallery <path>", "Path to the directory of the gallery. Default: current working directory", process3.cwd()).option("-r, --recursive", "Scan subdirectories recursively", false).action(withCommandContext((options, ui) => thumbnails(options, ui)));
 program.command("build").description("Build the HTML gallery in the specified directory").option("-g, --gallery <path>", "Path to the directory of the gallery. Default: current working directory", process3.cwd()).option("-r, --recursive", "Scan subdirectories recursively", false).option("-b, --base-url <url>", "Base URL where the photos are hosted").action(withCommandContext((options, ui) => build(options, ui)));
 program.command("clean").description("Remove all gallery files and folders (index.html, gallery/)").option("-g, --gallery <path>", "Path to the directory of the gallery. Default: current working directory", process3.cwd()).option("-r, --recursive", "Clean subdirectories recursively", false).action(withCommandContext((options, ui) => clean(options, ui)));