@lightnet/cli 4.6.2 → 4.7.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @lightnet/cli
 
+## 4.7.1
+
+### Patch Changes
+
+- [#447](https://github.com/LightNetDev/LightNet/pull/447) [`0d8fece`](https://github.com/LightNetDev/LightNet/commit/0d8fece3527a67a21c6272b422c62152948b32a1) - Only prompt for `lightnet r2 cp` and `lightnet r2 mv` when files would actually be overwritten, and list the destination files before confirmation.
+
+## 4.7.0
+
+### Minor Changes
+
+- [#445](https://github.com/LightNetDev/LightNet/pull/445) [`53b6a0d`](https://github.com/LightNetDev/LightNet/commit/53b6a0db8d9e6dca38c808d925007cb2ae343076) - Add a `--progress` option to `lightnet r2 cp`, `lightnet r2 mv`, and `lightnet r2 rm`.
+
+- [#445](https://github.com/LightNetDev/LightNet/pull/445) [`53b6a0d`](https://github.com/LightNetDev/LightNet/commit/53b6a0db8d9e6dca38c808d925007cb2ae343076) - Update `lightnet r2 cp` to follow Unix-style copy semantics for files and directories.
+
+- [#445](https://github.com/LightNetDev/LightNet/pull/445) [`53b6a0d`](https://github.com/LightNetDev/LightNet/commit/53b6a0db8d9e6dca38c808d925007cb2ae343076) - Update `lightnet r2 mv` to use safer Unix-like move semantics inside the configured R2 bucket.
+
+- [#445](https://github.com/LightNetDev/LightNet/pull/445) [`53b6a0d`](https://github.com/LightNetDev/LightNet/commit/53b6a0db8d9e6dca38c808d925007cb2ae343076) - Update `lightnet r2 rm` to follow safer Unix-like delete semantics inside the configured R2 bucket.
+
 ## 4.6.2
 
 ### Patch Changes

package/package.json

@@ -3,7 +3,7 @@
   "description": "CLI for managing LightNet projects",
   "type": "module",
   "license": "MIT",
-  "version": "4.6.2",
+  "version": "4.7.1",
   "publishConfig": {
     "access": "public"
   },
@@ -28,7 +28,13 @@
     "@clack/prompts": "^1.7.0",
     "commander": "^15.0.0"
   },
+  "devDependencies": {
+    "vitest": "^4.1.9"
+  },
   "engines": {
     "node": ">=22"
+  },
+  "scripts": {
+    "test": "vitest"
   }
 }

package/src/index.js

@@ -92,16 +92,20 @@ r2Command
   .description(
     'delete an R2 file; use -r to delete a directory/prefix or "/" to clean the bucket',
   )
-  .argument("<path>", 'R2 file path, directory/prefix with -r, or "/" with -r')
+  .argument(
+    "<paths...>",
+    'R2 file path(s), directory/prefix paths with -r, or "/" with -r',
+  )
   .option("-r, --recursive", "delete a directory/prefix recursively")
+  .option("--progress", "show operation progress")
   .option(
     "-f, --force",
     'delete without confirmation; use "--force" to clean the bucket root without confirmation',
   )
-  .action(async (path, options) => {
+  .action(async (paths, options) => {
     try {
       options.longForce = hasLongForceFlag()
-      await removeR2(path, options)
+      await removeR2(paths, options)
     } catch (error) {
       handleCommandError(error)
     }
@@ -112,16 +116,20 @@ r2Command
   .description(
     'copy files between R2 and local paths, or inside R2; prefix R2 paths with "r2:"',
   )
-  .argument("<source>", 'source path; use "r2:<path>" for R2')
-  .argument("<destination>", 'destination path; use "r2:<path>" for R2')
-  .option(
-    "-f, --force",
-    'overwrite without confirmation; use "--force" to replace the bucket root without confirmation',
+  .argument(
+    "<paths...>",
+    'source path(s) followed by a destination path; use "r2:<path>" for R2',
   )
-  .action(async (source, destination, options) => {
+  .option("-r, --recursive", "copy directories recursively")
+  .option("-R", "copy directories recursively")
+  .option("-a, --archive", "copy directories recursively")
+  .option("-f, --force", "overwrite existing files without confirmation")
+  .option("-n, --no-clobber", "skip existing destination files")
+  .option("--progress", "show operation progress")
+  .action(async (paths, options) => {
     try {
-      options.longForce = hasLongForceFlag()
-      await copyR2(source, destination, options)
+      options.recursive = options.recursive || options.R || options.archive
+      await copyR2(paths, options)
     } catch (error) {
       handleCommandError(error)
     }
@@ -130,12 +138,13 @@ r2Command
 r2Command
   .command("mv")
   .description("move or rename an R2 file or directory/prefix")
-  .argument("<source>", "R2 source path")
-  .argument("<destination>", "R2 destination path")
+  .argument("<paths...>", "R2 source path(s) followed by a destination path")
   .option("-f, --force", "overwrite existing destination without confirmation")
-  .action(async (source, destination, options) => {
+  .option("-n, --no-clobber", "skip existing destination files")
+  .option("--progress", "show operation progress")
+  .action(async (paths, options) => {
     try {
-      await moveR2(source, destination, options)
+      await moveR2(paths, options)
     } catch (error) {
       handleCommandError(error)
     }

package/src/r2.js

@@ -1,6 +1,6 @@
 // @ts-check
 
-import { rm, stat } from "node:fs/promises"
+import { readdir, stat } from "node:fs/promises"
 import { basename, join, posix, resolve } from "node:path"
 import {
   cwd as processCwd,
@@ -9,7 +9,15 @@ import {
   stdout,
 } from "node:process"
 
-import { confirm, intro, isCancel, log, outro, text } from "@clack/prompts"
+import {
+  confirm,
+  intro,
+  isCancel,
+  log,
+  outro,
+  progress,
+  text,
+} from "@clack/prompts"
 
 import { CliError } from "./support/cli-error.js"
 import { cancelPrompt } from "./support/prompt-cancel.js"
@@ -31,13 +39,17 @@ const defaultRcloneOptions = {
 /**
  * @typedef {{
  *   force?: boolean
- *   longForce?: boolean
+ *   noClobber?: boolean
+ *   progress?: boolean
+ *   recursive?: boolean
  * }} R2CopyOptions
  */
 
 /**
  * @typedef {{
  *   force?: boolean
+ *   noClobber?: boolean
+ *   progress?: boolean
  * }} R2MoveOptions
  */
 
@@ -55,6 +67,7 @@ const defaultRcloneOptions = {
  *   force?: boolean
  *   recursive?: boolean
  *   longForce?: boolean
+ *   progress?: boolean
  * }} R2RemoveOptions
  */
 
@@ -65,6 +78,7 @@ const defaultRcloneOptions = {
  *   isInteractive?: boolean
  *   promptConfirm?: (message: string) => Promise<boolean>
  *   promptText?: (message: string) => Promise<string>
+ *   createR2Client?: typeof createR2Client
  *   writeStdout?: (message: string) => void
  * }} R2Runtime
  */
@@ -85,297 +99,378 @@ export async function listR2(path, runtime = {}) {
 }
 
 /**
- * @param {string} path
+ * @param {string|string[]} paths
  * @param {R2RemoveOptions} options
  * @param {R2Runtime} [runtime]
  */
-export async function removeR2(path, options, runtime = {}) {
+export async function removeR2(paths, options, runtime = {}) {
   intro("r2 rm")
-  const r2Path = normalizeR2Path(path)
-  const isBucketRoot = isR2BucketRootPath(path)
-  if (isBucketRoot && !options.recursive) {
+  const removePaths = Array.isArray(paths) ? paths : [paths]
+  const rootPaths = removePaths.filter((path) => isR2BucketRootPath(path))
+  const hasBucketRoot = rootPaths.length > 0
+  if (removePaths.length === 0) {
+    throw new CliError("R2 deletion requires at least one path.")
+  }
+  if (hasBucketRoot && removePaths.length > 1) {
+    throw new CliError(
+      "Refusing to delete the R2 bucket root with other paths.",
+    )
+  }
+  if (hasBucketRoot && !options.recursive) {
     throw new CliError(
       'Refusing to delete the R2 bucket root without "--recursive".',
     )
   }
-  if (!r2Path && !isBucketRoot) {
-    throw new CliError("Refusing to delete the R2 bucket root.")
+
+  const r2Paths = removePaths.map((path) => normalizeR2Path(path))
+  for (const [index, r2Path] of r2Paths.entries()) {
+    if (!r2Path && !isR2BucketRootPath(removePaths[index])) {
+      throw new CliError("Refusing to delete the R2 bucket root.")
+    }
   }
 
   const interactive = getInteractive(runtime)
-  if (isBucketRoot && options.force && !options.longForce && !interactive) {
+  if (hasBucketRoot && options.force && !options.longForce && !interactive) {
     throw new CliError(
       'Ignoring "-f" for R2 bucket-root cleanup. If you are sure you want to delete the entire R2 bucket, use "--force".',
     )
   }
-  if (isBucketRoot && !interactive && !options.longForce) {
+  if (hasBucketRoot && !interactive && !options.longForce) {
     throw new CliError(
       'Cleaning the R2 bucket root requires interactive confirmation. If you are sure you want to delete the entire R2 bucket, use "--force".',
     )
   }
-  if (isBucketRoot && options.force && !options.longForce) {
+  if (hasBucketRoot && options.force && !options.longForce) {
     log.warn(
       'Ignoring "-f" for R2 bucket-root cleanup. Use "--force" if you are sure you want to delete the entire R2 bucket.',
     )
   }
-  if (!options.force && !interactive) {
-    throw new CliError(
-      'R2 deletion requires confirmation. Re-run with "--force" in non-interactive environments.',
+  if (hasBucketRoot) {
+    log.warn(
+      "This will delete ALL files in the configured R2 bucket. This cannot be undone.",
     )
   }
 
-  if (isBucketRoot) {
-    log.warn(
-      "This will delete ALL files in the configured R2 bucket. This cannot be undone.",
+  const client = createR2CommandClient(runtime)
+  const targets = []
+  for (const [index, r2Path] of r2Paths.entries()) {
+    const originalPath = removePaths[index]
+    const isBucketRoot = isR2BucketRootPath(originalPath)
+    const pathType = isBucketRoot
+      ? "directory"
+      : await getCopyPathType({ remote: true, path: r2Path }, client, runtime)
+
+    if (pathType === "missing") {
+      if (options.force) {
+        continue
+      }
+      throw new CliError(`R2 path "${r2Path}" does not exist.`)
+    }
+    if (pathType === "directory" && !options.recursive) {
+      throw new CliError(
+        `R2 path "${r2Path}" is a directory. Re-run with "--recursive" to delete directories.`,
+      )
+    }
+    targets.push({
+      isBucketRoot,
+      path: r2Path,
+      recursive: pathType === "directory",
+    })
+  }
+
+  if (targets.length > 0 && !options.force && !interactive) {
+    throw new CliError(
+      'R2 deletion requires confirmation. Re-run with "--force" in non-interactive environments.',
     )
   }
 
-  const shouldDelete = isBucketRoot
-    ? options.longForce ||
-      (await getPromptConfirm(runtime)(
-        "Delete all files in the R2 bucket? [y/N] ",
-      ))
-    : options.force ||
-      (await getPromptConfirm(runtime)(`Delete R2 path "${r2Path}"? [y/N] `))
+  for (const target of targets) {
+    const shouldDelete = target.isBucketRoot
+      ? options.longForce ||
+        (await getPromptConfirm(runtime)(
+          "Delete all files in the R2 bucket? [y/N] ",
+        ))
+      : options.force ||
+        (await getPromptConfirm(runtime)(
+          `Delete R2 path "${target.path}"? [y/N] `,
+        ))
 
-  if (!shouldDelete) {
-    cancelPrompt()
+    if (!shouldDelete) {
+      cancelPrompt()
+    }
   }
 
-  const client = createR2CommandClient(runtime)
-  await client.remove(r2Path, {
-    recursive: options.recursive === true,
-    rcloneOptions:
-      options.recursive === true ? defaultRcloneOptions : undefined,
+  const removeProgress = createR2Progress({
+    enabled: options.progress === true && targets.length > 0,
+    label: "Deleting R2 paths",
+    max: targets.length,
+    success: "R2 delete complete.",
   })
+  try {
+    for (const target of targets) {
+      await client.remove(target.path, {
+        recursive: target.recursive,
+        rcloneOptions: target.recursive ? defaultRcloneOptions : undefined,
+      })
+      removeProgress.advance()
+    }
+    removeProgress.stop()
+  } catch (error) {
+    removeProgress.error("R2 delete failed.")
+    throw error
+  }
   outro("R2 delete complete.")
 }
 
 /**
- * @param {string} source
- * @param {string} destination
+ * @param {string|string[]} paths
  * @param {R2CopyOptions} [options]
  * @param {R2Runtime} [runtime]
  */
-export async function copyR2(source, destination, options = {}, runtime = {}) {
+export async function copyR2(paths, options = {}, runtime = {}) {
   intro("r2 cp")
-  const sourcePath = parseCopyPath(source)
+  const { sources, destination } = parseCopyArguments(paths)
+  if (options.force && options.noClobber) {
+    throw new CliError('Cannot use "--force" with "--no-clobber".')
+  }
+  const sourcePaths = sources.map((source) => parseCopyPath(source))
   const destinationPath = parseCopyPath(destination)
-  if (!sourcePath.remote && !destinationPath.remote) {
+  if (
+    !destinationPath.remote &&
+    sourcePaths.every((sourcePath) => !sourcePath.remote)
+  ) {
     throw new CliError(
       `R2 copy requires at least one R2 path. Prefix R2 paths with "${remotePathPrefix}".`,
     )
   }
 
   const client = createR2CommandClient(runtime)
-  const sourceType = await getCopyPathType(sourcePath, client, runtime)
-  if (sourceType === "missing") {
-    throw new CliError(`Copy source "${source}" does not exist.`)
-  }
-
   const destinationType = await getCopyPathType(
     destinationPath,
     client,
     runtime,
   )
-  const targetPath = getCopyTargetPath({
-    destination: destinationPath,
-    destinationType,
-    runtime,
-    source: sourcePath,
-    sourceType,
-  })
-  const targetType = await getCopyPathType(targetPath, client, runtime)
-  const shouldUseCopyTo =
-    sourceType === "file" &&
-    (targetType !== "directory" || isDirectoryLikeCopyPath(destinationPath))
+  if (
+    sourcePaths.length > 1 &&
+    destinationType !== "directory" &&
+    !isDirectoryLikeCopyPath(destinationPath)
+  ) {
+    throw new CliError(
+      "Copying multiple sources requires a directory destination.",
+    )
+  }
+
+  const operations = []
+  for (const [index, sourcePath] of sourcePaths.entries()) {
+    const source = sources[index]
+    const sourceType = await getCopyPathType(sourcePath, client, runtime)
+    if (sourceType === "missing") {
+      throw new CliError(`Copy source "${source}" does not exist.`)
+    }
+    if (sourceType === "directory" && !options.recursive) {
+      throw new CliError(
+        `Copy source "${source}" is a directory. Re-run with "--recursive" to copy directories.`,
+      )
+    }
+
+    const targetPath = getCopyTargetPath({
+      destination: destinationPath,
+      destinationType,
+      runtime,
+      source: sourcePath,
+      sourceType,
+    })
+    const targetType = await getCopyPathType(targetPath, client, runtime)
+    const shouldUseCopyTo =
+      sourceType === "file" &&
+      (targetType !== "directory" || isDirectoryLikeCopyPath(destinationPath))
 
-  const confirmedRootOverwrite = await confirmCopyRootOverwrite({
-    force: options.force === true,
-    longForce: options.longForce === true,
-    runtime,
-    targetPath,
-    targetType,
-  })
-  if (!confirmedRootOverwrite) {
     await confirmCopyOverwrite({
+      client,
       destination,
       force: options.force === true,
+      noClobber: options.noClobber === true,
       runtime,
+      sourcePath,
       sourceType,
       targetPath,
       targetType,
     })
+
+    operations.push({ shouldUseCopyTo, sourcePath, targetPath })
   }
-  await replaceCopyTargetBeforeCopy({
-    client,
-    rcloneOptions: defaultRcloneOptions,
-    runtime,
-    sourceType,
-    targetPath,
-    targetType,
-  })
 
-  await client.copy(
-    await toRcloneCopyPath(sourcePath, client, runtime),
-    await toRcloneCopyPath(targetPath, client, runtime),
-    { rcloneOptions: defaultRcloneOptions, to: shouldUseCopyTo },
-  )
+  const copyProgress = createR2Progress({
+    enabled: options.progress === true,
+    label: "Copying R2 paths",
+    max: operations.length,
+    success: "R2 copy complete.",
+  })
+  try {
+    for (const operation of operations) {
+      await client.copy(
+        await toRcloneCopyPath(operation.sourcePath, client, runtime),
+        await toRcloneCopyPath(operation.targetPath, client, runtime),
+        {
+          ignoreExisting: options.noClobber === true,
+          rcloneOptions: defaultRcloneOptions,
+          to: operation.shouldUseCopyTo,
+        },
+      )
+      copyProgress.advance()
+    }
+    copyProgress.stop()
+  } catch (error) {
+    copyProgress.error("R2 copy failed.")
+    throw error
+  }
   outro("R2 copy complete.")
 }
 
 /**
- * @param {string} source
- * @param {string} destination
+ * @param {string|string[]} paths
  * @param {R2MoveOptions} options
  * @param {R2Runtime} [runtime]
  */
-export async function moveR2(source, destination, options, runtime = {}) {
+export async function moveR2(paths, options = {}, runtime = {}) {
   intro("r2 mv")
-  const sourcePath = parseR2OnlyPath(source, "Move source")
+  const { sources, destination } = parseCopyArguments(paths)
+  if (options.force && options.noClobber) {
+    throw new CliError('Cannot use "--force" with "--no-clobber".')
+  }
+  const sourcePaths = sources.map((source) =>
+    parseR2OnlyPath(source, "Move source"),
+  )
   const destinationPath = parseR2OnlyPath(destination, "Move destination")
-  if (isR2BucketRootPath(source) || isR2BucketRootPath(destination)) {
+  if (
+    sources.some((source) => isR2BucketRootPath(source)) ||
+    isR2BucketRootPath(destination)
+  ) {
     throw new CliError("Refusing to move the R2 bucket root.")
   }
 
   const client = createR2CommandClient(runtime)
-  const sourceType = await getCopyPathType(sourcePath, client, runtime)
-  if (sourceType === "missing") {
-    throw new CliError(`Move source "${source}" does not exist.`)
-  }
   const destinationType = await getCopyPathType(
     destinationPath,
     client,
     runtime,
   )
-  const targetPath = getCopyTargetPath({
-    destination: destinationPath,
-    destinationType,
-    runtime,
-    source: sourcePath,
-    sourceType,
-  })
-  const targetType = await getCopyPathType(targetPath, client, runtime)
-  const shouldUseMoveTo =
-    sourceType === "file" &&
-    (targetType !== "directory" || isDirectoryLikeCopyPath(destinationPath))
+  if (
+    sourcePaths.length > 1 &&
+    destinationType !== "directory" &&
+    !isDirectoryLikeCopyPath(destinationPath)
+  ) {
+    throw new CliError(
+      "Moving multiple sources requires a directory destination.",
+    )
+  }
 
-  await confirmCopyOverwrite({
-    destination,
-    force: options.force === true,
-    runtime,
-    sourceType,
-    targetPath,
-    targetType,
-  })
-  await replaceCopyTargetBeforeCopy({
-    client,
-    rcloneOptions: defaultRcloneOptions,
-    runtime,
-    sourceType,
-    targetPath,
-    targetType,
-  })
+  const operations = []
+  for (const [index, sourcePath] of sourcePaths.entries()) {
+    const source = sources[index]
+    const sourceType = await getCopyPathType(sourcePath, client, runtime)
+    if (sourceType === "missing") {
+      throw new CliError(`Move source "${source}" does not exist.`)
+    }
 
-  await client.move(
-    await toRcloneCopyPath(sourcePath, client, runtime),
-    await toRcloneCopyPath(targetPath, client, runtime),
-    { rcloneOptions: defaultRcloneOptions, to: shouldUseMoveTo },
-  )
-  outro("R2 move complete.")
-}
+    const targetPath = getCopyTargetPath({
+      destination: destinationPath,
+      destinationType,
+      runtime,
+      source: sourcePath,
+      sourceType,
+    })
+    const targetType = await getCopyPathType(targetPath, client, runtime)
+    const shouldUseMoveTo =
+      sourceType === "file" &&
+      (targetType !== "directory" || isDirectoryLikeCopyPath(destinationPath))
 
-/**
- * @param {{
- *   client: ReturnType<typeof createR2CommandClient>,
- *   rcloneOptions?: RcloneOptions,
- *   runtime: R2Runtime,
- *   sourceType: CopyPathType,
- *   targetPath: CopyPath,
- *   targetType: CopyPathType
- * }} args
- */
-async function replaceCopyTargetBeforeCopy({
-  client,
-  rcloneOptions,
-  runtime,
-  sourceType,
-  targetPath,
-  targetType,
-}) {
-  if (sourceType !== "directory" || targetType !== "directory") {
-    return
-  }
-  if (targetPath.remote) {
-    await client.remove(targetPath.path, { recursive: true, rcloneOptions })
-    return
-  }
-  await rm(resolveLocalPath(targetPath.path, runtime), {
-    force: true,
-    recursive: true,
-  })
-}
+    await confirmCopyOverwrite({
+      client,
+      destination,
+      force: options.force === true,
+      noClobber: options.noClobber === true,
+      runtime,
+      sourcePath,
+      sourceType,
+      targetPath,
+      targetType,
+    })
 
-/**
- * @param {{
- *   force: boolean,
- *   longForce: boolean,
- *   runtime: R2Runtime,
- *   targetPath: CopyPath,
- *   targetType: CopyPathType
- * }} args
- */
-async function confirmCopyRootOverwrite({
-  force,
-  longForce,
-  runtime,
-  targetPath,
-  targetType,
-}) {
-  if (!isR2BucketRootCopyPath(targetPath) || targetType === "missing") {
-    return false
-  }
-  log.warn(
-    "This will replace ALL files in the configured R2 bucket. This cannot be undone.",
-  )
-  if (longForce) {
-    return true
-  }
-  if (force && !getInteractive(runtime)) {
-    throw new CliError(
-      'Ignoring "-f" for R2 bucket-root replacement. If you are sure you want to replace the entire R2 bucket, use "--force".',
-    )
-  }
-  if (!getInteractive(runtime)) {
-    throw new CliError(
-      'Replacing the R2 bucket root requires interactive confirmation. If you are sure you want to replace the entire R2 bucket, use "--force".',
-    )
-  }
-  if (force) {
-    log.warn(
-      'Ignoring "-f" for R2 bucket-root replacement. Use "--force" if you are sure you want to replace the entire R2 bucket.',
-    )
+    operations.push({ shouldUseMoveTo, sourcePath, targetPath })
   }
-  const shouldOverwrite = await getPromptConfirm(runtime)(
-    "Replace all files in the R2 bucket? [y/N] ",
-  )
-  if (!shouldOverwrite) {
-    cancelPrompt()
+
+  const moveProgress = createR2Progress({
+    enabled: options.progress === true,
+    label: "Moving R2 paths",
+    max: operations.length,
+    success: "R2 move complete.",
+  })
+  try {
+    for (const operation of operations) {
+      await client.move(
+        await toRcloneCopyPath(operation.sourcePath, client, runtime),
+        await toRcloneCopyPath(operation.targetPath, client, runtime),
+        {
+          ignoreExisting: options.noClobber === true,
+          rcloneOptions: defaultRcloneOptions,
+          to: operation.shouldUseMoveTo,
+        },
+      )
+      moveProgress.advance()
+    }
+    moveProgress.stop()
+  } catch (error) {
+    moveProgress.error("R2 move failed.")
+    throw error
   }
-  return true
+  outro("R2 move complete.")
 }
 
 /**
  * @param {R2Runtime} runtime
  */
 function createR2CommandClient(runtime) {
-  return createR2Client({
+  return (runtime.createR2Client ?? createR2Client)({
     cwd: runtime.cwd ?? processCwd(),
     interactive: getInteractive(runtime),
     promptText: getPromptText(runtime),
   })
 }
 
+/**
+ * @param {{enabled: boolean, label: string, max: number, success: string}} options
+ */
+function createR2Progress({ enabled, label, max, success }) {
+  if (!enabled || max === 0) {
+    return {
+      advance() {},
+      error() {},
+      stop() {},
+    }
+  }
+
+  const operationProgress = progress({ max })
+  let completed = 0
+  operationProgress.start(`${label} (0/${max})`)
+
+  return {
+    advance() {
+      completed += 1
+      operationProgress.advance(1, `${label} (${completed}/${max})`)
+    },
+    /**
+     * @param {string} message
+     */
+    error(message) {
+      operationProgress.error(message)
+    },
+    stop() {
+      operationProgress.stop(success)
+    },
+  }
+}
+
 /**
  * @param {R2Runtime} runtime
  */
@@ -407,6 +502,23 @@ function parseCopyPath(value) {
   return { remote: true, path: normalizeR2Path(value) }
 }
 
+/**
+ * @param {string|string[]} paths
+ * @returns {{sources: string[], destination: string}}
+ */
+function parseCopyArguments(paths) {
+  const copyPaths = Array.isArray(paths) ? paths : [paths]
+  if (copyPaths.length < 2) {
+    throw new CliError(
+      "R2 copy requires at least one source and a destination.",
+    )
+  }
+  return {
+    sources: copyPaths.slice(0, -1),
+    destination: copyPaths[copyPaths.length - 1],
+  }
+}
+
 /**
  * @param {string} value
  * @param {string} label
@@ -443,6 +555,18 @@ function getCopyTargetPath({
     if (destinationType === "file") {
       throw new CliError("Cannot copy a directory to an existing file.")
     }
+    if (isCopyPathContentsOnly(source)) {
+      return destination
+    }
+    if (
+      destinationType === "directory" ||
+      isDirectoryLikeCopyPath(destination)
+    ) {
+      return {
+        ...destination,
+        path: joinCopyPath(destination, getCopyPathName(source, runtime)),
+      }
+    }
     return destination
   }
 
@@ -461,18 +585,24 @@ function getCopyTargetPath({
 
 /**
  * @param {{
+ *   client: ReturnType<typeof createR2CommandClient>,
  *   destination: string,
  *   force: boolean,
+ *   noClobber: boolean,
  *   runtime: R2Runtime,
+ *   sourcePath: CopyPath,
  *   sourceType: CopyPathType,
  *   targetPath: CopyPath,
  *   targetType: CopyPathType
  * }} args
  */
 async function confirmCopyOverwrite({
+  client,
   destination,
   force,
+  noClobber,
   runtime,
+  sourcePath,
   sourceType,
   targetPath,
   targetType,
@@ -480,6 +610,9 @@ async function confirmCopyOverwrite({
   if (targetType === "missing") {
     return
   }
+  if (sourceType === "directory" && targetType === "file") {
+    throw new CliError("Cannot transfer a directory to an existing file.")
+  }
   if (
     sourceType === "file" &&
     targetType === "directory" &&
@@ -490,19 +623,128 @@ async function confirmCopyOverwrite({
   if (force) {
     return
   }
+  if (noClobber) {
+    return
+  }
+  const overwrittenPaths =
+    sourceType === "directory"
+      ? await getDirectoryOverwritePaths({
+          client,
+          runtime,
+          sourcePath,
+          targetPath,
+        })
+      : [formatCopyPath(targetPath)]
+  if (overwrittenPaths.length === 0) {
+    return
+  }
   if (!getInteractive(runtime)) {
     throw new CliError(
-      'Copy would overwrite existing files. Re-run with "--force" in non-interactive environments.',
+      'Transfer would overwrite existing files. Re-run with "--force" in non-interactive environments.',
     )
   }
-  const shouldOverwrite = await getPromptConfirm(runtime)(
-    `Overwrite existing destination "${destination}"? [y/N] `,
-  )
+  log.warn(`Files to overwrite (${overwrittenPaths.length})`)
+  for (const overwrittenPath of overwrittenPaths) {
+    log.message(`• ${overwrittenPath}`)
+  }
+  const message =
+    sourceType === "directory"
+      ? `Overwrite any existing files under destination "${destination}"? [y/N] `
+      : `Overwrite existing destination "${destination}"? [y/N] `
+  const shouldOverwrite = await getPromptConfirm(runtime)(message)
   if (!shouldOverwrite) {
     cancelPrompt()
   }
 }
 
+/**
+ * @param {{
+ *   client: ReturnType<typeof createR2CommandClient>
+ *   runtime: R2Runtime
+ *   sourcePath: CopyPath
+ *   targetPath: CopyPath
+ * }} args
+ */
+async function getDirectoryOverwritePaths({
+  client,
+  runtime,
+  sourcePath,
+  targetPath,
+}) {
+  const sourceFiles = await listCopyFiles(sourcePath, client, runtime)
+  if (sourceFiles.length === 0) {
+    return []
+  }
+  const targetFiles = new Set(await listCopyFiles(targetPath, client, runtime))
+  return sourceFiles
+    .filter((relativePath) => targetFiles.has(relativePath))
+    .map((relativePath) =>
+      formatCopyPath({
+        ...targetPath,
+        path: joinCopyPath(targetPath, relativePath),
+      }),
+    )
+}
+
+/**
+ * @param {CopyPath} copyPath
+ * @param {ReturnType<typeof createR2CommandClient>} client
+ * @param {R2Runtime} runtime
+ */
+async function listCopyFiles(copyPath, client, runtime) {
+  if (copyPath.remote) {
+    return parseRcloneFileList(await client.list(copyPath.path))
+  }
+  return listLocalFiles(resolveLocalPath(copyPath.path, runtime))
+}
+
+/**
+ * @param {string} root
+ * @param {string} [prefix]
+ * @returns {Promise<string[]>}
+ */
+async function listLocalFiles(root, prefix = "") {
+  const entries = await readdir(root, { withFileTypes: true })
+  const files = []
+  for (const entry of entries) {
+    const relativePath = prefix
+      ? joinRelativePath(prefix, entry.name)
+      : entry.name
+    const absolutePath = join(root, entry.name)
+    if (entry.isDirectory()) {
+      files.push(...(await listLocalFiles(absolutePath, relativePath)))
+    } else if (entry.isFile()) {
+      files.push(relativePath)
+    }
+  }
+  return files
+}
+
+/**
+ * @param {string} output
+ */
+function parseRcloneFileList(output) {
+  return output
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+}
+
+/**
+ * @param {string} parent
+ * @param {string} child
+ */
+function joinRelativePath(parent, child) {
+  return parent ? posix.join(parent, child) : child
+}
+
+/**
+ * @param {CopyPath} copyPath
+ */
+function formatCopyPath(copyPath) {
+  return copyPath.remote ? `${remotePathPrefix}${copyPath.path}` : copyPath.path
+}
+
 /**
  * @param {CopyPath} copyPath
  * @param {ReturnType<typeof createR2CommandClient>} client
@@ -542,6 +784,16 @@ function isDirectoryLikeCopyPath(copyPath) {
   return copyPath.path === "." || copyPath.path.endsWith("/")
 }
 
+/**
+ * @param {CopyPath} copyPath
+ */
+function isCopyPathContentsOnly(copyPath) {
+  const path = copyPath.remote
+    ? copyPath.path
+    : copyPath.path.replaceAll("\\", "/")
+  return path === "." || path.endsWith("/.")
+}
+
 /**
  * @param {CopyPath} parent
  * @param {string} child
@@ -592,13 +844,6 @@ function isR2BucketRootPath(path) {
   return path.trim() === "/"
 }
 
-/**
- * @param {CopyPath} path
- */
-function isR2BucketRootCopyPath(path) {
-  return path.remote && path.path === ""
-}
-
 /**
  * @param {unknown} error
  */

package/src/support/r2.js

@@ -248,12 +248,17 @@ export function createR2Client({ cwd, interactive, promptText }) {
     /**
      * @param {string} source
      * @param {string} destination
-     * @param {{to?: boolean, rcloneOptions?: RcloneOptions}} [options]
+     * @param {{ignoreExisting?: boolean, to?: boolean, rcloneOptions?: RcloneOptions}} [options]
      */
     async copy(source, destination, options = {}) {
       const r2Config = await getConfig()
       await runConfiguredRclone({
-        args: [options.to ? "copyto" : "copy", source, destination],
+        args: [
+          options.to ? "copyto" : "copy",
+          source,
+          destination,
+          ...(options.ignoreExisting ? ["--ignore-existing"] : []),
+        ],
         cwd,
         config: r2Config,
         rcloneOptions: options.rcloneOptions,
@@ -263,12 +268,17 @@ export function createR2Client({ cwd, interactive, promptText }) {
     /**
      * @param {string} source
      * @param {string} destination
-     * @param {{to?: boolean, rcloneOptions?: RcloneOptions}} [options]
+     * @param {{ignoreExisting?: boolean, to?: boolean, rcloneOptions?: RcloneOptions}} [options]
      */
     async move(source, destination, options = {}) {
       const r2Config = await getConfig()
       await runConfiguredRclone({
-        args: [options.to ? "moveto" : "move", source, destination],
+        args: [
+          options.to ? "moveto" : "move",
+          source,
+          destination,
+          ...(options.ignoreExisting ? ["--ignore-existing"] : []),
+        ],
         cwd,
         config: r2Config,
         rcloneOptions: options.rcloneOptions,