feat(api): make cloud util commands visible (#7742)

...plus add commands for deleting remote variables, listing remote
variables and getting the current user.

Author: eysi09

core/src/commands/create/create-cloud-variables.ts

@@ -105,7 +105,6 @@ export class CreateCloudVariablesCommand extends Command<Args, Opts> {
 
   override arguments = createCloudVariablesArgs
   override options = createCloudVariablesOpts
-  override hidden = true
 
   override printHeader({ log }) {
     printHeader(log, "Create remote variables", "☁️")

core/src/commands/delete.ts

@@ -12,7 +12,7 @@ import dedent from "dedent"
 import { printHeader } from "../logger/util.js"
 import type { EnvironmentStatusMap } from "../plugin/handlers/Provider/getEnvironmentStatus.js"
 import { DeleteDeployTask, deletedDeployStatuses } from "../tasks/delete-deploy.js"
-import { joi, joiIdentifierMap } from "../config/common.js"
+import { joi, joiIdentifierMap, joiArray } from "../config/common.js"
 import { environmentStatusSchema } from "../config/status.js"
 import { BooleanParameter, StringsParameter } from "../cli/params.js"
 import { deline } from "../util/string.js"
@@ -21,14 +21,20 @@ import { isDeployAction } from "../actions/deploy.js"
 import { omit, mapValues } from "lodash-es"
 import type { DeployStatus, DeployStatusMap } from "../plugin/handlers/Deploy/get-status.js"
 import { getDeployStatusSchema } from "../plugin/handlers/Deploy/get-status.js"
+import { CommandError, ConfigurationError, GardenError } from "../exceptions.js"
+import { enumerate } from "../util/enumerate.js"
+import { handleBulkOperationResult, noApiMsg, throwIfLegacyCloud } from "./helpers.js"
+import { confirmDelete } from "./cloud/helpers.js"
+import type { DeleteResult } from "./cloud/helpers.js"
+import type { EmptyObject } from "type-fest"
 
 // TODO: rename this to CleanupCommand, and do the same for all related classes, constants, variables and functions
 export class DeleteCommand extends CommandGroup {
   name = "cleanup"
   override aliases = ["del", "delete"]
   help = "Clean up resources."
 
-  subCommands = [DeleteEnvironmentCommand, DeleteDeployCommand]
+  subCommands = [DeleteEnvironmentCommand, DeleteDeployCommand, DeleteRemoteVariablesCommand]
 }
 
 const dependantsFirstOpt = {
@@ -87,7 +93,7 @@ export class DeleteEnvironmentCommand extends Command<{}, DeleteEnvironmentOpts>
     garden,
     log,
     opts,
-  }: CommandParams<{}, DeleteEnvironmentOpts>): Promise<CommandResult<DeleteEnvironmentResult>> {
+  }: CommandParams<EmptyObject, DeleteEnvironmentOpts>): Promise<CommandResult<DeleteEnvironmentResult>> {
     const actions = await garden.getActionRouter()
     const graph = await garden.getConfigGraph({ log, emit: true })
     const deployStatuses = await actions.deleteDeploys({
@@ -211,3 +217,96 @@ export class DeleteDeployCommand extends Command<DeleteDeployArgs, DeleteDeployO
     return { result }
   }
 }
+
+export const deleteRemoteVariablesArgs = {
+  ids: new StringsParameter({
+    help: deline`The ID(s) of the cloud variables to delete.`,
+    spread: true,
+  }),
+}
+
+type DeleteRemoteVariablesArgs = typeof deleteRemoteVariablesArgs
+
+export class DeleteRemoteVariablesCommand extends Command<DeleteRemoteVariablesArgs> {
+  name = "remote-variables"
+  help = "Delete remote variables from Garden Cloud."
+  emoji = "☁️"
+
+  override aliases = ["cloud-variables"]
+
+  override description = dedent`
+    Delete remote variables in Garden Cloud. You will need the IDs of the variables you want to delete,
+    which you can get from the \`garden get remote-variables\` command.
+
+    Examples:
+        garden delete remote-variables <ID 1> <ID 2> <ID 3>   # delete the remote variables with the given IDs.
+  `
+
+  override arguments = deleteRemoteVariablesArgs
+
+  override printHeader({ log }) {
+    printHeader(log, "Delete remote variables", "☁️")
+  }
+
+  override outputsSchema = () =>
+    joi.object().keys({
+      variables: joiArray(
+        joi.object().keys({
+          id: joi.string(),
+          success: joi.boolean(),
+        })
+      ).description("A list of deleted variables"),
+    })
+
+  async action({ garden, args, log, opts }: CommandParams<DeleteRemoteVariablesArgs>): Promise<CommandResult> {
+    throwIfLegacyCloud(garden, "garden cloud variables delete")
+
+    const variablesToDelete = args.ids || []
+    if (variablesToDelete.length === 0) {
+      throw new CommandError({
+        message: `No variable IDs provided.`,
+      })
+    }
+
+    if (!opts.yes && !(await confirmDelete("remote variable", variablesToDelete.length))) {
+      return {}
+    }
+
+    if (!garden.cloudApi) {
+      throw new ConfigurationError({ message: noApiMsg("delete", "remote variables") })
+    }
+
+    const cmdLog = log.createLog({ name: "variables-command" })
+    cmdLog.info("Deleting remote variables...")
+
+    const errors: { identifier: string; message?: string }[] = []
+    const results: DeleteResult[] = []
+    for (const [counter, id] of enumerate(variablesToDelete, 1)) {
+      cmdLog.info({ msg: `Deleting remote variables... → ${counter}/${variablesToDelete.length}` })
+      try {
+        const res = await garden.cloudApi.trpc.variable.delete.mutate({
+          organizationId: garden.cloudApi.organizationId,
+          variableId: id,
+        })
+        results.push({ id, status: res.success ? "success" : "error" })
+      } catch (err) {
+        if (!(err instanceof GardenError)) {
+          throw err
+        }
+        errors.push({
+          identifier: id,
+          message: err.message,
+        })
+      }
+    }
+
+    return handleBulkOperationResult({
+      log,
+      cmdLog,
+      errors,
+      action: "delete",
+      resource: "variable",
+      results,
+    })
+  }
+}

core/src/commands/get/get-remote-variables.ts

@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2018-2025 Garden Technologies, Inc. <info@garden.io>
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+import type { CommandParams, CommandResult } from "../base.js"
+import { Command } from "../base.js"
+import { printEmoji, printHeader } from "../../logger/util.js"
+import { dedent, renderTable } from "../../util/string.js"
+import { styles } from "../../logger/styles.js"
+import { joi, joiArray } from "../../config/common.js"
+import { ConfigurationError } from "../../exceptions.js"
+import { getCloudListCommandBaseDescription, noApiMsg, throwIfLegacyCloud } from "../helpers.js"
+import { makeDocsLinkPlain } from "../../docs/common.js"
+import { getVarlistIdsFromRemoteVarsConfig } from "../../config/project.js"
+import type { RouterOutput } from "../../cloud/api/trpc.js"
+import type { EmptyObject } from "type-fest"
+
+const getRemoteVariablesOpts = {}
+
+type Opts = typeof getRemoteVariablesOpts
+
+interface RemoteVariable {
+  name: string
+  id: string
+  value: string
+  isSecret: boolean
+  variableListName: string
+  scopedToEnvironment: string
+  scopedToUser: string
+  expiresAt: string
+  description: string
+  scopedAccountId: string | null
+  scopedEnvironmentId: string | null
+}
+
+export class GetRemoteVariablesCommand extends Command<EmptyObject, Opts> {
+  name = "remote-variables"
+  help = "Get remote variables from Garden Cloud"
+  emoji = "☁️"
+
+  override aliases = ["cloud-variables"]
+
+  override description = dedent`
+    ${getCloudListCommandBaseDescription("remote variables")}
+
+    List all remote variables for the variable lists configured in this project. This is useful for
+    seeing the IDs of remote variables (e.g. for use with the \`garden delete remote-variables\` command)
+    and for viewing cloud-specific information such as scoping and expiration.
+
+    Examples:
+        garden get remote-variables                 # list remote variables and pretty print results
+        garden get remote-variables --output json   # returns remote variables as a JSON object, useful for scripting
+
+    See the [Variables and Templating guide](${makeDocsLinkPlain`features/variables-and-templating`}) for more information.
+
+  `
+
+  override options = getRemoteVariablesOpts
+
+  override printHeader({ log }) {
+    printHeader(log, "Get remote variables", "☁️")
+  }
+
+  override outputsSchema = () =>
+    joi.object().keys({
+      variables: joiArray(
+        joi.object().keys({
+          name: joi.string(),
+          id: joi.string(),
+          value: joi.string(),
+          isSecret: joi.boolean(),
+          variableListName: joi.string(),
+          environmentScope: joi.string(),
+          userScope: joi.string(),
+          expiresAt: joi.string().allow(""),
+          description: joi.string(),
+        })
+      ).description("A list of remote variables"),
+    })
+
+  async action({
+    garden,
+    log,
+  }: CommandParams<EmptyObject, Opts>): Promise<CommandResult<{ variables: RemoteVariable[] }>> {
+    throwIfLegacyCloud(garden, "garden cloud variables list")
+
+    if (!garden.cloudApi) {
+      throw new ConfigurationError({ message: noApiMsg("get", "cloud variables") })
+    }
+
+    const config = await garden.dumpConfigWithInteralFields({
+      log,
+      includeDisabled: false,
+      resolveGraph: false,
+      resolveProviders: false,
+      resolveWorkflows: false,
+    })
+
+    const variableListIds = getVarlistIdsFromRemoteVarsConfig(config.importVariables)
+
+    if (variableListIds.length === 0) {
+      log.info("No variable lists configured in this project.")
+      return { result: { variables: [] } }
+    }
+
+    const allVariables: RouterOutput["variableList"]["listVariables"]["items"] = []
+
+    for (const variableListId of variableListIds) {
+      let cursor: number | undefined = undefined
+
+      do {
+        log.debug(`Fetching variables for variable list ${variableListId}`)
+        const response = await garden.cloudApi.trpc.variableList.listVariables.query({
+          organizationId: garden.cloudApi.organizationId,
+          variableListId,
+          ...(cursor && { cursor }),
+        })
+
+        allVariables.push(...response.items)
+        cursor = response.nextCursor
+      } while (cursor)
+    }
+
+    const variables: RemoteVariable[] = allVariables.map((v) => ({
+      name: v.name,
+      id: v.id,
+      value: v.isSecret ? "<secret>" : v.value,
+      isSecret: v.isSecret,
+      variableListName: v.variableListName || "N/A",
+      scopedToEnvironment: v.scopedGardenEnvironmentName || "None",
+      scopedToUser: v.scopedAccountName || "None",
+      expiresAt: v.expiresAt ? new Date(v.expiresAt).toISOString() : "Never",
+      description: v.description || "",
+      scopedAccountId: v.scopedAccountId,
+      scopedEnvironmentId: v.scopedGardenEnvironmentId,
+    }))
+
+    const heading = [
+      "Name",
+      "ID",
+      "Value",
+      "Variable List",
+      "Environment Scope",
+      "User Scope",
+      "Expires At",
+      "Secret",
+    ].map((s) => styles.bold(s))
+
+    const rows: string[][] = variables.map((v) => {
+      return [
+        styles.highlight.bold(v.name),
+        v.id,
+        v.value,
+        v.variableListName,
+        v.scopedToEnvironment,
+        v.scopedToUser,
+        v.expiresAt,
+        v.isSecret ? "Yes" : "No",
+      ]
+    })
+
+    log.info("")
+    log.info(renderTable([heading].concat(rows)))
+    log.info(styles.success("OK") + " " + printEmoji("✔️", log))
+
+    return { result: { variables } }
+  }
+}