simple-photo-gallery 2.0.11-rc.1 → 2.0.11-rc.2

package/dist/index.cjs

@@ -0,0 +1,1257 @@
+#!/usr/bin/env node
+'use strict';
+
+var process3 = require('process');
+var commander = require('commander');
+var consola = require('consola');
+var child_process = require('child_process');
+var fs8 = require('fs');
+var path7 = require('path');
+var buffer = require('buffer');
+var sharp2 = require('sharp');
+var blurhash = require('blurhash');
+var ExifReader = require('exifreader');
+var gallery = require('@simple-photo-gallery/common/src/gallery');
+var ffprobe = require('node-ffprobe');
+var os = require('os');
+var Conf = require('conf');
+var axios = require('axios');
+var semverParser = require('semver-parser');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var process3__default = /*#__PURE__*/_interopDefault(process3);
+var fs8__default = /*#__PURE__*/_interopDefault(fs8);
+var path7__default = /*#__PURE__*/_interopDefault(path7);
+var sharp2__default = /*#__PURE__*/_interopDefault(sharp2);
+var ExifReader__default = /*#__PURE__*/_interopDefault(ExifReader);
+var ffprobe__default = /*#__PURE__*/_interopDefault(ffprobe);
+var os__default = /*#__PURE__*/_interopDefault(os);
+var Conf__default = /*#__PURE__*/_interopDefault(Conf);
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+
+// src/config/index.ts
+var DEFAULT_THUMBNAIL_SIZE = 300;
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".gif", ".webp", ".tiff", ".tif", ".svg", ".avif"]);
+var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([".mp4", ".avi", ".mov", ".wmv", ".flv", ".webm", ".mkv", ".m4v", ".3gp"]);
+var HEADER_IMAGE_LANDSCAPE_WIDTHS = [3840, 2560, 1920, 1280, 960, 640];
+var HEADER_IMAGE_PORTRAIT_WIDTHS = [1080, 720, 480, 360];
+async function loadImage(imagePath) {
+  return sharp2__default.default(imagePath).rotate();
+}
+async function loadImageWithMetadata(imagePath) {
+  const image = sharp2__default.default(imagePath);
+  const metadata = await image.metadata();
+  image.rotate();
+  const needsDimensionSwap = metadata.orientation && metadata.orientation >= 5 && metadata.orientation <= 8;
+  if (needsDimensionSwap) {
+    const originalWidth = metadata.width;
+    metadata.width = metadata.height;
+    metadata.height = originalWidth;
+  }
+  return { image, metadata };
+}
+async function resizeImage(image, outputPath, width, height, format = "avif") {
+  await image.resize(width, height, { withoutEnlargement: true }).toFormat(format).toFile(outputPath);
+}
+async function cropAndResizeImage(image, outputPath, width, height, format = "avif") {
+  await image.resize(width, height, {
+    fit: "cover",
+    withoutEnlargement: true
+  }).toFormat(format).toFile(outputPath);
+}
+async function getImageDescription(imagePath) {
+  try {
+    const tags = await ExifReader__default.default.load(imagePath);
+    if (tags.description?.description) return tags.description.description;
+    if (tags.ImageDescription?.description) return tags.ImageDescription.description;
+    if (tags.UserComment && typeof tags.UserComment === "object" && tags.UserComment !== null && "description" in tags.UserComment) {
+      return tags.UserComment.description;
+    }
+    if (tags.ExtDescrAccessibility?.description) return tags.ExtDescrAccessibility.description;
+    if (tags["Caption/Abstract"]?.description) return tags["Caption/Abstract"].description;
+    if (tags.XPTitle?.description) return tags.XPTitle.description;
+    if (tags.XPComment?.description) return tags.XPComment.description;
+  } catch {
+    return void 0;
+  }
+}
+async function createImageThumbnails(image, metadata, outputPath, outputPathRetina, size) {
+  const originalWidth = metadata.width || 0;
+  const originalHeight = metadata.height || 0;
+  if (originalWidth === 0 || originalHeight === 0) {
+    throw new Error("Invalid image dimensions");
+  }
+  const aspectRatio = originalWidth / originalHeight;
+  let width;
+  let height;
+  if (originalWidth > originalHeight) {
+    width = size;
+    height = Math.round(size / aspectRatio);
+  } else {
+    width = Math.round(size * aspectRatio);
+    height = size;
+  }
+  await resizeImage(image, outputPath, width, height);
+  await resizeImage(image, outputPathRetina, width * 2, height * 2);
+  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 blurhash.encode(pixels, info.width, info.height, componentX, componentY);
+}
+
+// src/modules/build/utils/index.ts
+path7__default.default.dirname(new URL((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))).pathname);
+async function createGallerySocialMediaCardImage(headerPhotoPath, title, ouputPath, ui) {
+  ui.start(`Creating social media card image`);
+  const headerBasename = path7__default.default.basename(headerPhotoPath, path7__default.default.extname(headerPhotoPath));
+  if (fs8__default.default.existsSync(ouputPath)) {
+    ui.success(`Social media card image already exists`);
+    return headerBasename;
+  }
+  const image = await loadImage(headerPhotoPath);
+  const resizedImageBuffer = await image.resize(1200, 631, { fit: "cover" }).jpeg({ quality: 90 }).toBuffer();
+  const outputPath = ouputPath;
+  await sharp2__default.default(resizedImageBuffer).toFile(outputPath);
+  const svgText = `
+    <svg width="1200" height="631" xmlns="http://www.w3.org/2000/svg">
+      <defs>
+        <style>
+          .title { font-family: Arial, sans-serif; font-size: 96px; font-weight: bold; fill: white; stroke: black; stroke-width: 5; paint-order: stroke; text-anchor: middle; }
+        </style>
+      </defs>
+      <text x="600" y="250" class="title">${title}</text>
+    </svg>
+  `;
+  const finalImageBuffer = await sharp2__default.default(resizedImageBuffer).composite([{ input: buffer.Buffer.from(svgText), top: 0, left: 0 }]).jpeg({ quality: 90 }).toBuffer();
+  await sharp2__default.default(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__default.default.basename(headerPhotoPath, path7__default.default.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}`);
+    const avifFilename = `${headerBasename}_landscape_${width}.avif`;
+    const jpgFilename = `${headerBasename}_landscape_${width}.jpg`;
+    if (fs8__default.default.existsSync(path7__default.default.join(outputFolder, avifFilename))) {
+      ui.debug(`Landscape header image ${width} AVIF already exists`);
+    } else {
+      await cropAndResizeImage(
+        image.clone(),
+        path7__default.default.join(outputFolder, avifFilename),
+        width,
+        width * landscapeYFactor,
+        "avif"
+      );
+    }
+    generatedFiles.push(avifFilename);
+    if (fs8__default.default.existsSync(path7__default.default.join(outputFolder, jpgFilename))) {
+      ui.debug(`Landscape header image ${width} JPG already exists`);
+    } else {
+      await cropAndResizeImage(image.clone(), path7__default.default.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}`);
+    const avifFilename = `${headerBasename}_portrait_${width}.avif`;
+    const jpgFilename = `${headerBasename}_portrait_${width}.jpg`;
+    if (fs8__default.default.existsSync(path7__default.default.join(outputFolder, avifFilename))) {
+      ui.debug(`Portrait header image ${width} AVIF already exists`);
+    } else {
+      await cropAndResizeImage(image.clone(), path7__default.default.join(outputFolder, avifFilename), width, width * portraitYFactor, "avif");
+    }
+    generatedFiles.push(avifFilename);
+    if (fs8__default.default.existsSync(path7__default.default.join(outputFolder, jpgFilename))) {
+      ui.debug(`Portrait header image ${width} JPG already exists`);
+    } else {
+      await cropAndResizeImage(image.clone(), path7__default.default.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__default.default.existsSync(outputFolder)) {
+    return false;
+  }
+  const files = fs8__default.default.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__default.default.existsSync(outputFolder)) {
+    ui.debug(`Output folder ${outputFolder} does not exist, skipping cleanup`);
+    return;
+  }
+  const files = fs8__default.default.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__default.default.join(outputFolder, file);
+      ui.debug(`Deleting old landscape header image: ${file}`);
+      fs8__default.default.unlinkSync(filePath);
+      deletedCount++;
+    } else if (portraitMatch && portraitMatch[1] !== currentHeaderBasename) {
+      const filePath = path7__default.default.join(outputFolder, file);
+      ui.debug(`Deleting old portrait header image: ${file}`);
+      fs8__default.default.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 = path7__default.default.join(basePath, "gallery", "gallery.json");
+  if (fs8__default.default.existsSync(galleryJsonPath)) {
+    galleryDirs.push(basePath);
+  }
+  if (recursive) {
+    try {
+      const entries = fs8__default.default.readdirSync(basePath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name !== "gallery") {
+          const subPath = path7__default.default.join(basePath, entry.name);
+          const subResults = findGalleries(subPath, recursive);
+          galleryDirs.push(...subResults);
+        }
+      }
+    } catch {
+    }
+  }
+  return galleryDirs;
+}
+function handleFileProcessingError(error, filename, ui) {
+  if (error instanceof Error && (error.message.includes("ffprobe") || error.message.includes("ffmpeg"))) {
+    ui.warn(
+      `Error processing ${filename}: ffprobe (part of ffmpeg) is required to process videos. Please install ffmpeg and ensure it is available in your PATH`
+    );
+  } else if (error instanceof Error && error.message.includes("unsupported image format")) {
+    ui.warn(`Error processing ${filename}: unsupported image format`);
+  } else {
+    ui.warn(`Error processing ${filename}`);
+  }
+  ui.debug(error);
+}
+function parseTelemetryOption(value) {
+  if (value !== "0" && value !== "1") {
+    throw new Error("Telemetry option must be either 0 or 1.");
+  }
+  return value;
+}
+function parseGalleryJson(galleryJsonPath, ui) {
+  let galleryContent;
+  try {
+    galleryContent = fs8__default.default.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 gallery.GalleryDataSchema.parse(galleryJSON);
+  } catch (error) {
+    try {
+      const deprecatedGalleryData = gallery.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__default.default.join("..", path7__default.default.basename(imagePath))) {
+    mediaBasePath = path7__default.default.resolve(path7__default.default.join(path7__default.default.dirname(galleryJsonPath)), path7__default.default.dirname(imagePath));
+  }
+  const sections = deprecatedGalleryData.sections.map((section) => ({
+    ...section,
+    images: section.images.map((image) => ({
+      ...image,
+      path: void 0,
+      filename: path7__default.default.basename(image.path)
+    }))
+  }));
+  const galleryData = {
+    ...deprecatedGalleryData,
+    headerImage: path7__default.default.basename(deprecatedGalleryData.headerImage),
+    sections,
+    mediaBasePath
+  };
+  ui.debug("Backing up old gallery.json file");
+  fs8__default.default.copyFileSync(galleryJsonPath, `${galleryJsonPath}.old`);
+  ui.debug("Writing gallery data to gallery.json file");
+  fs8__default.default.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__default.default.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 fs8.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__default.default.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__default.default.dirname(galleryJsonPath);
+  const isSameLocation = path7__default.default.relative(scanPath, path7__default.default.join(galleryDir, "..")) === "";
+  const mediaBasePath = isSameLocation ? void 0 : scanPath;
+  const relativeSubGalleries = subGalleries.map((subGallery) => ({
+    ...subGallery,
+    headerImage: subGallery.headerImage ? path7__default.default.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__default.default.basename(path7__default.default.join(galleryDir, "..")),
+        path7__default.default.basename(mediaFiles[0]?.filename || ""),
+        ui
+      )
+    };
+  }
+  await fs8.promises.writeFile(galleryJsonPath, JSON.stringify(galleryData, null, 2));
+}
+async function galleryExists(outputPath) {
+  const galleryPath = path7__default.default.join(outputPath, "gallery");
+  const galleryJsonPath = path7__default.default.join(galleryPath, "gallery.json");
+  try {
+    await fs8.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__default.default.join(outputPath, path7__default.default.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__default.default.join(outputPath, "gallery");
+    const galleryJsonPath = path7__default.default.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 fs8.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__default.default.basename(scanPath);
+    result.subGallery = {
+      title: capitalizeTitle(dirName),
+      headerImage: mediaFiles[0]?.filename || "",
+      path: path7__default.default.join("..", dirName)
+    };
+  }
+  return result;
+}
+async function init(options, ui) {
+  try {
+    const scanPath = path7__default.default.resolve(options.photos);
+    const outputPath = options.gallery ? path7__default.default.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 fs8.promises.stat(filePath);
+  return stats.mtime;
+}
+async function getVideoDimensions(filePath) {
+  const data = await ffprobe__default.default(filePath);
+  const videoStream = data.streams.find((stream) => stream.codec_type === "video");
+  if (!videoStream) {
+    throw new Error("No video stream found");
+  }
+  const dimensions = {
+    width: videoStream.width || 0,
+    height: videoStream.height || 0
+  };
+  if (dimensions.width === 0 || dimensions.height === 0) {
+    throw new Error("Invalid video dimensions");
+  }
+  return dimensions;
+}
+async function createVideoThumbnails(inputPath, videoDimensions, outputPath, outputPathRetina, height, verbose = false) {
+  const aspectRatio = videoDimensions.width / videoDimensions.height;
+  const width = Math.round(height * aspectRatio);
+  const tempFramePath = `${outputPath}.temp.png`;
+  return new Promise((resolve, reject) => {
+    const ffmpeg = child_process.spawn("ffmpeg", [
+      "-i",
+      inputPath,
+      "-vframes",
+      "1",
+      "-y",
+      "-loglevel",
+      verbose ? "error" : "quiet",
+      tempFramePath
+    ]);
+    ffmpeg.stderr.on("data", (data) => {
+      console.log(`ffmpeg: ${data.toString()}`);
+    });
+    ffmpeg.on("close", async (code) => {
+      if (code === 0) {
+        try {
+          const frameImage = sharp2__default.default(tempFramePath);
+          await resizeImage(frameImage, outputPath, width, height);
+          await resizeImage(frameImage, outputPathRetina, width * 2, height * 2);
+          try {
+            await fs8.promises.unlink(tempFramePath);
+          } catch {
+          }
+          resolve({ width, height });
+        } catch (sharpError) {
+          reject(new Error(`Failed to process extracted frame: ${sharpError}`));
+        }
+      } else {
+        reject(new Error(`ffmpeg exited with code ${code}`));
+      }
+    });
+    ffmpeg.on("error", (error) => {
+      reject(new Error(`Failed to start ffmpeg: ${error.message}`));
+    });
+  });
+}
+
+// src/modules/thumbnails/index.ts
+async function processImage(imagePath, thumbnailPath, thumbnailPathRetina, thumbnailSize, lastMediaTimestamp) {
+  const fileMtime = await getFileMtime(imagePath);
+  if (lastMediaTimestamp && fileMtime <= lastMediaTimestamp && fs8__default.default.existsSync(thumbnailPath)) {
+    return void 0;
+  }
+  const { image, metadata } = await loadImageWithMetadata(imagePath);
+  const imageDimensions = {
+    width: metadata.width || 0,
+    height: metadata.height || 0
+  };
+  if (imageDimensions.width === 0 || imageDimensions.height === 0) {
+    throw new Error("Invalid image dimensions");
+  }
+  const description = await getImageDescription(imagePath);
+  const thumbnailDimensions = await createImageThumbnails(
+    image,
+    metadata,
+    thumbnailPath,
+    thumbnailPathRetina,
+    thumbnailSize
+  );
+  const blurHash = await generateBlurHash(thumbnailPath);
+  return {
+    type: "image",
+    filename: path7__default.default.basename(imagePath),
+    alt: description,
+    width: imageDimensions.width,
+    height: imageDimensions.height,
+    thumbnail: {
+      path: thumbnailPath,
+      pathRetina: thumbnailPathRetina,
+      width: thumbnailDimensions.width,
+      height: thumbnailDimensions.height,
+      blurHash
+    },
+    lastMediaTimestamp: fileMtime.toISOString()
+  };
+}
+async function processVideo(videoPath, thumbnailPath, thumbnailPathRetina, thumbnailSize, verbose, lastMediaTimestamp) {
+  const fileMtime = await getFileMtime(videoPath);
+  if (lastMediaTimestamp && fileMtime <= lastMediaTimestamp && fs8__default.default.existsSync(thumbnailPath)) {
+    return void 0;
+  }
+  const videoDimensions = await getVideoDimensions(videoPath);
+  const thumbnailDimensions = await createVideoThumbnails(
+    videoPath,
+    videoDimensions,
+    thumbnailPath,
+    thumbnailPathRetina,
+    thumbnailSize,
+    verbose
+  );
+  const blurHash = await generateBlurHash(thumbnailPath);
+  return {
+    type: "video",
+    filename: path7__default.default.basename(videoPath),
+    alt: void 0,
+    width: videoDimensions.width,
+    height: videoDimensions.height,
+    thumbnail: {
+      path: thumbnailPath,
+      pathRetina: thumbnailPathRetina,
+      width: thumbnailDimensions.width,
+      height: thumbnailDimensions.height,
+      blurHash
+    },
+    lastMediaTimestamp: fileMtime.toISOString()
+  };
+}
+async function processMediaFile(mediaFile, mediaBasePath, galleryDir, thumbnailsPath, thumbnailSize, ui) {
+  try {
+    const filePath = path7__default.default.resolve(path7__default.default.join(mediaBasePath, mediaFile.filename));
+    const fileName = mediaFile.filename;
+    const fileNameWithoutExt = path7__default.default.parse(fileName).name;
+    const thumbnailFileName = `${fileNameWithoutExt}.avif`;
+    const thumbnailPath = path7__default.default.join(thumbnailsPath, thumbnailFileName);
+    const thumbnailPathRetina = thumbnailPath.replace(".avif", "@2x.avif");
+    const lastMediaTimestamp = mediaFile.lastMediaTimestamp ? new Date(mediaFile.lastMediaTimestamp) : void 0;
+    const verbose = ui.level === consola.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 && fs8__default.default.existsSync(thumbnailPath)) {
+        try {
+          const blurHash = await generateBlurHash(thumbnailPath);
+          return {
+            ...mediaFile,
+            thumbnail: {
+              ...mediaFile.thumbnail,
+              blurHash
+            }
+          };
+        } catch (error) {
+          ui.debug(`  Failed to generate BlurHash for ${fileName}:`, error);
+        }
+      }
+      return mediaFile;
+    }
+    updatedMediaFile.filename = mediaFile.filename;
+    if (updatedMediaFile.thumbnail) {
+      updatedMediaFile.thumbnail.path = path7__default.default.basename(thumbnailPath);
+      updatedMediaFile.thumbnail.pathRetina = path7__default.default.basename(thumbnailPathRetina);
+    }
+    return updatedMediaFile;
+  } catch (error) {
+    handleFileProcessingError(error, mediaFile.filename, ui);
+    return { ...mediaFile, thumbnail: void 0 };
+  }
+}
+async function processGalleryThumbnails(galleryDir, ui) {
+  const galleryJsonPath = path7__default.default.join(galleryDir, "gallery", "gallery.json");
+  const thumbnailsPath = path7__default.default.join(galleryDir, "gallery", "images");
+  ui.start(`Creating thumbnails: ${galleryDir}`);
+  try {
+    fs8__default.default.mkdirSync(thumbnailsPath, { recursive: true });
+    const galleryData = parseGalleryJson(galleryJsonPath, ui);
+    const thumbnailSize = galleryData.thumbnailSize || DEFAULT_THUMBNAIL_SIZE;
+    const mediaBasePath = galleryData.mediaBasePath ?? path7__default.default.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,
+          mediaBasePath,
+          galleryDir,
+          thumbnailsPath,
+          thumbnailSize,
+          ui
+        );
+      }
+      processedCount += section.images.length;
+    }
+    fs8__default.default.writeFileSync(galleryJsonPath, JSON.stringify(galleryData, null, 2));
+    ui.success(`Created thumbnails for ${processedCount} media files`);
+    return processedCount;
+  } catch (error) {
+    ui.error(`Error creating thumbnails for ${galleryDir}`);
+    throw error;
+  }
+}
+async function thumbnails(options, ui) {
+  try {
+    const galleryDirs = findGalleries(options.gallery, options.recursive);
+    if (galleryDirs.length === 0) {
+      ui.error("No galleries found.");
+      return { processedGalleryCount: 0, processedMediaCount: 0 };
+    }
+    let totalGalleries = 0;
+    let totalProcessed = 0;
+    for (const galleryDir of galleryDirs) {
+      const processed = await processGalleryThumbnails(galleryDir, ui);
+      if (processed > 0) {
+        ++totalGalleries;
+        totalProcessed += processed;
+      }
+    }
+    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;
+  }
+}
+
+// src/modules/build/index.ts
+function copyPhotos(galleryData, galleryDir, ui) {
+  for (const section of galleryData.sections) {
+    for (const image of section.images) {
+      if (galleryData.mediaBasePath) {
+        const sourcePath = path7__default.default.join(galleryData.mediaBasePath, image.filename);
+        const destPath = path7__default.default.join(galleryDir, image.filename);
+        ui.debug(`Copying photo to ${destPath}`);
+        fs8__default.default.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__default.default.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, scan, shouldCreateThumbnails, ui, baseUrl, thumbsBaseUrl) {
+  ui.start(`Building gallery ${galleryDir}`);
+  const galleryJsonPath = path7__default.default.join(galleryDir, "gallery", "gallery.json");
+  let galleryData = parseGalleryJson(galleryJsonPath, ui);
+  if (scan) {
+    galleryData = await scanAndAppendNewFiles(galleryDir, galleryJsonPath, galleryData, ui);
+  }
+  const socialMediaCardImagePath = path7__default.default.join(galleryDir, "gallery", "images", "social-media-card.jpg");
+  const mediaBasePath = galleryData.mediaBasePath;
+  const mediaBaseUrl = baseUrl || galleryData.mediaBaseUrl;
+  const headerImagePath = mediaBasePath ? path7__default.default.join(mediaBasePath, galleryData.headerImage) : path7__default.default.resolve(galleryDir, galleryData.headerImage);
+  const imagesFolder = path7__default.default.join(galleryDir, "gallery", "images");
+  const currentHeaderBasename = path7__default.default.basename(headerImagePath, path7__default.default.extname(headerImagePath));
+  if (shouldCreateThumbnails) {
+    if (!fs8__default.default.existsSync(imagesFolder)) {
+      fs8__default.default.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__default.default.existsSync(socialMediaCardImagePath)) {
+        fs8__default.default.unlinkSync(socialMediaCardImagePath);
+        ui.debug("Deleted old social media card");
+      }
+    }
+    await createGallerySocialMediaCardImage(headerImagePath, galleryData.title, socialMediaCardImagePath, ui);
+    const { blurHash } = await createOptimizedHeaderImage(headerImagePath, imagesFolder, ui);
+    if (galleryData.headerImageBlurHash !== blurHash) {
+      ui.debug("Updating gallery.json with header image blurhash");
+      galleryData.headerImageBlurHash = blurHash;
+      fs8__default.default.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 (mediaBaseUrl && galleryData.mediaBaseUrl !== mediaBaseUrl) {
+    ui.debug("Updating gallery.json with baseUrl");
+    galleryData.mediaBaseUrl = mediaBaseUrl;
+    fs8__default.default.writeFileSync(galleryJsonPath, JSON.stringify(galleryData, null, 2));
+  }
+  if (thumbsBaseUrl && galleryData.thumbsBaseUrl !== thumbsBaseUrl) {
+    ui.debug("Updating gallery.json with thumbsBaseUrl");
+    galleryData.thumbsBaseUrl = thumbsBaseUrl;
+    fs8__default.default.writeFileSync(galleryJsonPath, JSON.stringify(galleryData, null, 2));
+  }
+  if (!galleryData.metadata.image) {
+    ui.debug("Updating gallery.json with social media card URL");
+    galleryData.metadata.image = thumbsBaseUrl ? `${thumbsBaseUrl}/${path7__default.default.basename(socialMediaCardImagePath)}` : `${galleryData.url || ""}/${path7__default.default.relative(galleryDir, socialMediaCardImagePath)}`;
+    fs8__default.default.writeFileSync(galleryJsonPath, JSON.stringify(galleryData, null, 2));
+  }
+  if (shouldCreateThumbnails) {
+    await processGalleryThumbnails(galleryDir, ui);
+  }
+  ui.debug("Building gallery from template");
+  try {
+    process3__default.default.env.GALLERY_JSON_PATH = galleryJsonPath;
+    process3__default.default.env.GALLERY_OUTPUT_DIR = path7__default.default.join(galleryDir, "gallery");
+    child_process.execSync("npx astro build", { cwd: templateDir, stdio: ui.level === consola.LogLevels.debug ? "inherit" : "ignore" });
+  } catch (error) {
+    ui.error(`Build failed for ${galleryDir}`);
+    throw error;
+  }
+  const outputDir = path7__default.default.join(galleryDir, "gallery");
+  const buildDir = path7__default.default.join(outputDir, "_build");
+  ui.debug(`Copying build output to ${outputDir}`);
+  fs8__default.default.cpSync(buildDir, outputDir, { recursive: true });
+  ui.debug("Moving index.html to gallery directory");
+  fs8__default.default.copyFileSync(path7__default.default.join(outputDir, "index.html"), path7__default.default.join(galleryDir, "index.html"));
+  fs8__default.default.rmSync(path7__default.default.join(outputDir, "index.html"));
+  ui.debug("Cleaning up build directory");
+  fs8__default.default.rmSync(buildDir, { recursive: true, force: true });
+  ui.success(`Gallery built successfully`);
+}
+async function build(options, ui) {
+  try {
+    const galleryDirs = findGalleries(options.gallery, options.recursive);
+    if (galleryDirs.length === 0) {
+      ui.error("No galleries found.");
+      return { processedGalleryCount: 0 };
+    }
+    const themePath = await undefined("@simple-photo-gallery/theme-modern/package.json");
+    const themeDir = path7__default.default.dirname(new URL(themePath).pathname);
+    let totalGalleries = 0;
+    for (const dir of galleryDirs) {
+      const baseUrl = options.baseUrl ? `${options.baseUrl}${path7__default.default.relative(options.gallery, dir)}` : void 0;
+      const thumbsBaseUrl = options.thumbsBaseUrl ? `${options.thumbsBaseUrl}${path7__default.default.relative(options.gallery, dir)}` : void 0;
+      await buildGallery(path7__default.default.resolve(dir), themeDir, options.scan, options.thumbnails, ui, baseUrl, thumbsBaseUrl);
+      ++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");
+    } else {
+      ui.error("Error building gallery");
+    }
+    throw error;
+  }
+}
+async function cleanGallery(galleryDir, ui) {
+  let filesRemoved = 0;
+  const indexHtmlPath = path7__default.default.join(galleryDir, "index.html");
+  if (fs8__default.default.existsSync(indexHtmlPath)) {
+    try {
+      fs8__default.default.rmSync(indexHtmlPath);
+      ui.debug(`Removed: ${indexHtmlPath}`);
+      filesRemoved++;
+    } catch (error) {
+      ui.warn(`Failed to remove index.html: ${error}`);
+    }
+  }
+  const galleryPath = path7__default.default.join(galleryDir, "gallery");
+  if (fs8__default.default.existsSync(galleryPath)) {
+    try {
+      fs8__default.default.rmSync(galleryPath, { recursive: true, force: true });
+      ui.debug(`Removed directory: ${galleryPath}`);
+      filesRemoved++;
+    } catch (error) {
+      ui.warn(`Failed to remove gallery directory: ${error}`);
+    }
+  }
+  if (filesRemoved > 0) {
+    ui.success(`Cleaned gallery at: ${galleryDir}`);
+  } else {
+    ui.info(`No gallery files found at: ${galleryDir}`);
+  }
+  return { processedGalleryCount: filesRemoved };
+}
+async function clean(options, ui) {
+  try {
+    const basePath = path7__default.default.resolve(options.gallery);
+    if (!fs8__default.default.existsSync(basePath)) {
+      ui.error(`Directory does not exist: ${basePath}`);
+      return { processedGalleryCount: 0 };
+    }
+    const galleryDirs = findGalleries(basePath, options.recursive);
+    if (galleryDirs.length === 0) {
+      ui.info("No galleries found to clean.");
+      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;
+  }
+}
+
+// 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.info(`Telemetry is currently ${current ? "enabled" : "disabled"}.`);
+      updates.telemetryEnabled = current;
+    }
+  } else {
+    telemetryService2.setStoredPreference(options.state === "1");
+    ui.success(`Anonymous telemetry ${options.state === "1" ? "enabled" : "disabled"}.`);
+    updates.telemetryEnabled = options.state === "1";
+  }
+  return updates;
+}
+var ApiTelemetryClient = class {
+  constructor() {
+    this.endpoint = "https://tools.simple.photo/api/telemetry";
+  }
+  async record(event) {
+    try {
+      axios__default.default.post(this.endpoint, event, {
+        headers: {
+          "content-type": "application/json",
+          "user-agent": `simple-photo-gallery/${event.packageVersion} (${process3__default.default.platform}; ${process3__default.default.arch})`
+        }
+      });
+    } catch {
+    }
+  }
+};
+var ConsoleTelemetryClient = class {
+  async record(event) {
+    const serialized = JSON.stringify(event, null, 2);
+    process3.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__default.default({ 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__default.default.env.CI || process3__default.default.env.DO_NOT_TRACK) {
+      return false;
+    }
+    if (process3__default.default.env.SPG_TELEMETRY) {
+      return process3__default.default.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;
+    }
+  }
+  /** Builds and dispatches a telemetry event when telemetry is enabled. */
+  async emit(params) {
+    const event = this.buildEvent(params);
+    try {
+      const client = await this.getClient();
+      if (client) {
+        await client.record(event);
+      }
+    } catch (error) {
+      this.ui.debug("Error recording telemetry event", error);
+    }
+  }
+  /** 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__default.default.version,
+      osPlatform: os__default.default.platform(),
+      osRelease: os__default.default.release(),
+      osArch: os__default.default.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;
+  }
+  /** 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."
+    );
+    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__default.default.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) {
+  try {
+    const response = await axios__default.default.get(`${NPM_REGISTRY_URL}/${packageName}`, {
+      timeout: CHECK_TIMEOUT_MS,
+      headers: {
+        Accept: "application/vnd.npm.install-v1+json"
+      }
+    });
+    const versions = Object.keys(response.data.versions);
+    const stableVersions = versions.filter((version) => {
+      try {
+        const parsed = semverParser.parseSemVer(version);
+        return !parsed.pre || parsed.pre.length === 0;
+      } catch {
+        return false;
+      }
+    });
+    if (stableVersions.length === 0) {
+      return void 0;
+    }
+    stableVersions.sort(semverParser.compareSemVer);
+    return stableVersions[stableVersions.length - 1];
+  } catch {
+    return void 0;
+  }
+}
+function checkForUpdates(packageName, currentVersion) {
+  return fetchLatestStableVersion(packageName).then((latestStableVersion) => {
+    if (!latestStableVersion) {
+      return null;
+    }
+    try {
+      if (semverParser.compareSemVer(latestStableVersion, currentVersion) > 0) {
+        return { currentVersion, latestVersion: latestStableVersion };
+      }
+    } catch {
+    }
+    return null;
+  });
+}
+function displayUpdateNotification(updateInfo, ui) {
+  const { currentVersion, latestVersion } = updateInfo;
+  const message = [
+    `New version available: ${currentVersion} \u2192 ${latestVersion}`,
+    "",
+    "Run the following commands to update:",
+    "",
+    "  npm install -g simple-photo-gallery@latest"
+  ].join("\n");
+  ui.box(message);
+}
+async function waitForUpdateCheck(checkPromise) {
+  try {
+    let timeoutId;
+    const timeoutPromise = new Promise((resolve) => {
+      timeoutId = setTimeout(() => resolve(null), 5e3);
+    });
+    const result = await Promise.race([checkPromise, timeoutPromise]);
+    clearTimeout(timeoutId);
+    return result;
+  } catch {
+    return null;
+  }
+}
+
+// package.json
+var package_default = {
+  name: "simple-photo-gallery",
+  version: "2.0.11-rc.2"};
+
+// src/index.ts
+var program = new commander.Command();
+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 = consola.LogLevels.info;
+  if (globalOpts.quiet) {
+    level = consola.LogLevels.warn;
+  } else if (globalOpts.verbose) {
+    level = consola.LogLevels.debug;
+  }
+  return consola.createConsola({
+    level
+  }).withTag("simple-photo-gallery");
+}
+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 {
+      const result = await handler(commandOptions, ui, command);
+      if (result && Object.keys(result).length > 0) {
+        metrics = result;
+      }
+      success = true;
+    } catch (error) {
+      ui.debug(error);
+      errorInfo = error instanceof Error ? { name: error.name, message: error.message } : { name: "UnknownError", message: String(error) };
+      process3__default.default.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",
+  process3__default.default.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).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__default.default.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__default.default.cwd()).option("-r, --recursive", "Scan subdirectories recursively", false).option("-b, --base-url <url>", "Base URL where the photos are hosted").option("-t, --thumbs-base-url <url>", "Base URL where the thumbnails are hosted").option("--no-thumbnails", "Skip creating thumbnails when building the gallery", true).option("--no-scan", "Do not scan for new photos when building the gallery", true).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__default.default.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.cjs.map
+//# sourceMappingURL=index.cjs.map