clever-tools 4.11.0 → 5.0.0

package/src/config/features.js

@@ -1,26 +1,40 @@
 import dedent from 'dedent';
 import z from 'zod';
-import { readJson, writeJson } from '../lib/fs.js';
+import { readJsonSync, 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');
 
+/**
+ * @typedef {object} ExperimentalFeature
+ * @property {'beta'|'stable'} status
+ * @property {boolean} defaultValue - Value used when the feature is not explicitly set by the user
+ * @property {string} description
+ * @property {string} [instructions]
+ */
+
+/** @type {Record<string, ExperimentalFeature>} */
 export const EXPERIMENTAL_FEATURES = {
   'system-git': {
-    status: 'beta',
-    description: 'Use system git instead of current JS implementation for git operations',
+    status: 'stable',
+    defaultValue: true,
+    description: 'Use system git instead of the pure JS implementation for git operations',
     instructions: dedent`
-      This feature switches from the current JS implementation to using
-      the git installed on your system.
+      This feature switches from the pure JS implementation to using
+      the git installed on your system. It is enabled by default since v5.0.0.
 
       Requirements:
         - git must be installed and available in your PATH
+
+      Disable it to fall back to the previous pure JS implementation:
+        clever features disable system-git
     `,
   },
   k8s: {
     status: 'beta',
+    defaultValue: false,
     description: 'Deploy and manage Kubernetes clusters on Clever Cloud',
     instructions: dedent`
       - Create a Kubernetes cluster:
@@ -48,6 +62,7 @@ export const EXPERIMENTAL_FEATURES = {
   },
   kv: {
     status: 'beta',
+    defaultValue: false,
     description:
       'Send commands to databases such as Materia KV or Redis® directly from Clever Tools, without other dependencies',
     instructions: dedent`
@@ -64,6 +79,7 @@ export const EXPERIMENTAL_FEATURES = {
   },
   ng: {
     status: 'beta',
+    defaultValue: false,
     description: 'Manage Network Groups to manage applications, add-ons, external peers through a WireGuard network',
     instructions: dedent`
       - Create a Network Group:
@@ -92,6 +108,7 @@ export const EXPERIMENTAL_FEATURES = {
   },
   operators: {
     status: 'beta',
+    defaultValue: false,
     description: 'Manage operators and their features such as Keycloak, Matomo, Metabase, Otoroshi',
     instructions: dedent`
       clever keycloak
@@ -116,52 +133,67 @@ const FeaturesConfigSchema = z
  */
 
 /**
- * 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
+ * The features explicitly set by the user, loaded synchronously at startup.
+ * @type {FeaturesConfig}
  */
-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}`);
-    }
+let userFeatures = loadFeatures();
+
+/**
+ * Reads and parses the features file.
+ * Returns an empty object if the file doesn't exist or is invalid.
+ * @returns {FeaturesConfig} The features configuration object
+ */
+function loadFeatures() {
+  Logger.debug(`Load features configuration from ${EXPERIMENTAL_FEATURES_FILEPATH}`);
+  const rawFeatures = readJsonSync(EXPERIMENTAL_FEATURES_FILEPATH);
+  if (rawFeatures == null) {
+    return {};
+  }
+  const parsed = FeaturesConfigSchema.safeParse(rawFeatures);
+  if (!parsed.success) {
+    Logger.info(`Invalid features format in ${EXPERIMENTAL_FEATURES_FILEPATH}`);
     return {};
   }
+  return parsed.data;
 }
 
 /**
  * Sets an experimental feature to the specified value.
- * Creates the configuration directory and features file if they don't exist.
+ * Creates the configuration directory and features file if they don't exist,
+ * then reloads the in-memory configuration.
  * @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 };
+  const newFeatures = { ...userFeatures, [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}`);
   }
+  userFeatures = loadFeatures();
 }
 
 /**
  * Checks if an experimental feature is enabled.
+ * Falls back to the feature's `defaultValue` when the user hasn't set it explicitly.
  * @param {string} feature - The name of the feature to check
- * @returns {Promise<boolean>} True if the feature is explicitly enabled, false otherwise
+ * @returns {boolean} True if the feature is enabled
+ */
+export function isFeatureEnabled(feature) {
+  return userFeatures[feature] ?? EXPERIMENTAL_FEATURES[feature]?.defaultValue ?? false;
+}
+
+/**
+ * Lists all experimental features with their current status.
+ * @returns {Array<{ id: string, status: string, description: string, instructions?: string, enabled: boolean }>}
  */
-export async function isFeatureEnabled(feature) {
-  const features = await getFeatures();
-  return features[feature] === true;
+export function getAllFeatures() {
+  return Object.entries(EXPERIMENTAL_FEATURES).map(([id, feature]) => ({
+    id,
+    ...feature,
+    enabled: isFeatureEnabled(id),
+  }));
 }

package/src/format-table.js

@@ -36,16 +36,20 @@ export const formatTable = (data, columnWidth = []) => {
   return data
     .map((row) => row.map((cell) => String(cell)))
     .map((row) => {
-      return row
-        .map((cell, index) => {
-          const isLastColumn = index === row.length - 1;
-          if (isLastColumn) {
-            return cell;
-          }
-          const rightPaddingLength = columnSizes[index] - stringLength(cell) ?? 0;
-          return cell + ' '.repeat(rightPaddingLength);
-        })
-        .join(SEPARATOR);
+      return (
+        row
+          .map((cell, index) => {
+            const isLastColumn = index === row.length - 1;
+            if (isLastColumn) {
+              return cell;
+            }
+            const rightPaddingLength = columnSizes[index] - stringLength(cell) ?? 0;
+            return cell + ' '.repeat(rightPaddingLength);
+          })
+          .join(SEPARATOR)
+          // empty trailing cells would otherwise pad the line with meaningless spaces
+          .trimEnd()
+      );
     })
     .join('\n');
 };

package/src/initial-setup.js

@@ -1,5 +1,18 @@
+import { EnvHttpProxyAgent, setGlobalDispatcher } from 'undici';
 import { hasParam } from './lib/has-param.js';
 
+// Node's global fetch() ignores the http_proxy/https_proxy environment variables,
+// unlike most CLI tools (curl, kubectl, s3cmd…). When such a variable is set, install
+// an EnvHttpProxyAgent as the global dispatcher so every fetch() (API calls, update
+// checks…) routes through the proxy and honors no_proxy for exclusions. We only swap
+// the dispatcher when a proxy is actually configured, leaving the default behavior
+// untouched for everyone else.
+const hasProxyConfig =
+  process.env.http_proxy || process.env.https_proxy || process.env.HTTP_PROXY || process.env.HTTPS_PROXY;
+if (hasProxyConfig) {
+  setGlobalDispatcher(new EnvHttpProxyAgent());
+}
+
 // These need to be set before Logger and other stuffs
 if (hasParam('-v') || hasParam('--verbose')) {
   process.env.CLEVER_VERBOSE = '1';

package/src/initial-update-notifier.js

@@ -5,14 +5,11 @@ import { hasParam } from './lib/has-param.js';
 // These need to be set before Logger and other stuffs
 const updateNotifierExplicitFalse = hasParam('--no-update-notifier') || hasParam('--update-notifier', 'false');
 if (!updateNotifierExplicitFalse) {
+  const docsUrl = 'https://github.com/CleverCloud/clever-tools/blob/master/docs/update.md';
   updateNotifierModule({
     pkg,
-    tagsUrl: 'https://api.github.com/repos/CleverCloud/clever-tools/tags',
   }).notify({
     isGlobal: true,
-    getDetails() {
-      const docsUrl = 'https://github.com/CleverCloud/clever-tools/tree/master/docs#how-to-use-clever-tools';
-      return `\nPlease follow this link to update your clever-tools:\n${docsUrl}`;
-    },
+    message: `Update available {currentVersion} -> {latestVersion}\nPlease follow this link to update your clever-tools:\n${docsUrl}`,
   });
 }

package/src/lib/access-logs-transport.js

@@ -0,0 +1,29 @@
+/**
+ * Transport used by the connection an access log describes.
+ * @typedef {'HTTP'|'TCP'|'SSH'} AccessLogTransport
+ */
+
+/**
+ * Guess the transport of an access log.
+ *
+ * The v4 access log payload has no explicit transport field yet, so it is inferred from the
+ * sections the API did send:
+ *
+ * - an `http` section is only emitted for connections that went through the HTTP reverse proxy,
+ * - TCP redirections go through the TCP proxy, which assigns a `requestId` but no `http` section,
+ * - direct SSH connections to the instance go through neither, so they carry neither field.
+ *
+ * Drop this function once the API exposes the transport itself.
+ *
+ * @param {object} log an access log, as emitted by `ApplicationAccessLogStream`
+ * @returns {AccessLogTransport}
+ */
+export function guessAccessLogTransport(log) {
+  if (log.http != null) {
+    return 'HTTP';
+  }
+  if (log.requestId != null) {
+    return 'TCP';
+  }
+  return 'SSH';
+}

package/src/lib/cliparse-patched.js

@@ -179,7 +179,7 @@ function wrapParser(parser) {
 // instead of cliparse.autocomplete.words(array)
 function wrapComplete(complete) {
   return (word) => {
-    // Support both functions and static arrays (e.g. complete: Drain.DRAIN_TYPE_CLI_CODES)
+    // Support both functions and static arrays (e.g. complete: ['human', 'json'])
     const result = typeof complete === 'function' ? complete(word) : complete;
     return Promise.resolve(result).then(cliparse.autocomplete.words);
   };

package/src/models/drain.js

@@ -1,5 +1,7 @@
+import { createDrain } from '../clever-client/drains.js';
 import * as Application from './application.js';
 import { resolveAddon } from './ids-resolver.js';
+import { sendToApi } from './send-to-api.js';
 
 export async function resolveDrainResource(alias, appIdOrName, addonIdOrRealId) {
   if (addonIdOrRealId != null && (appIdOrName != null || alias != null)) {
@@ -15,18 +17,37 @@ export async function resolveDrainResource(alias, appIdOrName, addonIdOrRealId)
   return { ownerId, resourceId: appId };
 }
 
-export const DRAIN_TYPES = {
-  BETTERSTACK: { apiCode: 'BETTERSTACK', cliCode: 'betterstack', label: 'Better Stack' },
-  DATADOG: { apiCode: 'DATADOG', cliCode: 'datadog', label: 'Datadog' },
-  ELASTICSEARCH: { apiCode: 'ELASTICSEARCH', cliCode: 'elasticsearch', label: 'Elasticsearch' },
-  NEWRELIC: { apiCode: 'NEWRELIC', cliCode: 'newrelic', label: 'New Relic' },
-  OVH_TCP: { apiCode: 'OVH_TCP', cliCode: 'ovh-tcp', label: 'OVH TCP' },
-  RAW_HTTP: { apiCode: 'RAW_HTTP', cliCode: 'raw-http', label: 'Raw HTTP' },
-  SYSLOG_TCP: { apiCode: 'SYSLOG_TCP', cliCode: 'syslog-tcp', label: 'Syslog TCP' },
-  SYSLOG_UDP: { apiCode: 'SYSLOG_UDP', cliCode: 'syslog-udp', label: 'Syslog UDP' },
-};
+/**
+ * Creates a log drain, the recipient options that are not set are left out of the payload.
+ * @param {string} type - Drain type, as expected by the API
+ * @param {string} ownerId
+ * @param {string} resourceId
+ * @param {string} url - Drain URL
+ * @param {Record<string, unknown>} [recipientOptions] - Extra recipient fields, `null` and `undefined` ones are ignored
+ */
+export function createLogDrain(type, ownerId, resourceId, url, recipientOptions = {}) {
+  const body = { kind: 'LOG', recipient: { type, url } };
+
+  for (const key in recipientOptions) {
+    if (recipientOptions[key] != null) {
+      body.recipient[key] = recipientOptions[key];
+    }
+  }
+
+  return createDrain({ ownerId, resourceId, body }).then(sendToApi);
+}
 
-export const DRAIN_TYPE_CLI_CODES = Object.values(DRAIN_TYPES).map(({ cliCode }) => cliCode);
+export const DRAIN_TYPE_LABELS = {
+  BETTERSTACK: 'Better Stack',
+  DATADOG: 'Datadog',
+  ELASTICSEARCH: 'Elasticsearch',
+  NEWRELIC: 'New Relic',
+  OVH_TCP: 'OVH TCP',
+  RAW_HTTP: 'Raw HTTP',
+  SPLUNK: 'Splunk',
+  SYSLOG_TCP: 'Syslog TCP',
+  SYSLOG_UDP: 'Syslog UDP',
+};
 
 function formatRate(messagesPerSecond) {
   if (messagesPerSecond < 1) {
@@ -49,14 +70,19 @@ function formatThroughput(bytesPerSecond) {
 }
 
 export function formatDrain(rawDrain) {
-  const drainType = DRAIN_TYPES[rawDrain.recipient.type];
   const drainDetails = [
     ['ID', rawDrain.id],
     ['Status', rawDrain.status.status],
     ['Execution status', rawDrain.execution.status],
     ['URL', rawDrain.recipient.url],
-    ['Type', drainType.label],
+    ['Type', DRAIN_TYPE_LABELS[rawDrain.recipient.type]],
     ['Custom index', rawDrain.recipient.index],
+    ['Sourcetype', rawDrain.recipient.sourcetype],
+    // DEFAULT is the implicit norm, only a relaxed verification is worth showing
+    [
+      'TLS verification',
+      rawDrain.recipient.tlsVerification === 'TRUSTFUL' ? 'Trustful (certificate not verified)' : null,
+    ],
     ['SD parameters', rawDrain.recipient.rfc5424StructuredDataParameters],
     ['Message output rate', formatRate(rawDrain.backlog.msgRateOut)],
     ['Message throughput', formatThroughput(rawDrain.backlog.msgThroughputOut)],

package/src/models/git-system.js

@@ -167,8 +167,8 @@ export class GitSystem extends Git {
 class GitNotFoundError extends Error {
   constructor() {
     super(
-      'The system git feature requires git to be installed and available in your PATH\n' +
-        'Either install git or disable this feature with: clever features disable system-git',
+      'git was not found in your PATH\n' +
+        'Either install git, or fall back to the previous JS implementation with: clever features disable system-git',
     );
     this.name = 'GitNotFoundError';
   }

package/src/models/git.js

@@ -30,7 +30,7 @@ export class Git {
    */
   static async get() {
     if (Git.#instance == null) {
-      const useSystemGit = await isFeatureEnabled('system-git');
+      const useSystemGit = isFeatureEnabled('system-git');
       if (useSystemGit) {
         const { GitSystem } = await import('./git-system.js');
         Git.#instance = new GitSystem();