clever-tools 4.5.2 → 4.6.1

package/src/commands/tokens/tokens.create.command.js

@@ -1,14 +1,14 @@
 import dedent from 'dedent';
 import { z } from 'zod';
 import { createApiToken } from '../../clever-client/auth-bridge.js';
+import { config } from '../../config/config.js';
+import { formatDate } from '../../lib/date-utils.js';
 import { defineArgument } from '../../lib/define-argument.js';
 import { defineCommand } from '../../lib/define-command.js';
 import { defineOption } from '../../lib/define-option.js';
-import { formatDate } from '../../lib/format-date.js';
 import { promptSecret } from '../../lib/prompts.js';
 import { styleText } from '../../lib/style-text.js';
 import { Logger } from '../../logger.js';
-import { conf } from '../../models/configuration.js';
 import { sendToAuthBridge } from '../../models/send-to-api.js';
 import { getCurrent as getCurrentUser } from '../../models/user.js';
 import { futureDateOrDuration } from '../../parsers.js';
@@ -39,7 +39,7 @@ export const tokensCreateCommand = defineCommand({
     const user = await getCurrentUser();
 
     if (!user.hasPassword) {
-      const apiTokenListHref = new URL('/users/me/api-tokens', conf.CONSOLE_URL).href;
+      const apiTokenListHref = new URL('/users/me/api-tokens', config.CONSOLE_URL).href;
       throw new Error(dedent`
           ${styleText('yellow', '!')} Your Clever Cloud account is linked via GitHub and has no password. Setting one is required to create API tokens.
           ${styleText('blue', '→')} To do so, go to the following URL: ${styleText('blue', apiTokenListHref)}
@@ -98,7 +98,7 @@ export const tokensCreateCommand = defineCommand({
             Export this token and use it to make authenticated requests to the Clever Cloud API through the Auth Bridge:
     
             export CC_API_TOKEN=${createdToken.apiToken}
-            curl -H "Authorization: Bearer $CC_API_TOKEN" ${conf.AUTH_BRIDGE_HOST}/v2/self
+            curl -H "Authorization: Bearer $CC_API_TOKEN" ${config.AUTH_BRIDGE_HOST}/v2/self
     
             Then, to revoke this token, run:
             clever tokens revoke ${createdToken.apiTokenId}

package/src/config/cache.js

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { readJson, writeJson } from '../lib/fs.js';
+import { Logger } from '../logger.js';
+import { getConfigPath } from './paths.js';
+
+const IDS_CACHE_FILEPATH = getConfigPath('ids-cache.json');
+
+const IdsCacheSchema = z.object({
+  owners: z.record(z.string(), z.string()),
+  addons: z.record(
+    z.string(),
+    z.object({
+      addonId: z.string(),
+      realId: z.string(),
+    }),
+  ),
+});
+
+/**
+ * @typedef {z.output<typeof IdsCacheSchema>} IdsCache
+ */
+
+/** @type {IdsCache} */
+const EMPTY_CACHE = { owners: {}, addons: {} };
+
+/**
+ * Loads the IDs cache from the cache file.
+ * Returns an empty cache structure if the file doesn't exist or is invalid.
+ * @returns {Promise<IdsCache>} The cached IDs or empty cache structure
+ */
+export async function loadIdsCache() {
+  Logger.debug(`Get cache ID from ${IDS_CACHE_FILEPATH}`);
+  try {
+    const rawIdsCache = await readJson(IDS_CACHE_FILEPATH);
+    const parsed = IdsCacheSchema.safeParse(rawIdsCache);
+    if (!parsed.success) {
+      Logger.info(`Invalid IDs cache format in ${IDS_CACHE_FILEPATH}`);
+      return EMPTY_CACHE;
+    }
+    return parsed.data;
+  } catch (error) {
+    Logger.info(`Cannot load IDs cache from ${IDS_CACHE_FILEPATH}`);
+    return EMPTY_CACHE;
+  }
+}
+
+/**
+ * Writes the IDs cache to the cache file.
+ * Creates the configuration directory if it doesn't exist.
+ * @param {IdsCache} ids - The IDs to cache
+ * @returns {Promise<void>}
+ * @throws {Error} If the cache file cannot be written
+ */
+export async function writeIdsCache(ids) {
+  try {
+    await writeJson(IDS_CACHE_FILEPATH, ids, { mode: 0o700 });
+  } catch (error) {
+    throw new Error(`Cannot write IDs cache to ${IDS_CACHE_FILEPATH}\n${error.message}`);
+  }
+}

package/src/config/config.js

@@ -0,0 +1,233 @@
+import path from 'node:path';
+import { z } from 'zod';
+import { readJsonSync, writeJson } from '../lib/fs.js';
+import { Logger } from '../logger.js';
+import { getConfigPath } from './paths.js';
+
+const OverridesSchema = z.object({
+  API_HOST: z.string().url().optional(),
+  CONSOLE_URL: z.string().url().optional(),
+  AUTH_BRIDGE_HOST: z.string().url().optional(),
+  SSH_GATEWAY: z.string().optional(),
+  OAUTH_CONSUMER_KEY: z.string().optional(),
+  OAUTH_CONSUMER_SECRET: z.string().optional(),
+});
+
+const ProfileSchema = z.object({
+  alias: z.string(),
+  token: z.string(),
+  secret: z.string(),
+  expirationDate: z.string().optional(),
+  userId: z.string().optional(),
+  email: z.string().optional(),
+  overrides: OverridesSchema.optional(),
+});
+
+/** @typedef {z.infer<typeof ProfileSchema>} Profile */
+
+const LegacyConfigFileSchema = z.object({
+  token: z.string(),
+  secret: z.string(),
+  expirationDate: z.string().optional(),
+});
+
+/** @typedef {z.infer<typeof LegacyConfigFileSchema>} LegacyConfigFile */
+
+const ConfigFileSchema = z.object({
+  version: z.literal(1),
+  profiles: z.array(ProfileSchema).default([]),
+});
+
+/** @typedef {z.infer<typeof ConfigFileSchema>} ConfigFile */
+
+const ConfigSchema = z
+  .object({
+    CONFIGURATION_FILE: z.string().default(getConfigPath('clever-tools.json')),
+    EXPERIMENTAL_FEATURES_FILE: z.string().default(getConfigPath('clever-tools-experimental-features.json')),
+    APP_CONFIGURATION_FILE: z.string().default(() => path.resolve('.', '.clever.json')),
+
+    API_HOST: z.url().default('https://api.clever-cloud.com'),
+    AUTH_BRIDGE_HOST: z.url().default('https://api-bridge.clever-cloud.com'),
+    SSH_GATEWAY: z.string().default('ssh@sshgateway-clevercloud-customers.services.clever-cloud.com'),
+
+    // The disclosure of these tokens is not considered as a vulnerability.
+    // Do not report this to our security service.
+    OAUTH_CONSUMER_KEY: z.string().default('T5nFjKeHH4AIlEveuGhB5S3xg8T19e'),
+    OAUTH_CONSUMER_SECRET: z.string().default('MgVMqTr6fWlf2M0tkC2MXOnhfqBWDT'),
+
+    API_DOC_URL: z.url().default('https://www.clever.cloud/developers/api'),
+    DOC_URL: z.url().default('https://www.clever.cloud/developers/doc'),
+    CONSOLE_URL: z.url().default('https://console.clever-cloud.com'),
+
+    // Default values are computed from `CONSOLE_URL` below
+    CONSOLE_TOKEN_URL: z.url().optional(),
+    GOTO_URL: z.url().optional(),
+
+    token: z.string().optional(),
+    secret: z.string().optional(),
+    expirationDate: z.string().optional(),
+    profiles: z.array(ProfileSchema).default([]),
+  })
+  .transform((config) => ({
+    ...config,
+    CONSOLE_TOKEN_URL: config.CONSOLE_TOKEN_URL ?? `${config.CONSOLE_URL}/cli-oauth`,
+    GOTO_URL: config.GOTO_URL ?? `${config.CONSOLE_URL}/goto`,
+  }));
+
+/**
+ * Base configuration: environment variables + Zod schema defaults, without any profile overrides.
+ * Use this as fallback when operating on a specific profile (login, profile list)
+ * to avoid being affected by the active profile's overrides.
+ */
+export const baseConfig = loadBaseConfig();
+
+/**
+ * @returns {z.output<typeof ConfigSchema>}
+ */
+function loadBaseConfig() {
+  const result = ConfigSchema.safeParse(process.env);
+
+  if (!result.success) {
+    const errors = result.error.issues.map((issue) => `- ${issue.path.join('.')}: ${issue.message}`).join('\n');
+    Logger.error(`Invalid configuration:\n${errors}`);
+    process.exit(1);
+  }
+
+  return result.data;
+}
+
+/**
+ * The complete configuration object, loaded synchronously at startup.
+ * Priority: environment variables > active profile overrides > Zod schema defaults.
+ */
+export const config = loadConfig();
+
+/**
+ * @returns {z.output<typeof ConfigSchema>}
+ */
+function loadConfig() {
+  Logger.debug(`Load configuration from ${baseConfig.CONFIGURATION_FILE}`);
+  const configFromFile = loadConfigFile();
+
+  // If CLEVER_TOKEN and CLEVER_SECRET are set, inject a virtual "$env" profile as the active one
+  const profiles =
+    process.env.CLEVER_TOKEN != null && process.env.CLEVER_SECRET != null
+      ? [
+          { alias: '$env', token: process.env.CLEVER_TOKEN, secret: process.env.CLEVER_SECRET },
+          ...configFromFile.profiles,
+        ]
+      : configFromFile.profiles;
+
+  const activeProfile = profiles[0];
+
+  /** @type {z.input<typeof ConfigSchema>} */
+  const rawConfig = {
+    ...activeProfile,
+    // Profile overrides (e.g. custom API_HOST) applied after profile auth data, before env vars
+    ...activeProfile?.overrides,
+    profiles,
+    ...process.env,
+  };
+
+  const result = ConfigSchema.safeParse(rawConfig);
+
+  if (!result.success) {
+    const errors = result.error.issues.map((issue) => `- ${issue.path.join('.')}: ${issue.message}`).join('\n');
+    Logger.error(`Invalid configuration:\n${errors}`);
+    process.exit(1);
+  }
+
+  return result.data;
+}
+
+/**
+ * Reads and parses the config file, handling both current and legacy formats.
+ * @returns {ConfigFile}
+ */
+function loadConfigFile() {
+  const data = readJsonSync(baseConfig.CONFIGURATION_FILE);
+
+  // Try parsing as current format
+  const result = ConfigFileSchema.safeParse(data);
+  if (result.success) {
+    Logger.debug('Loaded config file with current format');
+    return result.data;
+  }
+
+  // Try parsing as legacy format
+  const legacyResult = LegacyConfigFileSchema.safeParse(data);
+  if (legacyResult.success) {
+    Logger.debug('Loaded config file with legacy format, converting to profile');
+    const legacyConfig = legacyResult.data;
+    return {
+      version: 1,
+      profiles: [
+        {
+          alias: 'default',
+          token: legacyConfig.token,
+          secret: legacyConfig.secret,
+          expirationDate: legacyConfig.expirationDate,
+        },
+      ],
+    };
+  }
+
+  // No valid config found
+  Logger.debug('No valid config file found, using empty config');
+  return { version: 1, profiles: [] };
+}
+
+/**
+ * Saves a profile to the configuration.
+ * If a profile with the same alias exists, it is replaced.
+ * The saved profile becomes the active profile (first in the list).
+ * @param {Profile} profile
+ * @returns {Promise<void>}
+ */
+export async function saveProfile(profile) {
+  const configFile = loadConfigFile();
+  const otherProfiles = configFile.profiles.filter((p) => p.alias !== profile.alias);
+  // Always put the active profile in the first position
+  configFile.profiles = [profile, ...otherProfiles];
+  await updateConfigFile(configFile);
+}
+
+/**
+ * Removes a profile by alias and returns the new active profile (if any).
+ * @param {string} alias
+ * @returns {Promise<Profile | null>}
+ */
+export async function removeProfile(alias) {
+  const configFile = loadConfigFile();
+  configFile.profiles = configFile.profiles.filter((p) => p.alias !== alias);
+  await updateConfigFile(configFile);
+  return configFile.profiles[0] ?? null;
+}
+
+/**
+ * Writes the configuration to the config file and reloads the in-memory config.
+ * @param {ConfigFile} newConfig - The new configuration to persist
+ * @returns {Promise<void>}
+ */
+async function updateConfigFile(newConfig) {
+  Logger.debug('Write the new config in the configuration file…');
+  try {
+    await writeJson(baseConfig.CONFIGURATION_FILE, newConfig, { mode: 0o700 });
+    reloadConfig();
+  } catch (error) {
+    throw new Error(`Cannot write configuration to ${baseConfig.CONFIGURATION_FILE}\n${error.message}`);
+  }
+}
+
+/**
+ * Reloads the configuration from file and updates the config object in place.
+ * This ensures all modules referencing the config object see the updated values.
+ */
+export function reloadConfig() {
+  const mutableConfig = /** @type {Record<string, unknown>} */ (config);
+  for (const key of Object.keys(mutableConfig)) {
+    delete mutableConfig[key];
+  }
+  const newConfig = loadConfig();
+  Object.assign(config, newConfig);
+}

package/src/config/features.js

@@ -0,0 +1,167 @@
+import dedent from 'dedent';
+import z from 'zod';
+import { readJson, writeJson } from '../lib/fs.js';
+import { Logger } from '../logger.js';
+import { config } from './config.js';
+import { getConfigPath } from './paths.js';
+
+const EXPERIMENTAL_FEATURES_FILEPATH = getConfigPath('clever-tools-experimental-features.json');
+
+export const EXPERIMENTAL_FEATURES = {
+  'system-git': {
+    status: 'beta',
+    description: 'Use system git instead of current JS implementation for git operations',
+    instructions: dedent`
+      This feature switches from the current JS implementation to using
+      the git installed on your system.
+
+      Requirements:
+        - git must be installed and available in your PATH
+    `,
+  },
+  k8s: {
+    status: 'beta',
+    description: 'Deploy and manage Kubernetes clusters on Clever Cloud',
+    instructions: dedent`
+      - Create a Kubernetes cluster:
+          clever k8s create my-cluster
+          clever k8s create my-cluster --org myOrg
+
+      - List Kubernetes clusters:
+          clever k8s list
+
+      - Get details about a Kubernetes cluster:
+          clever k8s get my-cluster
+
+      - Get kubeconfig file for a Kubernetes cluster:
+          clever k8s get-kubeconfig my-cluster
+          clever k8s get-kubeconfig my-cluster > ~/.kube/config
+
+      - Activate persistent storage on a Kubernetes cluster:
+          clever k8s add-persistent-storage my-cluster
+
+      - Delete a Kubernetes cluster:
+          clever k8s delete my-cluster
+
+      Learn more about Clever Kubernetes: ${config.DOC_URL}/kubernetes/
+    `,
+  },
+  kv: {
+    status: 'beta',
+    description:
+      'Send commands to databases such as Materia KV or Redis® directly from Clever Tools, without other dependencies',
+    instructions: dedent`
+      Target any compatible add-on by its name or ID (with an org ID if needed) and send commands to it:
+
+          clever kv myMateriaKV SET myKey myValue
+          clever kv kv_xxxxxxxx GET myKey -F json
+          clever kv addon_xxxxx SET myTempKey myTempValue EX 120
+          clever kv myMateriaKV -o myOrg TTL myTempKey
+          clever kv redis_xxxxx --org org_xxxxx PING
+
+      Learn more about Materia KV: ${config.DOC_URL}/addons/materia-kv/
+    `,
+  },
+  ng: {
+    status: 'beta',
+    description: 'Manage Network Groups to manage applications, add-ons, external peers through a WireGuard network',
+    instructions: dedent`
+      - Create a Network Group:
+          clever ng create myNG
+      - Create a Network Group with members (application, database add-on):
+          clever ng create myNG --link app_xxx,postgresql_xxx
+      - List Network Groups:
+          clever ng
+      - Delete a Network Group:
+          clever ng delete myNG
+      - (Un)Link an application or a database add-on to an existing Network Group:
+          clever ng link app_xxx myNG
+          clever ng unlink postgresql_xxx myNG
+      - Get the WireGuard configuration of a peer:
+          clever ng get-config peerIdOrLabel myNG
+      - Get details about a Network Group, a member or a peer:
+          clever ng get myNg
+          clever ng get app_xxx
+          clever ng get peerId
+          clever ng get memberLabel
+      - Search Network Groups, members or peers:
+          clever ng search myQuery
+
+      Learn more about Network Groups: ${config.DOC_URL}/develop/network-groups/
+    `,
+  },
+  operators: {
+    status: 'beta',
+    description: 'Manage operators and their features such as Keycloak, Matomo, Metabase, Otoroshi',
+    instructions: dedent`
+      clever keycloak
+      clever keycloak get keycloak_xxx
+      clever keycloak ng enable myKeycloak
+
+      clever metabase version check myMetabase
+      clever metabase version update myMetabase 0.53
+
+      clever matomo open myMatomo
+      clever otoroshi open logs myOtoroshi
+    `,
+  },
+};
+
+const FeaturesConfigSchema = z
+  .object(Object.fromEntries(Object.keys(EXPERIMENTAL_FEATURES).map((key) => [key, z.boolean()])))
+  .partial();
+
+/**
+ * @typedef {z.infer<typeof FeaturesConfigSchema>} FeaturesConfig
+ */
+
+/**
+ * Gets the current experimental features configuration.
+ * Returns an empty object if the features file doesn't exist or is invalid.
+ * @returns {Promise<FeaturesConfig>} The features configuration object
+ */
+export async function getFeatures() {
+  Logger.debug(`Get features configuration from ${EXPERIMENTAL_FEATURES_FILEPATH}`);
+  try {
+    const rawFeatures = await readJson(EXPERIMENTAL_FEATURES_FILEPATH);
+    const parsed = FeaturesConfigSchema.safeParse(rawFeatures);
+    if (!parsed.success) {
+      Logger.info(`Invalid features format in ${EXPERIMENTAL_FEATURES_FILEPATH}`);
+      return {};
+    }
+    return parsed.data;
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw new Error(`Cannot get experimental features configuration from ${EXPERIMENTAL_FEATURES_FILEPATH}`);
+    }
+    return {};
+  }
+}
+
+/**
+ * Sets an experimental feature to the specified value.
+ * Creates the configuration directory and features file if they don't exist.
+ * @param {string} feature - The name of the feature to set
+ * @param {boolean} value - The value to set for the feature
+ * @returns {Promise<void>}
+ * @throws {Error} If the features file cannot be written
+ */
+export async function setFeature(feature, value) {
+  const currentFeatures = await getFeatures();
+  const newFeatures = { ...currentFeatures, [feature]: value };
+  try {
+    await writeJson(EXPERIMENTAL_FEATURES_FILEPATH, newFeatures, { mode: 0o700 });
+  } catch (error) {
+    throw new Error(`Cannot write experimental features configuration to ${EXPERIMENTAL_FEATURES_FILEPATH}`);
+  }
+}
+
+/**
+ * Checks if an experimental feature is enabled.
+ * @param {string} feature - The name of the feature to check
+ * @returns {Promise<boolean>} True if the feature is explicitly enabled, false otherwise
+ */
+export async function isFeatureEnabled(feature) {
+  const features = await getFeatures();
+  return features[feature] === true;
+}

package/src/config/paths.js

@@ -0,0 +1,23 @@
+import path from 'node:path';
+// @ts-ignore - no types available for this module
+import xdg from 'xdg';
+
+/**
+ * Resolves the full path for a configuration file.
+ * @param {string} configFile - The name of the configuration file
+ * @returns {string} The absolute path to the configuration file
+ */
+export function getConfigPath(configFile) {
+  return path.resolve(getConfigDir(), configFile);
+}
+
+/**
+ * Gets the configuration directory path based on the operating system.
+ * On Windows, uses APPDATA/clever-cloud, on other platforms uses XDG config path.
+ * @returns {string} The absolute path to the configuration directory
+ */
+function getConfigDir() {
+  return process.platform === 'win32' && process.env.APPDATA != null
+    ? path.resolve(process.env.APPDATA, 'clever-cloud')
+    : xdg.basedir.configPath('clever-cloud');
+}

package/src/lib/date-utils.js

@@ -0,0 +1,48 @@
+/**
+ * Formats a date to ISO-like format "YYYY-MM-DD HH:mm".
+ * @param {string | number | Date} dateInput
+ * @returns {string}
+ */
+export function formatDate(dateInput) {
+  return new Date(dateInput).toISOString().substring(0, 16).replace('T', ' ');
+}
+
+/**
+ * Formats a date to localized display format (e.g. "Feb 5, 2027, 14:16 UTC").
+ * Returns undefined when the input is nullish.
+ * @param {Date | undefined | null} date
+ * @returns {string | undefined}
+ */
+export function formatDateLocalized(date) {
+  if (date == null) {
+    return undefined;
+  }
+  return date.toLocaleString('en-US', {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+    hour12: false,
+    timeZone: 'UTC',
+    timeZoneName: 'short',
+  });
+}
+
+/**
+ * Safely converts various date inputs (ISO string, timestamp, Date) to a Date instance.
+ * Returns undefined for null/undefined or invalid values.
+ * @param {string | number | Date | undefined | null} dateInput
+ * @returns {Date | undefined}
+ */
+export function toDate(dateInput) {
+  if (dateInput == null) {
+    return undefined;
+  }
+  try {
+    const date = new Date(dateInput);
+    return Number.isNaN(date.getTime()) ? undefined : date;
+  } catch {
+    return undefined;
+  }
+}

package/src/lib/fs.js

@@ -0,0 +1,49 @@
+import { promises as fs, readFileSync } from 'node:fs';
+import path from 'node:path';
+
+import { Logger } from '../logger.js';
+
+/**
+ * Reads and parses a JSON file asynchronously.
+ * @param {string} filePath - The absolute path to the JSON file
+ * @returns {Promise<unknown>} The parsed JSON content
+ * @throws {Error} If the file cannot be read or parsed
+ */
+export async function readJson(filePath) {
+  const rawFile = await fs.readFile(filePath, 'utf-8');
+  return JSON.parse(rawFile);
+}
+
+/**
+ * Reads and parses a JSON file synchronously.
+ * @param {string} filePath - The absolute path to the JSON file
+ * @returns {unknown | null} The parsed JSON content, or null if file is absent or invalid
+ */
+export function readJsonSync(filePath) {
+  try {
+    const rawFile = readFileSync(filePath, 'utf-8');
+    return JSON.parse(rawFile);
+  } catch (error) {
+    Logger.debug(`Failed to read JSON from ${filePath}: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Writes data as JSON to a file.
+ * Creates the parent directory if it doesn't exist.
+ * @param {string} filePath - The absolute path to the JSON file
+ * @param {unknown} data - The data to serialize and write
+ * @param {{ mode?: number }} [options] - Options for directory creation
+ * @returns {Promise<void>}
+ * @throws {Error} If the file cannot be written
+ */
+export async function writeJson(filePath, data, options = {}) {
+  /** @type {{ recursive: true, mode?: number }} */
+  const mkdirOptions = { recursive: true };
+  if (options.mode != null) {
+    mkdirOptions.mode = options.mode;
+  }
+  await fs.mkdir(path.dirname(filePath), mkdirOptions);
+  await fs.writeFile(filePath, JSON.stringify(data, null, 2), 'utf8');
+}

package/src/lib/operator-commands.js

@@ -9,8 +9,8 @@ import {
   versionCheck,
   versionUpdate,
 } from '../clever-client/operators.js';
+import { config } from '../config/config.js';
 import { Logger } from '../logger.js';
-import { conf } from '../models/configuration.js';
 import { findAddonsByAddonProvider } from '../models/ids-resolver.js';
 import * as Operator from '../models/operator.js';
 import { sendToApi } from '../models/send-to-api.js';
@@ -179,7 +179,7 @@ export async function operatorList(provider, format) {
 export async function operatorOpen(provider, addonIdOrName) {
   const operator = await Operator.getDetails(provider, addonIdOrName);
   await openBrowser(
-    `${conf.GOTO_URL}/${operator.addonId}`,
+    `${config.GOTO_URL}/${operator.addonId}`,
     `🌐 Opening ${styleText('blue', operator.addonId)} in the browser…`,
   );
 }
@@ -251,9 +251,9 @@ export async function operatorPrint(provider, addonIdOrName, format = 'human') {
   const operator = await Operator.getDetails(provider, addonIdOrName);
 
   if (provider === 'otoroshi' && format === 'otoroshictl') {
-    const config = await getOtoroshiConfig({ realId: operator.resourceId }).then(sendToApi);
+    const otoroshiConfig = await getOtoroshiConfig({ realId: operator.resourceId }).then(sendToApi);
 
-    Logger.println(config);
+    Logger.println(otoroshiConfig);
     return;
   }