clever-tools 4.10.0 → 5.0.0

package/src/commands/service/service.docs.md

@@ -31,7 +31,7 @@ clever service link-addon <addon-id|addon-name> [options]
 
 |Name|Description|
 |---|---|
-|`addon-id|addon-name`|Add-on ID (or name, if unambiguous)|
+|`addon-id\|addon-name`|Add-on ID (or name, if unambiguous)|
 
 ### ⚙️ Options
 
@@ -52,7 +52,7 @@ clever service link-app <app-id|app-name> [options]
 
 |Name|Description|
 |---|---|
-|`app-id|app-name`|Application ID (or name, if unambiguous)|
+|`app-id\|app-name`|Application ID (or name, if unambiguous)|
 
 ### ⚙️ Options
 
@@ -73,7 +73,7 @@ clever service unlink-addon <addon-id|addon-name> [options]
 
 |Name|Description|
 |---|---|
-|`addon-id|addon-name`|Add-on ID (or name, if unambiguous)|
+|`addon-id\|addon-name`|Add-on ID (or name, if unambiguous)|
 
 ### ⚙️ Options
 
@@ -94,7 +94,7 @@ clever service unlink-app <app-id|app-name> [options]
 
 |Name|Description|
 |---|---|
-|`app-id|app-name`|Application ID (or name, if unambiguous)|
+|`app-id\|app-name`|Application ID (or name, if unambiguous)|
 
 ### ⚙️ Options
 

package/src/commands/ssh/ssh.command.js

@@ -45,7 +45,7 @@ export const sshCommand = defineCommand({
     let sshTarget;
     if (instances.length === 1) {
       sshTarget = instances[0].id;
-    } else if (process.stdout.isTTY) {
+    } else if (process.stdin.isTTY) {
       const choices = instances
         .sort((a, b) => a.instanceNumber - b.instanceNumber)
         .map((inst) => ({
@@ -58,12 +58,18 @@ export const sshCommand = defineCommand({
     }
 
     const sshParams = [];
+    // Clever Cloud SSH only accepts key auth. Disable password fallback so a missing
+    // or unregistered key fails fast instead of prompting for a password that cannot work.
+    sshParams.push('-o', 'PreferredAuthentications=publickey', '-o', 'PasswordAuthentication=no');
     // -t: force PTY allocation (SSH skips it by default because appId is passed as a command for gateway routing)
     if (command == null) {
       sshParams.push('-t');
     }
     if (identityFile != null) {
+      // -i adds the key to the ones ssh may offer, but doesn't guarantee it's the one used
       sshParams.push('-i', identityFile);
+      // IdentitiesOnly forces ssh to only offer this key, ignoring agent/default ones
+      sshParams.push('-o', 'IdentitiesOnly=yes');
     }
     sshParams.push(config.SSH_GATEWAY, sshTarget);
 

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-clf.js

@@ -0,0 +1,52 @@
+const CLF_MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+
+/**
+ * Format a `Date` as a Common Log Format timestamp in UTC, e.g. `10/Oct/2000:13:55:36 +0000`.
+ * @param {Date} date
+ * @returns {string}
+ */
+function formatClfDate(date) {
+  const pad = (n) => String(n).padStart(2, '0');
+  const day = pad(date.getUTCDate());
+  const month = CLF_MONTHS[date.getUTCMonth()];
+  const year = date.getUTCFullYear();
+  const hours = pad(date.getUTCHours());
+  const minutes = pad(date.getUTCMinutes());
+  const seconds = pad(date.getUTCSeconds());
+  return `${day}/${month}/${year}:${hours}:${minutes}:${seconds} +0000`;
+}
+
+/**
+ * Escape a value so it can be safely embedded inside a double-quoted CLF field.
+ * Backslashes are escaped first, then double-quotes, otherwise a `"` would be escaped
+ * twice. Without this, a `"` in the value would close the quoted field early and shift
+ * every subsequent column.
+ * @param {string} value
+ * @returns {string}
+ */
+function escapeClfQuoted(value) {
+  return String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+/**
+ * Format an HTTP access log as a Common Log Format line.
+ *
+ * The HTTP protocol version is absent from the v4 access log payload, so the request line is
+ * limited to `method path` (no `HTTP/x.y` token). The protocol token is optional in CLF parsers
+ * (grok, GoAccess), and emitting a `-` placeholder would actually break their structured parsing.
+ *
+ * @see https://en.wikipedia.org/wiki/Common_Log_Format
+ * @param {object} log an HTTP access log (the `http` section must be present)
+ * @returns {string}
+ */
+export function formatClf(log) {
+  const host = log.source.ip;
+  const ident = '-';
+  const authuser = '-';
+  const date = formatClfDate(log.date);
+  const request = `${log.http.request.method} ${escapeClfQuoted(log.http.request.path)}`;
+  const status = log.http.response.statusCode;
+  const bytes = log.bytesOut;
+
+  return `${host} ${ident} ${authuser} [${date}] "${request}" ${status} ${bytes}`;
+}

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

@@ -1,4 +1,5 @@
 import cliparseOriginal from 'cliparse';
+import cliparseArgumentModule from 'cliparse/src/argument.js';
 import cliparseCommandModule from 'cliparse/src/command.js';
 import semver from 'semver';
 import pkg from '../../package.json' with { type: 'json' };
@@ -33,6 +34,23 @@ cliparseOriginal.command = function (name, options, commandFunction) {
   return command;
 };
 
+// Patch cliparse.argument.parseList to drop the parse results that succeeded
+// from its error payload. When several positional args are given and only one
+// fails its parser, parseList returns the *whole* result list (successes
+// included) as the error. Downstream, displayErrors prints the valid siblings
+// as `<arg-name>: undefined` (they carry an `.argument` but no `.error`).
+// We keep only the entries that actually failed, fixing the issue at its root.
+// The success path is untouched (we only rewrite the error array), and
+// missing-value errors carry an `.error` ("missing value") so they are kept.
+const originalParseList = cliparseArgumentModule.parseList;
+cliparseArgumentModule.parseList = function (args, providedArguments) {
+  const result = originalParseList(args, providedArguments);
+  if (Array.isArray(result.error)) {
+    return cliparseOriginal.parsers.error(result.error.filter((entry) => entry.error != null));
+  }
+  return result;
+};
+
 /**
  * Map options from cliparse format (using option.name) to the original definition keys.
  * For example, { theOptionName: defineOption({ name: 'the-option-name', ... }) },
@@ -161,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/lib/define-command.types.d.ts

@@ -41,8 +41,13 @@ export interface CommandDefinition<
    */
   featureFlag?: string;
 
-  /** Version when this command was introduced (semver format, e.g., '2.1.0'). */
-  since?: `${number}.${number}.${number}`;
+  /**
+   * Version when this command was introduced (semver format, e.g., '2.1.0').
+   * Use `null` for a command not yet released: the release workflow resolves it
+   * to the upcoming version (see `scripts/resolve-since.js`). Required on purpose,
+   * so a missing value is a type error rather than a silent omission.
+   */
+  since: `${number}.${number}.${number}` | null;
 
   /** Options (named options like --type, --region, --format). */
   options?: O;

package/src/lib/k8s.js

@@ -503,6 +503,7 @@ export async function k8sUpdateVersion(orgIdOrName, clusterIdOrName, askedVersio
     (await selectAnswer(
       `Which version do you want to update ${styleText('blue', name)} to, current is ${styleText('blue', versions.installed)}?`,
       [...versions.available].reverse(),
+      'Use --target <version> to update directly.',
     ));
 
   if (!versions.available.includes(targetVersion)) {

package/src/lib/operator-commands.js

@@ -77,6 +77,7 @@ export async function operatorUpdateVersion(provider, askedVersion, addonIdOrNam
     (await selectAnswer(
       `Which version do you want to update ${styleText('blue', name)} to, current is ${styleText('blue', versions.installed)}?`,
       versions.available.reverse(),
+      'Use --target <version> to update directly.',
     ));
 
   if (!versions.available.includes(targetVersion)) {

package/src/lib/profile.js

@@ -59,7 +59,14 @@ export async function getProfileDetails({ profile, isActive }) {
   const [user, token] = await Promise.all([
     getUser({}).then(sendWithCredentials),
     getCurrentTokenInfo().then(sendWithCredentials),
-  ]).catch(() => [null, null]);
+  ]).catch((error) => {
+    // An expired/invalid token surfaces as a 401: degrade gracefully so the command can report it.
+    // Any other failure (TLS, network…) must bubble up instead of being masked as "token invalid".
+    if (error?.cause?.response?.status === 401) {
+      return [null, null];
+    }
+    throw error;
+  });
 
   return {
     id: user?.id ?? profile.userId,

package/src/lib/prompts.js

@@ -25,11 +25,23 @@ export async function confirmAnswer(message, rejectionMessage, expectedAnswer) {
   }
 }
 
-export function selectAnswer(message, choices) {
+/**
+ * @param {string} message
+ * @param {Array<unknown>} choices
+ * @param {string} [nonInteractiveHint] How to achieve the same result without a prompt (e.g. an option to use)
+ */
+export function selectAnswer(message, choices, nonInteractiveHint) {
+  assertInteractiveTerminal(nonInteractiveHint);
   return select({ message, choices }).catch(exitOnPromptError);
 }
 
-export function promptCheckbox(message, choices) {
+/**
+ * @param {string} message
+ * @param {Array<unknown>} choices
+ * @param {string} [nonInteractiveHint] How to achieve the same result without a prompt (e.g. an option to use)
+ */
+export function promptCheckbox(message, choices, nonInteractiveHint) {
+  assertInteractiveTerminal(nonInteractiveHint);
   return checkbox({ message, choices }).catch(exitOnPromptError);
 }
 
@@ -50,6 +62,22 @@ export function promptTextOption(option, defaultValue) {
   return input({ message, default: defaultValue, validate }).catch(exitOnPromptError);
 }
 
+/**
+ * Throw an explicit error when no interactive terminal is available.
+ *
+ * Raw-mode prompts (select, checkbox) need a TTY on stdin. Without one (CI, scripts,
+ * pipes, `< /dev/null`), Inquirer reads EOF and throws ExitPromptError, which
+ * exitOnPromptError turns into a silent `process.exit(1)` — indistinguishable from a
+ * user pressing Ctrl+C. Guarding up front lets us surface a clear message instead.
+ * @param {string} [hint] How to achieve the same result without a prompt (e.g. an option to use)
+ */
+function assertInteractiveTerminal(hint) {
+  if (!process.stdin.isTTY) {
+    const suffix = hint != null ? ` ${hint}` : '';
+    throw new Error(`This command requires an interactive terminal.${suffix}`);
+  }
+}
+
 function exitOnPromptError(error) {
   if (error instanceof Error && error.name === 'ExitPromptError') {
     process.exit(1);

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,17 +17,37 @@ export async function resolveDrainResource(alias, appIdOrName, addonIdOrRealId)
   return { ownerId, resourceId: appId };
 }
 
-export const DRAIN_TYPES = {
-  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) {
@@ -48,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-isomorphic.js

@@ -13,6 +13,9 @@ export class GitIsomorphic extends Git {
 
   async #getRepo() {
     const dir = await this._getRepoDir();
+    if (await this._isLinkedWorktree(dir)) {
+      throw new LinkedWorktreeNotSupportedError();
+    }
     return { fs, dir, http };
   }
 
@@ -128,7 +131,8 @@ export class GitIsomorphic extends Git {
    */
   async isInsideGitRepo() {
     this._debug('isInsideGitRepo');
-    return this.#getRepo()
+    // Don't go through #getRepo: it rejects linked worktrees, which are still git repos
+    return this._getRepoDir()
       .then(() => true)
       .catch(() => false);
   }
@@ -151,3 +155,14 @@ export class GitIsomorphic extends Git {
     return isStatusEmpty;
   }
 }
+
+export class LinkedWorktreeNotSupportedError extends Error {
+  constructor() {
+    super(
+      "Linked git worktrees aren't supported by the default JS git backend.\n" +
+        'Enable the system git backend (it uses your installed git):\n' +
+        '    clever features enable system-git',
+    );
+    this.name = 'LinkedWorktreeNotSupportedError';
+  }
+}

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';
   }