@lightnet/cli 4.4.0 → 4.4.2

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @lightnet/cli
 
+## 4.4.2
+
+### Patch Changes
+
+- [#433](https://github.com/LightNetDev/LightNet/pull/433) [`dbde36e`](https://github.com/LightNetDev/LightNet/commit/dbde36e7a25bf6470783e9594260b666e09c2783) - Make `check-files` summaries clearer by explaining what was compared and what needs attention.
+
+- [#433](https://github.com/LightNetDev/LightNet/pull/433) [`dbde36e`](https://github.com/LightNetDev/LightNet/commit/dbde36e7a25bf6470783e9594260b666e09c2783) - Handle Ctrl+C cancellation consistently for interactive `check-*` command prompts.
+
+- [#433](https://github.com/LightNetDev/LightNet/pull/433) [`dbde36e`](https://github.com/LightNetDev/LightNet/commit/dbde36e7a25bf6470783e9594260b666e09c2783) - Replace `check-files --fix --no-confirm` with `check-files --fix-without-confirm` for non-interactive cleanup.
+
+- [#433](https://github.com/LightNetDev/LightNet/pull/433) [`dbde36e`](https://github.com/LightNetDev/LightNet/commit/dbde36e7a25bf6470783e9594260b666e09c2783) - Treat warning-only `check-files` runs as successful when no local content file references are found.
+
+- [#433](https://github.com/LightNetDev/LightNet/pull/433) [`dbde36e`](https://github.com/LightNetDev/LightNet/commit/dbde36e7a25bf6470783e9594260b666e09c2783) - Improve `check-files` and `check-links` output for long referenced paths and URLs.
+
+## 4.4.1
+
+### Patch Changes
+
+- [#431](https://github.com/LightNetDev/LightNet/pull/431) [`aa5968f`](https://github.com/LightNetDev/LightNet/commit/aa5968f26112f93121f03e7aafdfb04018186032) - Delete orphaned R2 objects from `check-files --fix --r2` in batches instead of spawning one rclone process per file.
+
+- [#431](https://github.com/LightNetDev/LightNet/pull/431) [`aa5968f`](https://github.com/LightNetDev/LightNet/commit/aa5968f26112f93121f03e7aafdfb04018186032) - Show progress feedback while `check-files` and `check-links` perform long-running checks.
+
+- [#431](https://github.com/LightNetDev/LightNet/pull/431) [`aa5968f`](https://github.com/LightNetDev/LightNet/commit/aa5968f26112f93121f03e7aafdfb04018186032) - Improve `check-files` performance by avoiding duplicate R2 listings and parallelizing independent filesystem work.
+
+- [#431](https://github.com/LightNetDev/LightNet/pull/431) [`aa5968f`](https://github.com/LightNetDev/LightNet/commit/aa5968f26112f93121f03e7aafdfb04018186032) - Protect R2 objects referenced by media content links from `check-files --fix --r2` cleanup and warn that they should use upload content.
+
+- [#431](https://github.com/LightNetDev/LightNet/pull/431) [`aa5968f`](https://github.com/LightNetDev/LightNet/commit/aa5968f26112f93121f03e7aafdfb04018186032) - Decode percent-encoded R2 public URLs when matching `check-files --r2` references against bucket objects.
+
 ## 4.4.0
 
 ### Minor Changes

package/package.json

@@ -3,7 +3,7 @@
   "description": "CLI for managing LightNet projects",
   "type": "module",
   "license": "MIT",
-  "version": "4.4.0",
+  "version": "4.4.2",
   "publishConfig": {
     "access": "public"
   },
@@ -25,8 +25,8 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "commander": "^15.0.0",
-    "@clack/prompts": "^1.6.0"
+    "@clack/prompts": "^1.7.0",
+    "commander": "^15.0.0"
   },
   "engines": {
     "node": ">=22"

package/src/check-files.js

@@ -3,7 +3,15 @@
 import { join, posix, resolve } from "node:path"
 import { cwd as processCwd, stdin, stdout } from "node:process"
 
-import { confirm, intro, isCancel, log, outro, text } from "@clack/prompts"
+import {
+  confirm,
+  intro,
+  isCancel,
+  log,
+  outro,
+  spinner,
+  text,
+} from "@clack/prompts"
 
 import { CliError } from "./support/cli-error.js"
 import { contentCollections } from "./support/content-collections.js"
@@ -13,6 +21,7 @@ import {
   pathExists,
   toLocalContentDisplayPath,
 } from "./support/filesystem.js"
+import { cancelPrompt } from "./support/prompt-cancel.js"
 import { createR2FileStorage } from "./support/r2.js"
 
 const supportedScopes = new Set(["content-files", "thumbnails"])
@@ -25,7 +34,7 @@ const categoryImagesDir = "src/content/categories/images"
  * @typedef {{
  *   scope?: string
  *   fix?: boolean
- *   confirm?: boolean
+ *   fixWithoutConfirm?: boolean
  *   r2?: boolean
  * }} CheckFilesOptions
  */
@@ -48,6 +57,8 @@ const categoryImagesDir = "src/content/categories/images"
  * }} FileReference
  */
 
+/** @typedef {MissingReference} WrongTypeReference */
+
 /**
  * @typedef {{
  *   cwd?: string
@@ -79,14 +90,15 @@ export async function checkFiles(options, runtime = {}) {
   await assertLightNetSiteRoot(cwd)
 
   const collections = contentCollections(cwd)
-  const mediaItems = await collections.getMediaItems()
-  const categories = await collections.getCategories()
-  log.message(
-    `Checking ${mediaItems.length} media items and ${categories.length} categories.`,
-  )
+  const [mediaItems, categories] = await Promise.all([
+    collections.getMediaItems(),
+    collections.getCategories(),
+  ])
 
   /** @type {MissingReference[]} */
   let missingContentFiles = []
+  /** @type {WrongTypeReference[]} */
+  let wrongTypeR2ContentFiles = []
   /** @type {string[]} */
   let orphanedContentFiles = []
   /** @type {string[]} */
@@ -104,18 +116,40 @@ export async function checkFiles(options, runtime = {}) {
   const categoryThumbnailStorage = files(cwd, { rootDir: categoryImagesDir })
 
   if (includeContentFiles) {
+    contentFileStorage = options.r2
+      ? createR2FileStorage({
+          cwd,
+          interactive,
+          promptConfirm,
+          promptText,
+        })
+      : contentFiles(cwd)
+    contentFileStorage = await contentFileStorage.init()
+  }
+
+  log.message(
+    `Checking ${mediaItems.length} media items and ${categories.length} categories.`,
+  )
+
+  if (includeContentFiles) {
+    if (!contentFileStorage) {
+      throw new CliError("Missing file storage for content validation.")
+    }
+    const initializedContentFileStorage = contentFileStorage
     if (options.r2) {
-      contentFileStorage = createR2FileStorage({
-        cwd,
-        interactive,
-        promptConfirm,
-        promptText,
-      })
-      const r2Result = await validateContentFiles({
-        mediaItems,
-        storage: contentFileStorage,
+      const r2Result = await runSpinner({
+        error: "Content file check failed.",
+        start: "Listing R2 objects and checking content file references",
+        stop: (result) => formatContentCheckSummary(result),
+        task: () =>
+          validateContentFiles({
+            includeLinkReferences: true,
+            mediaItems,
+            storage: initializedContentFileStorage,
+          }),
       })
       missingContentFiles = r2Result.missingReferences
+      wrongTypeR2ContentFiles = r2Result.wrongTypeReferences
       orphanedContentFiles = r2Result.orphanedFiles
       if (r2Result.referenceCount === 0) {
         warnings.push(
@@ -123,33 +157,44 @@ export async function checkFiles(options, runtime = {}) {
         )
       }
     } else {
-      contentFileStorage = contentFiles(cwd)
-      const localContentResult = await validateContentFiles({
-        mediaItems,
-        storage: contentFileStorage,
+      const localContentResult = await runSpinner({
+        error: "Content file check failed.",
+        start: "Checking local content files",
+        stop: (result) => formatContentCheckSummary(result),
+        task: () =>
+          validateContentFiles({
+            mediaItems,
+            storage: initializedContentFileStorage,
+          }),
       })
       missingContentFiles = localContentResult.missingReferences
       orphanedContentFiles = localContentResult.orphanedFiles
       if (localContentResult.referenceCount === 0) {
         warnings.push(
-          'No local "/files" content file references found. Use "--scope=thumbnails" or run with "--r2".',
+          'No local "/files" content file references found. If your content files are stored in R2, consider re-running with "--r2".',
         )
       }
     }
   }
 
   if (includeThumbnails) {
-    const thumbnailsResult = await validateThumbnails(
-      mediaItems,
-      categories,
-      mediaThumbnailStorage,
-      categoryThumbnailStorage,
-    )
+    const thumbnailsResult = await runSpinner({
+      error: "Thumbnail check failed.",
+      start: "Checking thumbnails",
+      stop: (result) => formatThumbnailCheckSummary(result),
+      task: () =>
+        validateThumbnails(
+          mediaItems,
+          categories,
+          mediaThumbnailStorage,
+          categoryThumbnailStorage,
+        ),
+    })
     orphanedMediaThumbnails = thumbnailsResult.orphanedMediaThumbnails
     orphanedCategoryThumbnails = thumbnailsResult.orphanedCategoryThumbnails
   }
 
-  if (options.fix) {
+  if (options.fix || options.fixWithoutConfirm) {
     /** @type {{displayPath:string, target:string}[]} */
     const deletions = []
     /** @type {{displayPath:string, target:string}[]} */
@@ -185,10 +230,10 @@ export async function checkFiles(options, runtime = {}) {
     }
 
     if (deletions.length > 0) {
-      const shouldSkipConfirmation = options.confirm === false
+      const shouldSkipConfirmation = options.fixWithoutConfirm === true
       if (!shouldSkipConfirmation && !interactive) {
         throw new CliError(
-          'Deletion requires confirmation. Re-run with "--fix --no-confirm" in non-interactive environments.',
+          'Deletion requires confirmation. Re-run with "--fix-without-confirm" in non-interactive environments.',
         )
       }
       const shouldDelete =
@@ -199,25 +244,52 @@ export async function checkFiles(options, runtime = {}) {
         }))
 
       if (shouldDelete) {
-        const deletedContentTargets = contentFileStorage
-          ? await contentFileStorage.delete(
-              contentDeletions.map((deletion) => deletion.target),
-            )
-          : []
-        const deletedLocalTargets = [
-          ...(await mediaThumbnailStorage.delete(
-            localDeletions
-              .filter((deletion) => deletion.target.startsWith(mediaImagesDir))
-              .map((deletion) => deletion.target),
-          )),
-          ...(await categoryThumbnailStorage.delete(
-            localDeletions
-              .filter((deletion) =>
-                deletion.target.startsWith(categoryImagesDir),
-              )
-              .map((deletion) => deletion.target),
-          )),
-        ]
+        const { deletedContentTargets, deletedLocalTargets } = await runSpinner(
+          {
+            error: "File deletion failed.",
+            start: formatDeletionProgress("Deleting", deletions.length),
+            stop: (result) => {
+              const deletedCount =
+                result.deletedContentTargets.length +
+                result.deletedLocalTargets.length
+              return formatDeletionProgress("Deleted", deletedCount)
+            },
+            task: async () => {
+              const [
+                deletedContentTargets,
+                deletedMediaThumbnailTargets,
+                deletedCategoryThumbnailTargets,
+              ] = await Promise.all([
+                contentFileStorage
+                  ? contentFileStorage.delete(
+                      contentDeletions.map((deletion) => deletion.target),
+                    )
+                  : [],
+                mediaThumbnailStorage.delete(
+                  localDeletions
+                    .filter((deletion) =>
+                      deletion.target.startsWith(mediaImagesDir),
+                    )
+                    .map((deletion) => deletion.target),
+                ),
+                categoryThumbnailStorage.delete(
+                  localDeletions
+                    .filter((deletion) =>
+                      deletion.target.startsWith(categoryImagesDir),
+                    )
+                    .map((deletion) => deletion.target),
+                ),
+              ])
+              return {
+                deletedContentTargets,
+                deletedLocalTargets: [
+                  ...deletedMediaThumbnailTargets,
+                  ...deletedCategoryThumbnailTargets,
+                ],
+              }
+            },
+          },
+        )
         const deletedTargets = new Set([
           ...deletedContentTargets,
           ...deletedLocalTargets,
@@ -243,25 +315,29 @@ export async function checkFiles(options, runtime = {}) {
   }
 
   const hasIssues =
-    warnings.length > 0 ||
     missingContentFiles.length > 0 ||
+    wrongTypeR2ContentFiles.length > 0 ||
     orphanedContentFiles.length > 0 ||
     orphanedMediaThumbnails.length > 0 ||
     orphanedCategoryThumbnails.length > 0
 
+  for (const warning of warnings) {
+    log.warn(warning)
+  }
+
   if (!hasIssues && removedItems.length === 0) {
     outro("No issues found. 🎉")
     return true
   }
 
-  for (const warning of warnings) {
-    log.warn(warning)
-  }
-
   printMissingReferenceSection(
     "Missing referenced content files",
     missingContentFiles,
   )
+  printWrongTypeReferenceSection(
+    "R2 objects referenced as links",
+    wrongTypeR2ContentFiles,
+  )
   printSection(
     options.r2 ? "Orphaned R2 objects" : "Orphaned local content files",
     orphanedContentFiles.map((filePath) =>
@@ -300,13 +376,128 @@ function printMissingReferenceSection(title, items) {
     return
   }
   log.error(`${title} (${items.length})`)
+  for (const item of items) {
+    log.message(`• ${item.path}\n${formatReferenceSources(item.sources)}`)
+  }
+}
+
+/**
+ * @param {string} title
+ * @param {WrongTypeReference[]} items
+ */
+function printWrongTypeReferenceSection(title, items) {
+  if (items.length === 0) {
+    return
+  }
+  log.warn(`${title} (${items.length})`)
   for (const item of items) {
     log.message(
-      `• ${item.path} (referenced by ${item.sources.toSorted().join(", ")})`,
+      `• ${item.path}\n  Expected type: "upload"\n${formatReferenceSources(item.sources)}`,
     )
   }
 }
 
+/**
+ * @param {string[]} sources
+ */
+function formatReferenceSources(sources) {
+  const sortedSources = sources.toSorted()
+  if (sortedSources.length === 1) {
+    return `  Referenced by: ${sortedSources[0]}`
+  }
+  return [
+    "  Referenced by:",
+    ...sortedSources.map((source) => `  - ${source}`),
+  ].join("\n")
+}
+
+/**
+ * @template T
+ * @param {{
+ *   error: string
+ *   start: string
+ *   stop: (result: T) => string
+ *   task: () => Promise<T>
+ * }} args
+ * @returns {Promise<T>}
+ */
+async function runSpinner({ error, start, stop, task }) {
+  const activeSpinner = spinner()
+  activeSpinner.start(start)
+  try {
+    const result = await task()
+    activeSpinner.stop(stop(result))
+    return result
+  } catch (caughtError) {
+    activeSpinner.error(error)
+    throw caughtError
+  }
+}
+
+/**
+ * @param {{
+ *   fileCount: number
+ *   missingReferences: MissingReference[]
+ *   orphanedFiles: string[]
+ *   referenceCount: number
+ * }} result
+ */
+function formatContentCheckSummary(result) {
+  const issues = [
+    formatFindingCount(result.missingReferences.length, "missing reference"),
+    formatFindingCount(result.orphanedFiles.length, "orphaned file"),
+  ]
+
+  if (result.referenceCount === 0 && result.fileCount === 0) {
+    return `Content files: none found.`
+  }
+
+  return `Content files: ${formatCount(result.referenceCount, "reference")}, ${formatCount(result.fileCount, "file")}; ${issues.join(", ")}.`
+}
+
+/**
+ * @param {{
+ *   fileCount: number
+ *   orphanedCategoryThumbnails: string[]
+ *   orphanedMediaThumbnails: string[]
+ *   referenceCount: number
+ * }} result
+ */
+function formatThumbnailCheckSummary(result) {
+  const orphanedThumbnails =
+    result.orphanedMediaThumbnails.length +
+    result.orphanedCategoryThumbnails.length
+
+  return `Thumbnails: ${formatCount(result.referenceCount, "reference")}, ${formatCount(result.fileCount, "file")}; orphaned: ${orphanedThumbnails} (${result.orphanedMediaThumbnails.length} media, ${result.orphanedCategoryThumbnails.length} categories).`
+}
+
+/**
+ * @param {number} count
+ * @param {string} singular
+ */
+function formatFindingCount(count, singular) {
+  if (count === 0) {
+    return `no ${singular}s`
+  }
+  return formatCount(count, singular)
+}
+
+/**
+ * @param {number} count
+ * @param {string} singular
+ */
+function formatCount(count, singular) {
+  return `${count} ${singular}${count === 1 ? "" : "s"}`
+}
+
+/**
+ * @param {string} action
+ * @param {number} count
+ */
+function formatDeletionProgress(action, count) {
+  return `${action} ${count} orphaned file${count === 1 ? "" : "s"}.`
+}
+
 /**
  * @param {string|undefined} rawScope
  */
@@ -369,39 +560,57 @@ async function validateThumbnails(
       .filter((value) => value !== undefined),
   )
 
-  const initializedMediaStorage = await mediaThumbnailStorage.init()
-  const initializedCategoryStorage = await categoryThumbnailStorage.init()
-  const mediaFiles = await initializedMediaStorage.list()
-  const categoryFiles = await initializedCategoryStorage.list()
+  const [initializedMediaStorage, initializedCategoryStorage] =
+    await Promise.all([
+      mediaThumbnailStorage.init(),
+      categoryThumbnailStorage.init(),
+    ])
+  const [mediaFiles, categoryFiles] = await Promise.all([
+    initializedMediaStorage.list(),
+    initializedCategoryStorage.list(),
+  ])
 
   return {
+    fileCount: mediaFiles.length + categoryFiles.length,
     orphanedMediaThumbnails: mediaFiles.filter(
       (file) => !mediaReferences.has(file),
     ),
     orphanedCategoryThumbnails: categoryFiles.filter(
       (file) => !categoryReferences.has(file),
     ),
+    referenceCount: mediaReferences.size + categoryReferences.size,
   }
 }
 
 /**
  * @param {{
+ *   includeLinkReferences?: boolean
  *   mediaItems: MediaItem[]
  *   storage: FileStorage
  * }} args
  */
-async function validateContentFiles({ mediaItems, storage }) {
+async function validateContentFiles({
+  includeLinkReferences = false,
+  mediaItems,
+  storage,
+}) {
   const initializedStorage = await storage.init()
-  const references = collectContentReferences(mediaItems, initializedStorage)
+  const { references, wrongTypeReferences } = collectContentReferences(
+    mediaItems,
+    initializedStorage,
+    { includeLinkReferences },
+  )
+  const files = await initializedStorage.list()
   if (references.size === 0) {
     return {
+      fileCount: files.length,
       missingReferences: /** @type {MissingReference[]} */ ([]),
       orphanedFiles: /** @type {string[]} */ ([]),
       referenceCount: 0,
+      wrongTypeReferences: /** @type {WrongTypeReference[]} */ ([]),
     }
   }
 
-  const files = await initializedStorage.list()
   const fileSet = new Set(files)
 
   const missingReferences = [...references.entries()]
@@ -416,41 +625,75 @@ async function validateContentFiles({ mediaItems, storage }) {
     .filter((filePath) => !references.has(filePath))
     .sort()
 
+  const existingWrongTypeReferences = [...wrongTypeReferences.entries()]
+    .filter(([path]) => fileSet.has(path))
+    .map(([, reference]) => ({
+      path: reference.displayPath,
+      sources: [...reference.sources].toSorted(),
+    }))
+    .sort((a, b) => a.path.localeCompare(b.path))
+
   return {
+    fileCount: files.length,
     missingReferences,
     orphanedFiles,
     referenceCount: references.size,
+    wrongTypeReferences: existingWrongTypeReferences,
   }
 }
 
 /**
  * @param {MediaItem[]} mediaItems
  * @param {FileStorage} storage
+ * @param {{includeLinkReferences:boolean}} options
  */
-function collectContentReferences(mediaItems, storage) {
+function collectContentReferences(mediaItems, storage, options) {
   const references = new Map()
+  const wrongTypeReferences = new Map()
   for (const item of mediaItems) {
     const sourceFileName = posix.basename(toPosixPath(item.path))
     for (const contentItem of item.content) {
-      if (contentItem.type !== "upload") {
+      const isLinkReference = contentItem.type === "link"
+      if (
+        contentItem.type !== "upload" &&
+        !(options.includeLinkReferences && isLinkReference)
+      ) {
         continue
       }
       const filePath = storage.toPath(contentItem.url)
       if (!filePath) {
         continue
       }
-      const current = references.get(filePath)
-      if (current) {
-        current.sources.add(sourceFileName)
-      } else {
-        references.set(filePath, {
-          displayPath: contentItem.url,
-          sources: new Set([sourceFileName]),
-        })
+      addFileReference(references, filePath, contentItem.url, sourceFileName)
+      if (isLinkReference) {
+        addFileReference(
+          wrongTypeReferences,
+          filePath,
+          contentItem.url,
+          sourceFileName,
+        )
       }
     }
   }
-  return references
+  return { references, wrongTypeReferences }
+}
+
+/**
+ * @param {Map<string, FileReference>} references
+ * @param {string} filePath
+ * @param {string} displayPath
+ * @param {string} sourceFileName
+ */
+function addFileReference(references, filePath, displayPath, sourceFileName) {
+  const current = references.get(filePath)
+  if (current) {
+    current.sources.add(sourceFileName)
+    return
+  }
+  references.set(filePath, {
+    displayPath,
+    sources: new Set([sourceFileName]),
+  })
 }
 
 /**
@@ -512,7 +755,10 @@ function toPosixPath(filePath) {
  */
 async function defaultPromptText(message) {
   const answer = await text({ message })
-  return isCancel(answer) ? "" : String(answer)
+  if (isCancel(answer)) {
+    cancelPrompt()
+  }
+  return String(answer)
 }
 
 /**
@@ -523,5 +769,8 @@ async function defaultPromptConfirm(message) {
     message,
     initialValue: false,
   })
-  return isCancel(answer) ? false : answer
+  if (isCancel(answer)) {
+    cancelPrompt()
+  }
+  return answer
 }

package/src/check-links.js

@@ -3,7 +3,7 @@
 import { posix, resolve } from "node:path"
 import { cwd as processCwd, stdin, stdout } from "node:process"
 
-import { intro, isCancel, log, outro, text } from "@clack/prompts"
+import { intro, isCancel, log, outro, progress, text } from "@clack/prompts"
 
 import {
   cliConfigFileName,
@@ -13,6 +13,7 @@ import {
 import { CliError } from "./support/cli-error.js"
 import { contentCollections } from "./support/content-collections.js"
 import { pathExists } from "./support/filesystem.js"
+import { cancelPrompt } from "./support/prompt-cancel.js"
 
 const mediaDir = "src/content/media"
 const defaultConcurrency = 24
@@ -96,12 +97,10 @@ export async function checkLinks(options, runtime = {}) {
     return true
   }
 
-  const results = await mapConcurrent(
-    references,
-    defaultConcurrency,
-    (reference) =>
-      checkLink(reference.resolvedUrl, { fetch: runFetch, timeoutMs }),
-  )
+  const results = await checkReferencesWithProgress(references, {
+    fetch: runFetch,
+    timeoutMs,
+  })
   const checkedLinks = references
     .map((reference, index) => ({ reference, result: results[index] }))
     .sort((a, b) =>
@@ -128,11 +127,7 @@ export async function checkLinks(options, runtime = {}) {
   log.error(`Unavailable links (${unavailableLinks.length})`)
   for (const { reference, result } of unavailableLinks) {
     log.message(
-      `· ${reference.displayUrl} (${formatFailure(result)}, referenced by ${[
-        ...reference.sources,
-      ]
-        .toSorted()
-        .join(", ")})`,
+      `• ${reference.displayUrl}\n  Result: ${formatFailure(result)}\n${formatReferenceSources(reference.sources)}`,
     )
   }
 
@@ -141,6 +136,46 @@ export async function checkLinks(options, runtime = {}) {
   return false
 }
 
+/**
+ * @param {LinkReference[]} references
+ * @param {{fetch: typeof fetch, timeoutMs: number}} options
+ */
+async function checkReferencesWithProgress(references, options) {
+  const linkProgress = progress({ max: references.length })
+  let completed = 0
+  linkProgress.start(`Checking links (0/${references.length})`)
+
+  try {
+    const results = await mapConcurrent(
+      references,
+      defaultConcurrency,
+      async (reference) => {
+        const result = await checkLink(reference.resolvedUrl, options)
+        completed += 1
+        linkProgress.advance(
+          1,
+          `Checking links (${completed}/${references.length})`,
+        )
+        return result
+      },
+    )
+    const protectedCount = results.filter((result) =>
+      isProtectedLink(result),
+    ).length
+    const unavailableCount = results.filter(
+      (result) => !result.ok && !isProtectedLink(result),
+    ).length
+    const availableCount = results.length - protectedCount - unavailableCount
+    linkProgress.stop(
+      `Checked links: ${availableCount} available, ${protectedCount} protected, ${unavailableCount} unavailable.`,
+    )
+    return results
+  } catch (error) {
+    linkProgress.error("Link check failed.")
+    throw error
+  }
+}
+
 /**
  * @param {{
  *   cwd: string
@@ -294,15 +329,25 @@ function printProtectedLinks(links) {
   log.warn(`Protected or forbidden links (${links.length})`)
   for (const { reference, result } of links) {
     log.message(
-      `· ${reference.displayUrl} (${formatFailure(result)}, referenced by ${[
-        ...reference.sources,
-      ]
-        .toSorted()
-        .join(", ")})`,
+      `• ${reference.displayUrl}\n  Result: ${formatFailure(result)}\n${formatReferenceSources(reference.sources)}`,
     )
   }
 }
 
+/**
+ * @param {Set<string>} sources
+ */
+function formatReferenceSources(sources) {
+  const sortedSources = [...sources].toSorted()
+  if (sortedSources.length === 1) {
+    return `  Referenced by: ${sortedSources[0]}`
+  }
+  return [
+    "  Referenced by:",
+    ...sortedSources.map((source) => `  - ${source}`),
+  ].join("\n")
+}
+
 /**
  * @param {string} url
  * @param {{
@@ -445,7 +490,10 @@ function toPosixPath(filePath) {
  */
 async function defaultPromptText(message) {
   const answer = await text({ message })
-  return isCancel(answer) ? "" : String(answer)
+  if (isCancel(answer)) {
+    cancelPrompt()
+  }
+  return String(answer)
 }
 
 /**

package/src/check-translations.js

@@ -5,7 +5,9 @@ import { readFile } from "node:fs/promises"
 import { resolve } from "node:path"
 import { cwd } from "node:process"
 
-import { confirm, intro, log, outro, taskLog } from "@clack/prompts"
+import { confirm, intro, isCancel, log, outro, taskLog } from "@clack/prompts"
+
+import { cancelPrompt } from "./support/prompt-cancel.js"
 
 /**
  * @typedef {{
@@ -100,13 +102,7 @@ export async function checkTranslations(options = {}) {
  * @returns
  */
 async function runBuild(build) {
-  const shouldRunBuild =
-    build ??
-    (await confirm({
-      message:
-        "Run pnpm build now? Command requires an up-to-date dist/ directory.",
-      initialValue: false,
-    }))
+  const shouldRunBuild = build ?? (await promptRunBuild())
   if (!shouldRunBuild) {
     return true
   }
@@ -158,6 +154,18 @@ async function runBuild(build) {
   }
 }
 
+async function promptRunBuild() {
+  const answer = await confirm({
+    message:
+      "Run pnpm build now? Command requires an up-to-date dist/ directory.",
+    initialValue: false,
+  })
+  if (isCancel(answer)) {
+    cancelPrompt()
+  }
+  return answer
+}
+
 /**
  *
  * @param {{title:string, action:string}} source

package/src/index.js

@@ -8,6 +8,7 @@ import { checkFiles } from "./check-files.js"
 import { checkLinks } from "./check-links.js"
 import { checkTranslations } from "./check-translations.js"
 import { CliError } from "./support/cli-error.js"
+import { PromptCancelled } from "./support/prompt-cancel.js"
 const { version } = pkg
 
 const program = new Command()
@@ -24,8 +25,12 @@ program
   .option("--build", "run pnpm build before checking translations")
   .option("--no-build", "skip the build prompt and use the latest dist/ output")
   .action(async (options) => {
-    const checkSuccessful = await checkTranslations(options)
-    commandExitCode = checkSuccessful ? 0 : 1
+    try {
+      const checkSuccessful = await checkTranslations(options)
+      commandExitCode = checkSuccessful ? 0 : 1
+    } catch (error) {
+      handleCommandError(error)
+    }
   })
 
 program
@@ -34,7 +39,7 @@ program
     "check for missing and orphaned content files and thumbnails in a LightNet site",
   )
   .option("--fix", "remove orphaned files")
-  .option("--no-confirm", "skip deletion confirmation when used with --fix")
+  .option("--fix-without-confirm", "remove orphaned files without confirmation")
   .option(
     "--r2",
     "validate remote content files in Cloudflare R2 instead of public/files",
@@ -48,12 +53,7 @@ program
       const checkSuccessful = await checkFiles(options)
       commandExitCode = checkSuccessful ? 0 : 1
     } catch (error) {
-      if (error instanceof CliError) {
-        console.error(error.message)
-        commandExitCode = 1
-        return
-      }
-      throw error
+      handleCommandError(error)
     }
   })
 
@@ -66,14 +66,25 @@ program
       const checkSuccessful = await checkLinks(options)
       commandExitCode = checkSuccessful ? 0 : 1
     } catch (error) {
-      if (error instanceof CliError) {
-        console.error(error.message)
-        commandExitCode = 1
-        return
-      }
-      throw error
+      handleCommandError(error)
     }
   })
 
 await program.parseAsync()
 process.exitCode = commandExitCode
+
+/**
+ * @param {unknown} error
+ */
+function handleCommandError(error) {
+  if (error instanceof PromptCancelled) {
+    commandExitCode = 0
+    return
+  }
+  if (error instanceof CliError) {
+    console.error(error.message)
+    commandExitCode = 1
+    return
+  }
+  throw error
+}

package/src/support/filesystem.js

@@ -58,23 +58,24 @@ export function files(cwd, options) {
      * @param {string[]} paths
      */
     async delete(paths) {
-      /** @type {string[]} */
-      const removed = []
-      for (const path of paths) {
-        try {
-          await unlink(
-            resolve(
-              cwd,
-              options.toAbsolutePath?.(path) ??
-                toLocalFilePath(options.rootDir, path),
-            ),
-          )
-          removed.push(path)
-        } catch {
-          // The caller prints per-file failures based on the returned paths.
-        }
-      }
-      return removed
+      const removals = await Promise.all(
+        paths.map(async (path) => {
+          try {
+            await unlink(
+              resolve(
+                cwd,
+                options.toAbsolutePath?.(path) ??
+                  toLocalFilePath(options.rootDir, path),
+              ),
+            )
+            return path
+          } catch {
+            // The caller prints per-file failures based on the returned paths.
+            return undefined
+          }
+        }),
+      )
+      return removals.filter((path) => path !== undefined)
     },
     /**
      * @param {string} url
@@ -161,13 +162,17 @@ async function walkFiles(dirPath) {
   /** @type {string[]} */
   const files = []
   const entries = await readdir(dirPath, { withFileTypes: true })
-  for (const entry of entries) {
-    const entryPath = join(dirPath, entry.name)
-    if (entry.isDirectory()) {
-      files.push(...(await walkFiles(entryPath)))
-    } else if (entry.isFile()) {
-      files.push(entryPath)
-    }
+  const nestedFiles = await Promise.all(
+    entries.map(async (entry) => {
+      const entryPath = join(dirPath, entry.name)
+      if (entry.isDirectory()) {
+        return walkFiles(entryPath)
+      }
+      return entry.isFile() ? [entryPath] : []
+    }),
+  )
+  for (const item of nestedFiles) {
+    files.push(...item)
   }
   return files
 }

package/src/support/prompt-cancel.js

@@ -0,0 +1,13 @@
+// @ts-check
+
+import { cancel } from "@clack/prompts"
+
+export class PromptCancelled extends Error {}
+
+/**
+ * @returns {never}
+ */
+export function cancelPrompt() {
+  cancel("Operation cancelled.")
+  throw new PromptCancelled()
+}

package/src/support/r2.js

@@ -1,6 +1,9 @@
 // @ts-check
 
 import { execFile } from "node:child_process"
+import { mkdtemp, rm, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
 import { env as processEnv } from "node:process"
 import { promisify } from "node:util"
 
@@ -12,9 +15,11 @@ import {
   writeCliConfig,
 } from "./cli-config.js"
 import { CliError } from "./cli-error.js"
+import { cancelPrompt } from "./prompt-cancel.js"
 
 const execFileAsync = promisify(execFile)
 const sessionSecretEnvName = "LIGHTNET_R2_SECRET_ACCESS_KEY"
+const r2DeleteBatchSize = 1000
 
 /**
  * @typedef {{
@@ -117,18 +122,16 @@ export function createR2FileStorage({
   const storage = {
     async init() {
       await getConfig()
+      await getSecretAccessKey()
       return storage
     },
     async list() {
       return runWithRefresh(async (config) => {
-        const secretAccessKey = await getSecretAccessKey()
-        const sharedArgs = {
+        const bucketObjects = await listR2Objects({
           cwd,
           config,
-          secretAccessKey,
-        }
-        await assertR2Access(sharedArgs)
-        const bucketObjects = await listR2Objects(sharedArgs)
+          secretAccessKey: await getSecretAccessKey(),
+        })
         return bucketObjects.map((item) => item.key).sort()
       })
     },
@@ -138,22 +141,12 @@ export function createR2FileStorage({
     async delete(paths) {
       const r2Config = await getConfig()
       const secretAccessKey = await getSecretAccessKey()
-      /** @type {string[]} */
-      const removed = []
-      for (const path of paths) {
-        try {
-          await runConfiguredRclone({
-            args: ["deletefile", makeR2Path(r2Config, path)],
-            cwd,
-            config: r2Config,
-            secretAccessKey,
-          })
-          removed.push(path)
-        } catch {
-          // The caller prints per-file failures based on the returned paths.
-        }
-      }
-      return removed
+      return deleteR2Objects({
+        config: r2Config,
+        cwd,
+        paths,
+        secretAccessKey,
+      })
     },
     /**
      * @param {string} url
@@ -167,32 +160,134 @@ export function createR2FileStorage({
         return undefined
       }
       const path = url.slice(normalizedBase.length).replace(/^\/+/, "")
-      return path || undefined
+      return decodeR2ObjectPath(path) || undefined
     },
   }
   return storage
 }
 
+/**
+ * @param {string} path
+ */
+function decodeR2ObjectPath(path) {
+  try {
+    return decodeURIComponent(path)
+  } catch {
+    return path
+  }
+}
+
 /**
  * @param {{
+ *   config: R2Config
  *   cwd: string
+ *   paths: string[]
+ *   secretAccessKey: string
+ * }} args
+ */
+async function deleteR2Objects({ config, cwd, paths, secretAccessKey }) {
+  /** @type {string[]} */
+  const removed = []
+  const batchablePaths = paths.filter((path) => !path.includes("\n"))
+  const singleDeletePaths = paths.filter((path) => path.includes("\n"))
+
+  for (
+    let index = 0;
+    index < batchablePaths.length;
+    index += r2DeleteBatchSize
+  ) {
+    const batch = batchablePaths.slice(index, index + r2DeleteBatchSize)
+    try {
+      await deleteR2ObjectBatch({ config, cwd, paths: batch, secretAccessKey })
+      removed.push(...batch)
+    } catch {
+      removed.push(
+        ...(await deleteR2ObjectsIndividually({
+          config,
+          cwd,
+          paths: batch,
+          secretAccessKey,
+        })),
+      )
+    }
+  }
+
+  removed.push(
+    ...(await deleteR2ObjectsIndividually({
+      config,
+      cwd,
+      paths: singleDeletePaths,
+      secretAccessKey,
+    })),
+  )
+
+  return removed
+}
+
+/**
+ * @param {{
  *   config: R2Config
+ *   cwd: string
+ *   paths: string[]
  *   secretAccessKey: string
  * }} args
  */
-async function assertR2Access(args) {
+async function deleteR2ObjectBatch({ config, cwd, paths, secretAccessKey }) {
+  if (paths.length === 0) {
+    return
+  }
+
+  const tempDir = await mkdtemp(join(tmpdir(), "lightnet-r2-delete-"))
+  const fileListPath = join(tempDir, "files.txt")
   try {
+    await writeFile(fileListPath, `${paths.join("\n")}\n`, "utf8")
     await runConfiguredRclone({
-      args: ["lsjson", makeR2Path(args.config), "--files-only"],
-      ...args,
+      args: [
+        "delete",
+        makeR2Path(config),
+        "--files-from-raw",
+        fileListPath,
+        "--fast-list",
+      ],
+      cwd,
+      config,
+      secretAccessKey,
     })
-  } catch (error) {
-    throw new CliError(
-      error instanceof Error
-        ? `Unable to access R2 bucket "${args.config.bucket}": ${error.message}`
-        : `Unable to access R2 bucket "${args.config.bucket}".`,
-    )
+  } finally {
+    await rm(tempDir, { force: true, recursive: true })
+  }
+}
+
+/**
+ * @param {{
+ *   config: R2Config
+ *   cwd: string
+ *   paths: string[]
+ *   secretAccessKey: string
+ * }} args
+ */
+async function deleteR2ObjectsIndividually({
+  config,
+  cwd,
+  paths,
+  secretAccessKey,
+}) {
+  /** @type {string[]} */
+  const removed = []
+  for (const path of paths) {
+    try {
+      await runConfiguredRclone({
+        args: ["deletefile", makeR2Path(config, path)],
+        cwd,
+        config,
+        secretAccessKey,
+      })
+      removed.push(path)
+    } catch {
+      // The caller prints per-file failures based on the returned paths.
+    }
   }
+  return removed
 }
 
 /**
@@ -203,18 +298,28 @@ async function assertR2Access(args) {
  * }} args
  */
 async function listR2Objects(args) {
-  const { stdout: listJson } = await runConfiguredRclone({
-    args: [
-      "lsjson",
-      makeR2Path(args.config),
-      "--recursive",
-      "--files-only",
-      "--fast-list",
-      "--no-mimetype",
-      "--no-modtime",
-    ],
-    ...args,
-  })
+  let listJson
+  try {
+    const result = await runConfiguredRclone({
+      args: [
+        "lsjson",
+        makeR2Path(args.config),
+        "--recursive",
+        "--files-only",
+        "--fast-list",
+        "--no-mimetype",
+        "--no-modtime",
+      ],
+      ...args,
+    })
+    listJson = result.stdout
+  } catch (error) {
+    throw new CliError(
+      error instanceof Error
+        ? `Unable to access R2 bucket "${args.config.bucket}": ${error.message}`
+        : `Unable to access R2 bucket "${args.config.bucket}".`,
+    )
+  }
 
   let parsed
   try {
@@ -308,7 +413,7 @@ async function promptRequiredSecret() {
       message: "R2 secretAccessKey:",
     })
     if (isCancel(value)) {
-      throw new CliError("Secret access key prompt cancelled.")
+      cancelPrompt()
     }
     if (value.trim()) {
       processEnv[sessionSecretEnvName] = value