@lightnet/cli 4.4.2 → 4.5.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @lightnet/cli
 
+## 4.5.0
+
+### Minor Changes
+
+- [#437](https://github.com/LightNetDev/LightNet/pull/437) [`91446d3`](https://github.com/LightNetDev/LightNet/commit/91446d3102da0383dfffa836578c02286d0258c9) - Add `lightnet r2` commands for listing, deleting, and copying Cloudflare R2 files through the project R2 configuration.
+
 ## 4.4.2
 
 ### Patch Changes

package/package.json

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

package/src/index.js

@@ -7,6 +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 { CliError } from "./support/cli-error.js"
 import { PromptCancelled } from "./support/prompt-cancel.js"
 const { version } = pkg
@@ -70,6 +71,51 @@ program
     }
   })
 
+const r2Command = program
+  .command("r2")
+  .description("manage Cloudflare R2 files with rclone")
+
+r2Command
+  .command("ls")
+  .description("list R2 objects")
+  .argument("[path]", "R2 path or prefix")
+  .action(async (path) => {
+    try {
+      await listR2(path)
+    } catch (error) {
+      handleCommandError(error)
+    }
+  })
+
+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")
+  .option("-r, --recursive", "delete a directory/prefix recursively")
+  .option("-f, --force", "delete without confirmation")
+  .action(async (path, options) => {
+    try {
+      await removeR2(path, options)
+    } catch (error) {
+      handleCommandError(error)
+    }
+  })
+
+r2Command
+  .command("cp")
+  .description(
+    'copy files between R2 and the local filesystem; prefix the R2 side with "r2:"',
+  )
+  .argument("<source>", 'source path; use "r2:<path>" for R2')
+  .argument("<destination>", 'destination path; use "r2:<path>" for R2')
+  .action(async (source, destination) => {
+    try {
+      await copyR2(source, destination)
+    } catch (error) {
+      handleCommandError(error)
+    }
+  })
+
 await program.parseAsync()
 process.exitCode = commandExitCode
 

package/src/r2.js

@@ -0,0 +1,196 @@
+// @ts-check
+
+import { resolve } from "node:path"
+import {
+  cwd as processCwd,
+  env as processEnv,
+  stdin,
+  stdout,
+} from "node:process"
+
+import { confirm, isCancel, 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:"
+
+/**
+ * @typedef {{
+ *   force?: boolean
+ *   recursive?: boolean
+ * }} R2RemoveOptions
+ */
+
+/**
+ * @typedef {{
+ *   cwd?: string
+ *   invocationCwd?: string
+ *   isInteractive?: boolean
+ *   promptConfirm?: (message: string) => Promise<boolean>
+ *   promptText?: (message: string) => Promise<string>
+ *   writeStdout?: (message: string) => void
+ * }} R2Runtime
+ */
+
+/**
+ * @param {string|undefined} path
+ * @param {R2Runtime} [runtime]
+ */
+export async function listR2(path, runtime = {}) {
+  const client = createR2CommandClient(runtime)
+  const output = await client.list(path)
+  const writeStdout =
+    runtime.writeStdout ??
+    ((message) => {
+      stdout.write(message)
+    })
+  writeStdout(output)
+}
+
+/**
+ * @param {string} path
+ * @param {R2RemoveOptions} options
+ * @param {R2Runtime} [runtime]
+ */
+export async function removeR2(path, options, runtime = {}) {
+  const r2Path = normalizeR2Path(path)
+  if (!r2Path) {
+    throw new CliError("Refusing to delete the R2 bucket root.")
+  }
+
+  const interactive = getInteractive(runtime)
+  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 (!shouldDelete) {
+    return
+  }
+
+  const client = createR2CommandClient(runtime)
+  await client.remove(r2Path, {
+    recursive: options.recursive === true,
+  })
+}
+
+/**
+ * @param {string} source
+ * @param {string} destination
+ * @param {R2Runtime} [runtime]
+ */
+export async function copyR2(source, destination, runtime = {}) {
+  const sourcePath = parseCopyPath(source)
+  const destinationPath = parseCopyPath(destination)
+  if (sourcePath.remote === destinationPath.remote) {
+    throw new CliError(
+      `R2 copy requires exactly one R2 path. Prefix the remote side 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)
+
+  await client.copy(rcloneSource, rcloneDestination)
+}
+
+/**
+ * @param {R2Runtime} runtime
+ */
+function createR2CommandClient(runtime) {
+  return createR2Client({
+    cwd: runtime.cwd ?? processCwd(),
+    interactive: getInteractive(runtime),
+    promptText: getPromptText(runtime),
+  })
+}
+
+/**
+ * @param {R2Runtime} runtime
+ */
+function getInteractive(runtime) {
+  return runtime.isInteractive ?? Boolean(stdin.isTTY && stdout.isTTY)
+}
+
+/**
+ * @param {R2Runtime} runtime
+ */
+function getPromptText(runtime) {
+  return runtime.promptText ?? defaultPromptText
+}
+
+/**
+ * @param {R2Runtime} runtime
+ */
+function getPromptConfirm(runtime) {
+  return runtime.promptConfirm ?? defaultPromptConfirm
+}
+
+/**
+ * @param {string} value
+ */
+function parseCopyPath(value) {
+  if (!value.startsWith(remotePathPrefix)) {
+    return { remote: false, path: value }
+  }
+  return { remote: true, path: normalizeR2Path(value) }
+}
+
+/**
+ * @param {string} path
+ * @param {R2Runtime} runtime
+ */
+function resolveLocalPath(path, runtime) {
+  return resolve(getInvocationCwd(runtime), path)
+}
+
+/**
+ * @param {R2Runtime} runtime
+ */
+function getInvocationCwd(runtime) {
+  return runtime.invocationCwd ?? processEnv.INIT_CWD ?? processCwd()
+}
+
+/**
+ * @param {string|undefined} path
+ */
+function normalizeR2Path(path) {
+  return path?.replace(/^r2:/, "").replace(/^\/+/, "") ?? ""
+}
+
+/**
+ * @param {string} message
+ */
+async function defaultPromptText(message) {
+  const answer = await text({ message })
+  if (isCancel(answer)) {
+    cancelPrompt()
+  }
+  return String(answer)
+}
+
+/**
+ * @param {string} message
+ */
+async function defaultPromptConfirm(message) {
+  const answer = await confirm({
+    message,
+    initialValue: false,
+  })
+  if (isCancel(answer)) {
+    cancelPrompt()
+  }
+  return answer
+}

package/src/support/r2.js

@@ -90,7 +90,7 @@ export function createR2FileStorage({
   /** @returns {Promise<string>} */
   const getSecretAccessKey = async () => {
     if (!secretAccessKey) {
-      secretAccessKey = await promptRequiredSecret()
+      secretAccessKey = await promptRequiredSecret({ interactive })
     }
     return secretAccessKey
   }
@@ -166,6 +166,99 @@ export function createR2FileStorage({
   return storage
 }
 
+/**
+ * @param {{
+ *   cwd: string
+ *   interactive: boolean
+ *   promptText: (message: string) => Promise<string>
+ * }} args
+ */
+export function createR2Client({ cwd, interactive, promptText }) {
+  /** @type {R2Config|undefined} */
+  let config
+  /** @type {string|undefined} */
+  let secretAccessKey
+
+  /** @returns {Promise<R2Config>} */
+  const getConfig = async () => {
+    if (config) {
+      return config
+    }
+    const initializedConfig = await initR2Config({
+      cwd,
+      interactive,
+      promptText,
+    })
+    config = initializedConfig
+    return initializedConfig
+  }
+
+  /** @returns {Promise<string>} */
+  const getSecretAccessKey = async () => {
+    if (!secretAccessKey) {
+      secretAccessKey = await promptRequiredSecret({ interactive })
+    }
+    return secretAccessKey
+  }
+
+  return {
+    /**
+     * @param {string} [path]
+     */
+    async list(path) {
+      const r2Config = await getConfig()
+      const result = await runConfiguredRclone({
+        args: [
+          "lsf",
+          makeR2Path(r2Config, normalizeR2ObjectPath(path)),
+          "--recursive",
+          "--files-only",
+        ],
+        cwd,
+        config: r2Config,
+        secretAccessKey: await getSecretAccessKey(),
+      })
+      return result.stdout
+    },
+    /**
+     * @param {string} path
+     * @param {{recursive?: boolean}} [options]
+     */
+    async remove(path, options = {}) {
+      const r2Config = await getConfig()
+      const secretAccessKey = await getSecretAccessKey()
+      const r2Path = makeR2Path(r2Config, normalizeR2ObjectPath(path))
+      await runConfiguredRclone({
+        args: options.recursive
+          ? ["delete", r2Path, "--rmdirs"]
+          : ["deletefile", r2Path],
+        cwd,
+        config: r2Config,
+        secretAccessKey,
+      })
+    },
+    /**
+     * @param {string} source
+     * @param {string} destination
+     */
+    async copy(source, destination) {
+      const r2Config = await getConfig()
+      await runConfiguredRclone({
+        args: ["copy", source, destination],
+        cwd,
+        config: r2Config,
+        secretAccessKey: await getSecretAccessKey(),
+      })
+    },
+    /**
+     * @param {string} path
+     */
+    async toRemotePath(path) {
+      return makeR2Path(await getConfig(), normalizeR2ObjectPath(path))
+    },
+  }
+}
+
 /**
  * @param {string} path
  */
@@ -366,6 +459,7 @@ async function runConfiguredRclone({ args, cwd, config, secretAccessKey }) {
         "auto",
         "--s3-endpoint",
         getR2Endpoint(config.accountId),
+        "--s3-no-check-bucket",
       ],
       cwd,
       env,
@@ -400,14 +494,21 @@ async function promptForR2Config({ cwd, promptText }) {
 }
 
 /**
+ * @param {{interactive?: boolean}} [args]
  * @returns {Promise<string>}
  */
-async function promptRequiredSecret() {
+async function promptRequiredSecret({ interactive = true } = {}) {
   const sessionSecret = processEnv[sessionSecretEnvName]
   if (typeof sessionSecret === "string" && sessionSecret.trim()) {
     return sessionSecret
   }
 
+  if (!interactive) {
+    throw new CliError(
+      `Missing R2 secret access key. Set ${sessionSecretEnvName} in non-interactive environments.`,
+    )
+  }
+
   while (true) {
     const value = await password({
       message: "R2 secretAccessKey:",
@@ -422,6 +523,13 @@ async function promptRequiredSecret() {
   }
 }
 
+/**
+ * @param {string} [path]
+ */
+function normalizeR2ObjectPath(path) {
+  return path?.replace(/^r2:/, "").replace(/^\/+/, "") ?? ""
+}
+
 /**
  * @param {(message:string)=>Promise<string>} promptText
  * @param {string} message