@lightnet/cli 4.6.0 → 4.6.2

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @lightnet/cli
 
+## 4.6.2
+
+### Patch Changes
+
+- [#443](https://github.com/LightNetDev/LightNet/pull/443) [`6593139`](https://github.com/LightNetDev/LightNet/commit/65931398471107c03bca6bf4de675599b11db5e5) - Add Clack intro and completion messages to mutating `lightnet r2` commands while keeping `lightnet r2 ls` pipe-friendly.
+
+- [#443](https://github.com/LightNetDev/LightNet/pull/443) [`6593139`](https://github.com/LightNetDev/LightNet/commit/65931398471107c03bca6bf4de675599b11db5e5) - Improve `lightnet r2 cp`, `lightnet r2 mv`, and recursive `lightnet r2 rm` performance by passing tuned rclone concurrency settings internally.
+
+- [#443](https://github.com/LightNetDev/LightNet/pull/443) [`6593139`](https://github.com/LightNetDev/LightNet/commit/65931398471107c03bca6bf4de675599b11db5e5) - Show a clear install message when `lightnet r2` commands cannot find `rclone` on PATH.
+
+## 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

package/package.json

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

package/src/index.js

@@ -96,10 +96,11 @@ r2Command
   .option("-r, --recursive", "delete a directory/prefix recursively")
   .option(
     "-f, --force",
-    "delete without confirmation, except when cleaning the bucket root",
+    '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)
@@ -113,9 +114,13 @@ r2Command
   )
   .argument("<source>", 'source path; use "r2:<path>" for R2')
   .argument("<destination>", 'destination path; use "r2:<path>" for R2')
-  .option("-f, --force", "overwrite existing files without confirmation")
+  .option(
+    "-f, --force",
+    'overwrite without confirmation; use "--force" to replace the bucket root without confirmation',
+  )
   .action(async (source, destination, options) => {
     try {
+      options.longForce = hasLongForceFlag()
       await copyR2(source, destination, options)
     } catch (error) {
       handleCommandError(error)
@@ -154,3 +159,7 @@ function handleCommandError(error) {
   }
   throw error
 }
+
+function hasLongForceFlag() {
+  return process.argv.includes("--force")
+}

package/src/r2.js

@@ -9,17 +9,29 @@ import {
   stdout,
 } from "node:process"
 
-import { confirm, isCancel, log, text } from "@clack/prompts"
+import { confirm, intro, isCancel, log, outro, text } from "@clack/prompts"
 
 import { CliError } from "./support/cli-error.js"
 import { cancelPrompt } from "./support/prompt-cancel.js"
 import { createR2Client } from "./support/r2.js"
 
 const remotePathPrefix = "r2:"
+const defaultRcloneOptions = {
+  checkers: 16,
+  transfers: 8,
+}
+
+/**
+ * @typedef {{
+ *   transfers?: number
+ *   checkers?: number
+ * }} RcloneOptions
+ */
 
 /**
  * @typedef {{
  *   force?: boolean
+ *   longForce?: boolean
  * }} R2CopyOptions
  */
 
@@ -42,6 +54,7 @@ const remotePathPrefix = "r2:"
  * @typedef {{
  *   force?: boolean
  *   recursive?: boolean
+ *   longForce?: boolean
  * }} R2RemoveOptions
  */
 
@@ -77,6 +90,7 @@ export async function listR2(path, runtime = {}) {
  * @param {R2Runtime} [runtime]
  */
 export async function removeR2(path, options, runtime = {}) {
+  intro("r2 rm")
   const r2Path = normalizeR2Path(path)
   const isBucketRoot = isR2BucketRootPath(path)
   if (isBucketRoot && !options.recursive) {
@@ -89,9 +103,19 @@ export async function removeR2(path, options, runtime = {}) {
   }
 
   const interactive = getInteractive(runtime)
-  if (isBucketRoot && !interactive) {
+  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.",
+      '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) {
@@ -107,20 +131,24 @@ export async function removeR2(path, options, runtime = {}) {
   }
 
   const shouldDelete = isBucketRoot
-    ? await getPromptConfirm(runtime)(
+    ? 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)
   await client.remove(r2Path, {
     recursive: options.recursive === true,
+    rcloneOptions:
+      options.recursive === true ? defaultRcloneOptions : undefined,
   })
+  outro("R2 delete complete.")
 }
 
 /**
@@ -130,6 +158,7 @@ export async function removeR2(path, options, runtime = {}) {
  * @param {R2Runtime} [runtime]
  */
 export async function copyR2(source, destination, options = {}, runtime = {}) {
+  intro("r2 cp")
   const sourcePath = parseCopyPath(source)
   const destinationPath = parseCopyPath(destination)
   if (!sourcePath.remote && !destinationPath.remote) {
@@ -161,16 +190,26 @@ export async function copyR2(source, destination, options = {}, runtime = {}) {
     sourceType === "file" &&
     (targetType !== "directory" || isDirectoryLikeCopyPath(destinationPath))
 
-  await confirmCopyOverwrite({
-    destination,
+  const confirmedRootOverwrite = await confirmCopyRootOverwrite({
     force: options.force === true,
+    longForce: options.longForce === true,
     runtime,
-    sourceType,
     targetPath,
     targetType,
   })
+  if (!confirmedRootOverwrite) {
+    await confirmCopyOverwrite({
+      destination,
+      force: options.force === true,
+      runtime,
+      sourceType,
+      targetPath,
+      targetType,
+    })
+  }
   await replaceCopyTargetBeforeCopy({
     client,
+    rcloneOptions: defaultRcloneOptions,
     runtime,
     sourceType,
     targetPath,
@@ -180,8 +219,9 @@ export async function copyR2(source, destination, options = {}, runtime = {}) {
   await client.copy(
     await toRcloneCopyPath(sourcePath, client, runtime),
     await toRcloneCopyPath(targetPath, client, runtime),
-    { to: shouldUseCopyTo },
+    { rcloneOptions: defaultRcloneOptions, to: shouldUseCopyTo },
   )
+  outro("R2 copy complete.")
 }
 
 /**
@@ -191,6 +231,7 @@ export async function copyR2(source, destination, options = {}, runtime = {}) {
  * @param {R2Runtime} [runtime]
  */
 export async function moveR2(source, destination, options, runtime = {}) {
+  intro("r2 mv")
   const sourcePath = parseR2OnlyPath(source, "Move source")
   const destinationPath = parseR2OnlyPath(destination, "Move destination")
   if (isR2BucketRootPath(source) || isR2BucketRootPath(destination)) {
@@ -229,6 +270,7 @@ export async function moveR2(source, destination, options, runtime = {}) {
   })
   await replaceCopyTargetBeforeCopy({
     client,
+    rcloneOptions: defaultRcloneOptions,
     runtime,
     sourceType,
     targetPath,
@@ -238,13 +280,15 @@ export async function moveR2(source, destination, options, runtime = {}) {
   await client.move(
     await toRcloneCopyPath(sourcePath, client, runtime),
     await toRcloneCopyPath(targetPath, client, runtime),
-    { to: shouldUseMoveTo },
+    { rcloneOptions: defaultRcloneOptions, to: shouldUseMoveTo },
   )
+  outro("R2 move complete.")
 }
 
 /**
  * @param {{
  *   client: ReturnType<typeof createR2CommandClient>,
+ *   rcloneOptions?: RcloneOptions,
  *   runtime: R2Runtime,
  *   sourceType: CopyPathType,
  *   targetPath: CopyPath,
@@ -253,6 +297,7 @@ export async function moveR2(source, destination, options, runtime = {}) {
  */
 async function replaceCopyTargetBeforeCopy({
   client,
+  rcloneOptions,
   runtime,
   sourceType,
   targetPath,
@@ -262,7 +307,7 @@ async function replaceCopyTargetBeforeCopy({
     return
   }
   if (targetPath.remote) {
-    await client.remove(targetPath.path, { recursive: true })
+    await client.remove(targetPath.path, { recursive: true, rcloneOptions })
     return
   }
   await rm(resolveLocalPath(targetPath.path, runtime), {
@@ -271,6 +316,55 @@ async function replaceCopyTargetBeforeCopy({
   })
 }
 
+/**
+ * @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
+}
+
 /**
  * @param {R2Runtime} runtime
  */
@@ -498,6 +592,13 @@ 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

@@ -21,6 +21,13 @@ const execFileAsync = promisify(execFile)
 const sessionSecretEnvName = "LIGHTNET_R2_SECRET_ACCESS_KEY"
 const r2DeleteBatchSize = 1000
 
+/**
+ * @typedef {{
+ *   transfers?: number
+ *   checkers?: number
+ * }} RcloneOptions
+ */
+
 /**
  * @typedef {{
  *   publicUrl: string
@@ -222,7 +229,7 @@ export function createR2Client({ cwd, interactive, promptText }) {
     },
     /**
      * @param {string} path
-     * @param {{recursive?: boolean}} [options]
+     * @param {{recursive?: boolean, rcloneOptions?: RcloneOptions}} [options]
      */
     async remove(path, options = {}) {
       const r2Config = await getConfig()
@@ -234,13 +241,14 @@ export function createR2Client({ cwd, interactive, promptText }) {
           : ["deletefile", r2Path],
         cwd,
         config: r2Config,
+        rcloneOptions: options.rcloneOptions,
         secretAccessKey,
       })
     },
     /**
      * @param {string} source
      * @param {string} destination
-     * @param {{to?: boolean}} [options]
+     * @param {{to?: boolean, rcloneOptions?: RcloneOptions}} [options]
      */
     async copy(source, destination, options = {}) {
       const r2Config = await getConfig()
@@ -248,13 +256,14 @@ export function createR2Client({ cwd, interactive, promptText }) {
         args: [options.to ? "copyto" : "copy", source, destination],
         cwd,
         config: r2Config,
+        rcloneOptions: options.rcloneOptions,
         secretAccessKey: await getSecretAccessKey(),
       })
     },
     /**
      * @param {string} source
      * @param {string} destination
-     * @param {{to?: boolean}} [options]
+     * @param {{to?: boolean, rcloneOptions?: RcloneOptions}} [options]
      */
     async move(source, destination, options = {}) {
       const r2Config = await getConfig()
@@ -262,6 +271,7 @@ export function createR2Client({ cwd, interactive, promptText }) {
         args: [options.to ? "moveto" : "move", source, destination],
         cwd,
         config: r2Config,
+        rcloneOptions: options.rcloneOptions,
         secretAccessKey: await getSecretAccessKey(),
       })
     },
@@ -496,10 +506,17 @@ async function listR2Objects(args) {
  *   args: string[]
  *   cwd: string
  *   config: R2Config
+ *   rcloneOptions?: RcloneOptions
  *   secretAccessKey: string
  * }} args
  */
-async function runConfiguredRclone({ args, cwd, config, secretAccessKey }) {
+async function runConfiguredRclone({
+  args,
+  cwd,
+  config,
+  rcloneOptions,
+  secretAccessKey,
+}) {
   const env = {
     ...processEnv,
     RCLONE_S3_SECRET_ACCESS_KEY: secretAccessKey,
@@ -518,6 +535,7 @@ async function runConfiguredRclone({ args, cwd, config, secretAccessKey }) {
         "--s3-endpoint",
         getR2Endpoint(config.accountId),
         "--s3-no-check-bucket",
+        ...formatRcloneOptions(rcloneOptions),
       ],
       cwd,
       env,
@@ -527,6 +545,21 @@ async function runConfiguredRclone({ args, cwd, config, secretAccessKey }) {
   }
 }
 
+/**
+ * @param {RcloneOptions|undefined} options
+ */
+function formatRcloneOptions(options) {
+  /** @type {string[]} */
+  const args = []
+  if (options?.transfers !== undefined) {
+    args.push("--transfers", String(options.transfers))
+  }
+  if (options?.checkers !== undefined) {
+    args.push("--checkers", String(options.checkers))
+  }
+  return args
+}
+
 /**
  * @param {{cwd:string, promptText:(message:string)=>Promise<string>}} args
  */
@@ -698,9 +731,16 @@ async function defaultRunRclone(args, cwd, env) {
  */
 function getSanitizedRcloneError(error) {
   if (isPlainObject(error)) {
-    const processError = /** @type {{stderr?: unknown, stdout?: unknown}} */ (
-      error
-    )
+    const processError =
+      /** @type {{code?: unknown, stderr?: unknown, stdout?: unknown}} */ (
+        error
+      )
+    if (processError.code === "ENOENT") {
+      return [
+        "rclone is required for lightnet r2 commands but was not found on PATH.",
+        "Install rclone: https://rclone.org/install/",
+      ].join("\n")
+    }
     if (typeof processError.stderr === "string" && processError.stderr.trim()) {
       return processError.stderr.trim()
     }