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

package/dist/index.js

@@ -1,73 +1,21 @@
 #!/usr/bin/env node
-import process2 from 'process';
+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(),
-  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"]);
@@ -135,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();
@@ -161,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);
         }
@@ -252,16 +248,341 @@ function handleFileProcessingError(error, filename, ui) {
   }
   ui.debug(error);
 }
+function parseTelemetryOption(value) {
+  if (value !== "0" && value !== "1") {
+    throw new Error("Telemetry option must be either 0 or 1.");
+  }
+  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");
@@ -322,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);
@@ -344,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,
@@ -360,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);
@@ -375,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,
@@ -389,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 {
@@ -422,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) {
@@ -462,7 +790,7 @@ async function thumbnails(options, ui) {
     const galleryDirs = findGalleries(options.gallery, options.recursive);
     if (galleryDirs.length === 0) {
       ui.error("No galleries found.");
-      return;
+      return { processedGalleryCount: 0, processedMediaCount: 0 };
     }
     let totalGalleries = 0;
     let totalProcessed = 0;
@@ -476,6 +804,7 @@ async function thumbnails(options, ui) {
     ui.box(
       `Created thumbnails for ${totalGalleries} ${totalGalleries === 1 ? "gallery" : "galleries"} with ${totalProcessed} media ${totalProcessed === 1 ? "file" : "files"}`
     );
+    return { processedGalleryCount: totalGalleries, processedMediaCount: totalProcessed };
   } catch (error) {
     ui.error("Error creating thumbnails");
     throw error;
@@ -483,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));
   }
-  ui.debug("Building gallery form template");
+  await processGalleryThumbnails(galleryDir, ui);
+  ui.debug("Building gallery from template");
   try {
-    process2.env.GALLERY_JSON_PATH = galleryJsonPath;
-    process2.env.GALLERY_OUTPUT_DIR = path4.join(galleryDir, "gallery");
+    process3.env.GALLERY_JSON_PATH = galleryJsonPath;
+    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) {
@@ -552,17 +926,18 @@ async function build(options, ui) {
     const galleryDirs = findGalleries(options.gallery, options.recursive);
     if (galleryDirs.length === 0) {
       ui.error("No galleries found.");
-      return;
+      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`);
+    return { processedGalleryCount: totalGalleries };
   } catch (error) {
     if (error instanceof Error && error.message.includes("Cannot find package")) {
       ui.error("Theme package not found: @simple-photo-gallery/theme-modern/package.json");
@@ -574,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) {
@@ -599,192 +974,198 @@ async function cleanGallery(galleryDir, ui) {
   } else {
     ui.info(`No gallery files found at: ${galleryDir}`);
   }
+  return { processedGalleryCount: filesRemoved };
 }
 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;
+      return { processedGalleryCount: 0 };
     }
     const galleryDirs = findGalleries(basePath, options.recursive);
     if (galleryDirs.length === 0) {
       ui.info("No galleries found to clean.");
-      return;
+      return { processedGalleryCount: 0 };
     }
     for (const dir of galleryDirs) {
       await cleanGallery(dir, ui);
     }
     ui.box(`Successfully cleaned ${galleryDirs.length} ${galleryDirs.length === 1 ? "gallery" : "galleries"}`);
+    return { processedGalleryCount: galleryDirs.length };
   } catch (error) {
     ui.error("Error cleaning galleries");
     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}`);
+// src/modules/telemetry/index.ts
+async function telemetry(options, ui, telemetryService2) {
+  const updates = {};
+  if (options.state === void 0) {
+    const current = telemetryService2.getStoredPreference();
+    if (current === void 0) {
+      ui.info("Telemetry preference not set yet. It will be requested on next command run.");
+      updates.telemetryStatus = "unset";
     } else {
-      ui.error(`Error scanning directory ${dirPath}:`, error);
+      ui.info(`Telemetry is currently ${current ? "enabled" : "disabled"}.`);
+      updates.telemetryEnabled = current;
     }
-    throw error;
+  } else {
+    telemetryService2.setStoredPreference(options.state === "1");
+    ui.success(`Anonymous telemetry ${options.state === "1" ? "enabled" : "disabled"}.`);
+    updates.telemetryEnabled = options.state === "1";
   }
-  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 };
+  return updates;
 }
-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
+var ApiTelemetryClient = class {
+  constructor() {
+    this.endpoint = "https://tools.simple.photo/api/telemetry";
+  }
+  async record(event) {
+    try {
+      axios.post(this.endpoint, event, {
+        headers: {
+          "content-type": "application/json",
+          "user-agent": `simple-photo-gallery/${event.packageVersion} (${process3.platform}; ${process3.arch})`
+        }
+      });
+    } catch {
     }
-  };
-  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);
-      }
+};
+var ConsoleTelemetryClient = class {
+  async record(event) {
+    const serialized = JSON.stringify(event, null, 2);
+    stdout.write(`TELEMETRY EVENT: ${serialized}
+`);
+  }
+};
+
+// src/modules/telemetry/service/index.ts
+var CONFIG_KEY = "telemetryEnabled";
+var TelemetryService = class {
+  constructor(packageName, packageVersion, ui) {
+    this.packageName = packageName;
+    this.packageVersion = packageVersion;
+    this.ui = ui;
+    this.config = new Conf({ projectName: packageName });
+  }
+  /** Returns the stored telemetry preference, if any. */
+  getStoredPreference() {
+    return this.config.get(CONFIG_KEY);
+  }
+  /** Updates the persisted telemetry preference. */
+  setStoredPreference(enabled) {
+    this.config.set(CONFIG_KEY, enabled);
+  }
+  /** Determines whether telemetry should be collected for this run. */
+  async shouldCollectTelemetry(override) {
+    if (override) {
+      return override === "1";
+    }
+    if (process3.env.CI || process3.env.DO_NOT_TRACK) {
+      return false;
+    }
+    if (process3.env.SPG_TELEMETRY) {
+      return process3.env.SPG_TELEMETRY === "1";
+    }
+    const stored = this.getStoredPreference();
+    if (stored === void 0) {
+      const consent = await this.promptForConsent();
+      this.setStoredPreference(consent);
+      return consent;
+    } else {
+      return stored;
     }
   }
-  if (mediaFiles.length > 0 || subGalleries.length > 0) {
-    const galleryPath = path4.join(outputPath, "gallery");
-    const galleryJsonPath = path4.join(galleryPath, "gallery.json");
+  /** Builds and dispatches a telemetry event when telemetry is enabled. */
+  async emit(params) {
+    const event = this.buildEvent(params);
     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}`
-      );
+      const client = await this.getClient();
+      if (client) {
+        await client.record(event);
+      }
     } catch (error) {
-      ui.error(`Error creating gallery.json at ${galleryJsonPath}`);
-      throw error;
+      this.ui.debug("Error recording telemetry event", 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)
+  /** Builds a telemetry event. */
+  buildEvent({
+    command,
+    argumentsProvided,
+    globalOptionsProvided,
+    metrics,
+    success,
+    error,
+    startedAt
+  }) {
+    const now = Date.now();
+    const event = {
+      command,
+      argumentsProvided,
+      globalOptionsProvided,
+      timestamp: new Date(now).toISOString(),
+      durationMs: now - startedAt,
+      packageName: this.packageName,
+      packageVersion: this.packageVersion,
+      nodeVersion: process3.version,
+      osPlatform: os.platform(),
+      osRelease: os.release(),
+      osArch: os.arch(),
+      result: success ? "success" : "error"
     };
+    if (metrics && Object.keys(metrics).length > 0) {
+      event.metrics = metrics;
+    }
+    if (!success && error) {
+      event.errorName = error.name;
+      event.errorMessage = error.message;
+    }
+    return event;
   }
-  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"}`
+  /** Prompts the user for consent to collect telemetry. */
+  async promptForConsent() {
+    this.ui.info(
+      "Simple Photo Gallery collects anonymous usage telemetry to improve the CLI. No personal data or information about your photos is collected. For more information, see https://simple.photo/telemetry."
     );
-  } catch (error) {
-    ui.error("Error initializing gallery");
-    throw error;
+    const answer = await this.ui.prompt("Would you like to enable telemetry?", {
+      type: "confirm",
+      initial: true
+    });
+    if (!answer) {
+      this.ui.info('Anonymous telemetry disabled. You can re-enable it with "spg telemetry 1".');
+      return false;
+    }
+    this.ui.success("Thank you! Telemetry will help us improve Simple Photo Gallery.");
+    return true;
   }
-}
+  /** Returns the telemetry client. */
+  getClient() {
+    if (!this.client) {
+      switch (process3.env.SPG_TELEMETRY_PROVIDER) {
+        case "none": {
+          this.client = void 0;
+          break;
+        }
+        case "console": {
+          this.client = new ConsoleTelemetryClient();
+          break;
+        }
+        case "api": {
+          this.client = new ApiTelemetryClient();
+          break;
+        }
+        default: {
+          this.client = new ApiTelemetryClient();
+          break;
+        }
+      }
+    }
+    return this.client;
+  }
+};
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var CHECK_TIMEOUT_MS = 3e3;
 async function fetchLatestStableVersion(packageName) {
@@ -855,11 +1236,12 @@ async function waitForUpdateCheck(checkPromise) {
 // package.json
 var package_default = {
   name: "simple-photo-gallery",
-  version: "2.0.8"};
+  version: "2.0.10-rc.1"};
 
 // src/index.ts
 var program = new Command();
-program.name("gallery").description("Simple Photo Gallery CLI").version(package_default.version).option("-v, --verbose", "Verbose output (debug level)", false).option("-q, --quiet", "Minimal output (only warnings/errors)", false).showHelpAfterError(true);
+var telemetryService = new TelemetryService(package_default.name, package_default.version, createConsolaUI(program.opts()));
+program.name("gallery").description("Simple Photo Gallery CLI").version(package_default.version).option("-v, --verbose", "Verbose output (debug level)", false).option("-q, --quiet", "Minimal output (only warnings/errors)", false).option("--telemetry <state>", "Enable (1) or disable (0) telemetry for this command", parseTelemetryOption).showHelpAfterError(true);
 function createConsolaUI(globalOpts) {
   let level = LogLevels.info;
   if (globalOpts.quiet) {
@@ -871,33 +1253,62 @@ function createConsolaUI(globalOpts) {
     level
   }).withTag("simple-photo-gallery");
 }
-function withConsolaUI(handler) {
-  return async (opts) => {
+function collectCommandArguments(command) {
+  return command.options.map((option) => ({ name: option.attributeName(), source: command.getOptionValueSource(option.attributeName()) })).filter((option) => option.source && option.source !== "default").map((option) => option.name);
+}
+function collectGlobalArguments() {
+  return program.options.map((option) => ({ name: option.attributeName(), source: program.getOptionValueSource(option.attributeName()) })).filter((option) => option.source && option.source !== "default").map((option) => option.name);
+}
+function withCommandContext(handler) {
+  return async (rawOpts, command) => {
+    const { telemetry: telemetryOverride, ...commandOptions } = rawOpts;
     const ui = createConsolaUI(program.opts());
+    const shouldCollectTelemetry = await telemetryService.shouldCollectTelemetry(telemetryOverride);
+    const startedAt = Date.now();
     const updateCheckPromise = checkForUpdates(package_default.name, package_default.version);
+    let success = false;
+    let metrics;
+    let errorInfo;
     try {
-      await handler(opts, ui);
+      const result = await handler(commandOptions, ui, command);
+      if (result && Object.keys(result).length > 0) {
+        metrics = result;
+      }
+      success = true;
     } catch (error) {
       ui.debug(error);
-      process2.exitCode = 1;
+      errorInfo = error instanceof Error ? { name: error.name, message: error.message } : { name: "UnknownError", message: String(error) };
+      process3.exitCode = 1;
     }
     const updateInfo = await waitForUpdateCheck(updateCheckPromise);
     if (updateInfo) {
       displayUpdateNotification(updateInfo, ui);
     }
+    if (shouldCollectTelemetry) {
+      await telemetryService.emit({
+        command: command.name(),
+        argumentsProvided: collectCommandArguments(command),
+        globalOptionsProvided: collectGlobalArguments(),
+        metrics,
+        success,
+        error: errorInfo,
+        startedAt
+      });
+    }
   };
 }
 program.command("init").description("Initialize a gallery by scaning a folder for images and videos").option(
   "-p, --photos <path>",
   "Path to the folder where the photos are stored. Default: current working directory",
-  process2.cwd()
+  process3.cwd()
 ).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(withConsolaUI(init));
-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", process2.cwd()).option("-r, --recursive", "Scan subdirectories recursively", false).action(withConsolaUI(thumbnails));
-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", process2.cwd()).option("-r, --recursive", "Scan subdirectories recursively", false).option("-b, --base-url <url>", "Base URL where the photos are hosted").action(withConsolaUI(build));
-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", process2.cwd()).option("-r, --recursive", "Clean subdirectories recursively", false).action(withConsolaUI(clean));
+).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)));
+program.command("telemetry").description("Manage anonymous telemetry preferences. Use 1 to enable, 0 to disable, or no argument to check status").option("-s, --state <state>", "Enable (1) or disable (0) telemetry", parseTelemetryOption).action(withCommandContext((options, ui) => telemetry(options, ui, telemetryService)));
 program.parse();
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map