@lightnet/cli 4.5.0 → 4.6.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @lightnet/cli
 
+## 4.6.1
+
+### Patch Changes
+
+- [#441](https://github.com/LightNetDev/LightNet/pull/441) [`b643414`](https://github.com/LightNetDev/LightNet/commit/b643414852ed1e6d80fa013dff9e1189c9f7ba35) - Protect R2 bucket-root delete and copy replacement with a visible warning and require the long `--force` flag to bypass confirmation.
+
+## 4.6.0
+
+### Minor Changes
+
+- [#439](https://github.com/LightNetDev/LightNet/pull/439) [`2572437`](https://github.com/LightNetDev/LightNet/commit/25724372a47ac8fcac1fd5959c442d6619f5b758) - Update `lightnet r2 cp` to support Unix-like file overwrite behavior and prompt before overwriting unless `-f` is provided.
+
+- [#439](https://github.com/LightNetDev/LightNet/pull/439) [`2572437`](https://github.com/LightNetDev/LightNet/commit/25724372a47ac8fcac1fd5959c442d6619f5b758) - Allow `lightnet r2 cp` to copy files and prefixes inside the configured R2 bucket with `r2:` source and destination paths.
+
+- [#439](https://github.com/LightNetDev/LightNet/pull/439) [`2572437`](https://github.com/LightNetDev/LightNet/commit/25724372a47ac8fcac1fd5959c442d6619f5b758) - Add `lightnet r2 mv` for moving and renaming files and prefixes inside the configured R2 bucket.
+
+- [#439](https://github.com/LightNetDev/LightNet/pull/439) [`2572437`](https://github.com/LightNetDev/LightNet/commit/25724372a47ac8fcac1fd5959c442d6619f5b758) - Update `lightnet r2 rm` to use OS-style deletion flags with `-r` for recursive prefix removal and `-f` for skipping confirmation.
+
 ## 4.5.0
 
 ### Minor Changes

package/package.json

@@ -3,7 +3,7 @@
   "description": "CLI for managing LightNet projects",
   "type": "module",
   "license": "MIT",
-  "version": "4.5.0",
+  "version": "4.6.1",
   "publishConfig": {
     "access": "public"
   },

package/src/index.js

@@ -7,7 +7,7 @@ import pkg from "../package.json" with { type: "json" }
 import { checkFiles } from "./check-files.js"
 import { checkLinks } from "./check-links.js"
 import { checkTranslations } from "./check-translations.js"
-import { copyR2, listR2, removeR2 } from "./r2.js"
+import { copyR2, listR2, moveR2, removeR2 } from "./r2.js"
 import { CliError } from "./support/cli-error.js"
 import { PromptCancelled } from "./support/prompt-cancel.js"
 const { version } = pkg
@@ -89,12 +89,18 @@ r2Command
 
 r2Command
   .command("rm")
-  .description("delete an R2 file; use -r to delete a directory/prefix")
-  .argument("<path>", "R2 file path, or directory/prefix with -r")
+  .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')
   .option("-r, --recursive", "delete a directory/prefix recursively")
-  .option("-f, --force", "delete without confirmation")
+  .option(
+    "-f, --force",
+    'delete without confirmation; use "--force" to clean the bucket root without confirmation',
+  )
   .action(async (path, options) => {
     try {
+      options.longForce = hasLongForceFlag()
       await removeR2(path, options)
     } catch (error) {
       handleCommandError(error)
@@ -104,13 +110,32 @@ r2Command
 r2Command
   .command("cp")
   .description(
-    'copy files between R2 and the local filesystem; prefix the R2 side with "r2:"',
+    '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')
-  .action(async (source, destination) => {
+  .option(
+    "-f, --force",
+    'overwrite without confirmation; use "--force" to replace the bucket root without confirmation',
+  )
+  .action(async (source, destination, options) => {
     try {
-      await copyR2(source, destination)
+      options.longForce = hasLongForceFlag()
+      await copyR2(source, destination, options)
+    } catch (error) {
+      handleCommandError(error)
+    }
+  })
+
+r2Command
+  .command("mv")
+  .description("move or rename an R2 file or directory/prefix")
+  .argument("<source>", "R2 source path")
+  .argument("<destination>", "R2 destination path")
+  .option("-f, --force", "overwrite existing destination without confirmation")
+  .action(async (source, destination, options) => {
+    try {
+      await moveR2(source, destination, options)
     } catch (error) {
       handleCommandError(error)
     }
@@ -134,3 +159,7 @@ function handleCommandError(error) {
   }
   throw error
 }
+
+function hasLongForceFlag() {
+  return process.argv.includes("--force")
+}

package/src/r2.js

@@ -1,6 +1,7 @@
 // @ts-check
 
-import { resolve } from "node:path"
+import { rm, stat } from "node:fs/promises"
+import { basename, join, posix, resolve } from "node:path"
 import {
   cwd as processCwd,
   env as processEnv,
@@ -8,7 +9,7 @@ import {
   stdout,
 } from "node:process"
 
-import { confirm, isCancel, text } from "@clack/prompts"
+import { confirm, isCancel, log, text } from "@clack/prompts"
 
 import { CliError } from "./support/cli-error.js"
 import { cancelPrompt } from "./support/prompt-cancel.js"
@@ -16,10 +17,33 @@ import { createR2Client } from "./support/r2.js"
 
 const remotePathPrefix = "r2:"
 
+/**
+ * @typedef {{
+ *   force?: boolean
+ *   longForce?: boolean
+ * }} R2CopyOptions
+ */
+
+/**
+ * @typedef {{
+ *   force?: boolean
+ * }} R2MoveOptions
+ */
+
+/**
+ * @typedef {{
+ *   remote: boolean
+ *   path: string
+ * }} CopyPath
+ */
+
+/** @typedef {"file"|"directory"|"missing"} CopyPathType */
+
 /**
  * @typedef {{
  *   force?: boolean
  *   recursive?: boolean
+ *   longForce?: boolean
  * }} R2RemoveOptions
  */
 
@@ -56,23 +80,54 @@ export async function listR2(path, runtime = {}) {
  */
 export async function removeR2(path, options, runtime = {}) {
   const r2Path = normalizeR2Path(path)
-  if (!r2Path) {
+  const isBucketRoot = isR2BucketRootPath(path)
+  if (isBucketRoot && !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 interactive = getInteractive(runtime)
+  if (isBucketRoot && 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) {
+    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) {
+    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.',
     )
   }
 
-  const shouldDelete =
-    options.force ||
-    (await getPromptConfirm(runtime)(`Delete R2 path "${r2Path}"? [y/N] `))
+  if (isBucketRoot) {
+    log.warn(
+      "This will delete ALL files in the configured R2 bucket. This cannot be undone.",
+    )
+  }
+
+  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] `))
 
   if (!shouldDelete) {
-    return
+    cancelPrompt()
   }
 
   const client = createR2CommandClient(runtime)
@@ -84,26 +139,207 @@ export async function removeR2(path, options, runtime = {}) {
 /**
  * @param {string} source
  * @param {string} destination
+ * @param {R2CopyOptions} [options]
  * @param {R2Runtime} [runtime]
  */
-export async function copyR2(source, destination, runtime = {}) {
+export async function copyR2(source, destination, options = {}, runtime = {}) {
   const sourcePath = parseCopyPath(source)
   const destinationPath = parseCopyPath(destination)
-  if (sourcePath.remote === destinationPath.remote) {
+  if (!sourcePath.remote && !destinationPath.remote) {
     throw new CliError(
-      `R2 copy requires exactly one R2 path. Prefix the remote side with "${remotePathPrefix}".`,
+      `R2 copy requires at least one R2 path. Prefix R2 paths with "${remotePathPrefix}".`,
     )
   }
 
   const client = createR2CommandClient(runtime)
-  const rcloneSource = sourcePath.remote
-    ? await client.toRemotePath(sourcePath.path)
-    : resolveLocalPath(sourcePath.path, runtime)
-  const rcloneDestination = destinationPath.remote
-    ? await client.toRemotePath(destinationPath.path)
-    : resolveLocalPath(destinationPath.path, 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))
 
-  await client.copy(rcloneSource, rcloneDestination)
+  const confirmedRootOverwrite = await confirmCopyRootOverwrite({
+    force: options.force === true,
+    longForce: options.longForce === true,
+    runtime,
+    targetPath,
+    targetType,
+  })
+  if (!confirmedRootOverwrite) {
+    await confirmCopyOverwrite({
+      destination,
+      force: options.force === true,
+      runtime,
+      sourceType,
+      targetPath,
+      targetType,
+    })
+  }
+  await replaceCopyTargetBeforeCopy({
+    client,
+    runtime,
+    sourceType,
+    targetPath,
+    targetType,
+  })
+
+  await client.copy(
+    await toRcloneCopyPath(sourcePath, client, runtime),
+    await toRcloneCopyPath(targetPath, client, runtime),
+    { to: shouldUseCopyTo },
+  )
+}
+
+/**
+ * @param {string} source
+ * @param {string} destination
+ * @param {R2MoveOptions} options
+ * @param {R2Runtime} [runtime]
+ */
+export async function moveR2(source, destination, options, runtime = {}) {
+  const sourcePath = parseR2OnlyPath(source, "Move source")
+  const destinationPath = parseR2OnlyPath(destination, "Move destination")
+  if (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))
+
+  await confirmCopyOverwrite({
+    destination,
+    force: options.force === true,
+    runtime,
+    sourceType,
+    targetPath,
+    targetType,
+  })
+  await replaceCopyTargetBeforeCopy({
+    client,
+    runtime,
+    sourceType,
+    targetPath,
+    targetType,
+  })
+
+  await client.move(
+    await toRcloneCopyPath(sourcePath, client, runtime),
+    await toRcloneCopyPath(targetPath, client, runtime),
+    { to: shouldUseMoveTo },
+  )
+}
+
+/**
+ * @param {{
+ *   client: ReturnType<typeof createR2CommandClient>,
+ *   runtime: R2Runtime,
+ *   sourceType: CopyPathType,
+ *   targetPath: CopyPath,
+ *   targetType: CopyPathType
+ * }} args
+ */
+async function replaceCopyTargetBeforeCopy({
+  client,
+  runtime,
+  sourceType,
+  targetPath,
+  targetType,
+}) {
+  if (sourceType !== "directory" || targetType !== "directory") {
+    return
+  }
+  if (targetPath.remote) {
+    await client.remove(targetPath.path, { recursive: true })
+    return
+  }
+  await rm(resolveLocalPath(targetPath.path, runtime), {
+    force: true,
+    recursive: true,
+  })
+}
+
+/**
+ * @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.',
+    )
+  }
+  const shouldOverwrite = await getPromptConfirm(runtime)(
+    "Replace all files in the R2 bucket? [y/N] ",
+  )
+  if (!shouldOverwrite) {
+    cancelPrompt()
+  }
+  return true
 }
 
 /**
@@ -148,6 +384,162 @@ function parseCopyPath(value) {
   return { remote: true, path: normalizeR2Path(value) }
 }
 
+/**
+ * @param {string} value
+ * @param {string} label
+ * @returns {CopyPath}
+ */
+function parseR2OnlyPath(value, label) {
+  if (value.startsWith(remotePathPrefix)) {
+    return { remote: true, path: normalizeR2Path(value) }
+  }
+  if (value.startsWith("/") || value.startsWith("./") || value === ".") {
+    throw new CliError(`${label} must be an R2 path, not a local path.`)
+  }
+  return { remote: true, path: normalizeR2Path(value) }
+}
+
+/**
+ * @param {{
+ *   destination: CopyPath,
+ *   destinationType: CopyPathType,
+ *   runtime: R2Runtime,
+ *   source: CopyPath,
+ *   sourceType: CopyPathType
+ * }} args
+ * @returns {CopyPath}
+ */
+function getCopyTargetPath({
+  destination,
+  destinationType,
+  runtime,
+  source,
+  sourceType,
+}) {
+  if (sourceType === "directory") {
+    if (destinationType === "file") {
+      throw new CliError("Cannot copy a directory to an existing file.")
+    }
+    return destination
+  }
+
+  if (
+    destinationType === "directory" ||
+    (destinationType === "missing" && isDirectoryLikeCopyPath(destination))
+  ) {
+    return {
+      ...destination,
+      path: joinCopyPath(destination, getCopyPathName(source, runtime)),
+    }
+  }
+
+  return destination
+}
+
+/**
+ * @param {{
+ *   destination: string,
+ *   force: boolean,
+ *   runtime: R2Runtime,
+ *   sourceType: CopyPathType,
+ *   targetPath: CopyPath,
+ *   targetType: CopyPathType
+ * }} args
+ */
+async function confirmCopyOverwrite({
+  destination,
+  force,
+  runtime,
+  sourceType,
+  targetPath,
+  targetType,
+}) {
+  if (targetType === "missing") {
+    return
+  }
+  if (
+    sourceType === "file" &&
+    targetType === "directory" &&
+    !isDirectoryLikeCopyPath(targetPath)
+  ) {
+    throw new CliError("Cannot overwrite an existing directory with a file.")
+  }
+  if (force) {
+    return
+  }
+  if (!getInteractive(runtime)) {
+    throw new CliError(
+      'Copy would overwrite existing files. Re-run with "--force" in non-interactive environments.',
+    )
+  }
+  const shouldOverwrite = await getPromptConfirm(runtime)(
+    `Overwrite existing destination "${destination}"? [y/N] `,
+  )
+  if (!shouldOverwrite) {
+    cancelPrompt()
+  }
+}
+
+/**
+ * @param {CopyPath} copyPath
+ * @param {ReturnType<typeof createR2CommandClient>} client
+ * @param {R2Runtime} runtime
+ * @returns {Promise<CopyPathType>}
+ */
+async function getCopyPathType(copyPath, client, runtime) {
+  if (copyPath.remote) {
+    return client.getPathType(copyPath.path)
+  }
+  try {
+    const stats = await stat(resolveLocalPath(copyPath.path, runtime))
+    return stats.isDirectory() ? "directory" : "file"
+  } catch (error) {
+    if (isLocalNotFoundError(error)) {
+      return "missing"
+    }
+    throw error
+  }
+}
+
+/**
+ * @param {CopyPath} copyPath
+ * @param {ReturnType<typeof createR2CommandClient>} client
+ * @param {R2Runtime} runtime
+ */
+async function toRcloneCopyPath(copyPath, client, runtime) {
+  return copyPath.remote
+    ? await client.toRemotePath(copyPath.path)
+    : resolveLocalPath(copyPath.path, runtime)
+}
+
+/**
+ * @param {CopyPath} copyPath
+ */
+function isDirectoryLikeCopyPath(copyPath) {
+  return copyPath.path === "." || copyPath.path.endsWith("/")
+}
+
+/**
+ * @param {CopyPath} parent
+ * @param {string} child
+ */
+function joinCopyPath(parent, child) {
+  if (parent.remote) {
+    return parent.path ? posix.join(parent.path, child) : child
+  }
+  return join(parent.path, child)
+}
+
+/**
+ * @param {CopyPath} copyPath
+ * @param {R2Runtime} runtime
+ */
+function getCopyPathName(copyPath, runtime) {
+  return copyPath.remote
+    ? posix.basename(copyPath.path.replace(/\/+$/, ""))
+    : basename(resolveLocalPath(copyPath.path, runtime))
+}
+
 /**
  * @param {string} path
  * @param {R2Runtime} runtime
@@ -170,6 +562,32 @@ function normalizeR2Path(path) {
   return path?.replace(/^r2:/, "").replace(/^\/+/, "") ?? ""
 }
 
+/**
+ * @param {string} path
+ */
+function isR2BucketRootPath(path) {
+  return path.trim() === "/"
+}
+
+/**
+ * @param {CopyPath} path
+ */
+function isR2BucketRootCopyPath(path) {
+  return path.remote && path.path === ""
+}
+
+/**
+ * @param {unknown} error
+ */
+function isLocalNotFoundError(error) {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    error.code === "ENOENT"
+  )
+}
+
 /**
  * @param {string} message
  */

package/src/support/r2.js

@@ -240,16 +240,74 @@ export function createR2Client({ cwd, interactive, promptText }) {
     /**
      * @param {string} source
      * @param {string} destination
+     * @param {{to?: boolean}} [options]
      */
-    async copy(source, destination) {
+    async copy(source, destination, options = {}) {
       const r2Config = await getConfig()
       await runConfiguredRclone({
-        args: ["copy", source, destination],
+        args: [options.to ? "copyto" : "copy", source, destination],
         cwd,
         config: r2Config,
         secretAccessKey: await getSecretAccessKey(),
       })
     },
+    /**
+     * @param {string} source
+     * @param {string} destination
+     * @param {{to?: boolean}} [options]
+     */
+    async move(source, destination, options = {}) {
+      const r2Config = await getConfig()
+      await runConfiguredRclone({
+        args: [options.to ? "moveto" : "move", source, destination],
+        cwd,
+        config: r2Config,
+        secretAccessKey: await getSecretAccessKey(),
+      })
+    },
+    /**
+     * @param {string} path
+     * @returns {Promise<"file"|"directory"|"missing">}
+     */
+    async getPathType(path) {
+      const normalizedPath = normalizeR2ObjectPath(path)
+      if (!normalizedPath) {
+        return "directory"
+      }
+      const r2Config = await getConfig()
+      try {
+        const result = await runConfiguredRclone({
+          args: [
+            "lsjson",
+            makeR2Path(r2Config, normalizedPath),
+            "--max-depth",
+            "1",
+            "--no-mimetype",
+            "--no-modtime",
+          ],
+          cwd,
+          config: r2Config,
+          secretAccessKey: await getSecretAccessKey(),
+        })
+        const entries = parseRcloneJsonList(result.stdout)
+        if (entries.length === 0) {
+          return "missing"
+        }
+        if (
+          entries.length === 1 &&
+          !entries[0].isDir &&
+          entries[0].name === getR2PathName(normalizedPath)
+        ) {
+          return "file"
+        }
+        return "directory"
+      } catch (error) {
+        if (isRcloneNotFoundError(error)) {
+          return "missing"
+        }
+        throw error
+      }
+    },
     /**
      * @param {string} path
      */
@@ -530,6 +588,40 @@ function normalizeR2ObjectPath(path) {
   return path?.replace(/^r2:/, "").replace(/^\/+/, "") ?? ""
 }
 
+/**
+ * @param {string} output
+ * @returns {{name:string, isDir:boolean}[]}
+ */
+function parseRcloneJsonList(output) {
+  const parsed = JSON.parse(output)
+  if (!Array.isArray(parsed)) {
+    throw new CliError("Unexpected rclone JSON listing output.")
+  }
+  return parsed
+    .filter((item) => isPlainObject(item) && typeof item.Name === "string")
+    .map((item) => ({
+      name: String(item.Name),
+      isDir: item.IsDir === true,
+    }))
+}
+
+/**
+ * @param {string} path
+ */
+function getR2PathName(path) {
+  return path.replace(/\/+$/, "").split("/").at(-1) ?? ""
+}
+
+/**
+ * @param {unknown} error
+ */
+function isRcloneNotFoundError(error) {
+  return (
+    error instanceof Error &&
+    /not found|directory not found|object not found/i.test(error.message)
+  )
+}
+
 /**
  * @param {(message:string)=>Promise<string>} promptText
  * @param {string} message