clever-tools 4.4.1 → 4.5.0

package/src/commands/create.js

@@ -1,129 +0,0 @@
-import path from 'node:path';
-import { styleText } from '../lib/style-text.js';
-import { Logger } from '../logger.js';
-import * as AppConfig from '../models/app_configuration.js';
-import * as Application from '../models/application.js';
-import { conf } from '../models/configuration.js';
-import { isGitWorkingDirectoryClean, isInsideGitRepo } from '../models/git.js';
-
-export async function create(params) {
-  const { type: typeName } = params.options;
-  const [rawName] = params.args;
-  const { org: orgaIdOrName, alias, region, github: githubOwnerRepo, format, task: taskCommand } = params.options;
-  const { apps } = await AppConfig.loadApplicationConf();
-
-  // Application name is optionnal, use current directory name if not specified (empty string)
-  const name = rawName !== '' ? rawName : getCurrentDirectoryName();
-
-  const isTask = taskCommand != null;
-  const envVars = isTask ? { CC_RUN_COMMAND: taskCommand } : {};
-
-  AppConfig.checkAlreadyLinked(apps, name, alias);
-
-  const github = getGithubDetails(githubOwnerRepo);
-  const app = await Application.create(name, typeName, region, orgaIdOrName, github, isTask, envVars);
-  await AppConfig.addLinkedApplication(app, alias);
-
-  switch (format) {
-    case 'json': {
-      Logger.printJson({
-        id: app.id,
-        name: app.name,
-        executedAs: app.instance.lifetime,
-        env: app.env,
-        deployUrl: app.deployUrl,
-      });
-      break;
-    }
-
-    case 'human':
-    default:
-      await displayAppCreation(app, alias, github, taskCommand);
-  }
-}
-
-function getGithubDetails(githubOwnerRepo) {
-  if (githubOwnerRepo != null) {
-    const [owner, name] = githubOwnerRepo.split('/');
-    return { owner, name };
-  }
-}
-
-function getCurrentDirectoryName() {
-  return path.basename(process.cwd());
-}
-
-/**
- * Display the application creation message in a human-readable format
- * @param {Object} app - The application object
- * @param {string} alias - The alias of the application
- * @param {Object} github - The GitHub details
- * @param {string} taskCommand - The task command
- */
-async function displayAppCreation(app, alias, github, taskCommand) {
-  Logger.printSuccess(`Application ${styleText('green', app.name)} successfully created!`);
-
-  const hasDistinctAlias = alias != null && alias !== app.name;
-  const isTask = app.instance.lifetime === 'TASK';
-
-  Logger.println();
-  printFieldsAsTable(2, {
-    Type: styleText('blue', `⬢ ${app.instance.variant.name}`),
-    ID: app.id,
-    'Organisation ID': app.ownerId,
-    Name: app.name,
-    GitHub: github != null && `${github.owner}/${github.name}`,
-    Alias: hasDistinctAlias && alias,
-    Zone: app.zone,
-    Task: isTask && `"${taskCommand}"`,
-  });
-
-  Logger.println();
-  Logger.println('  ' + styleText('bold', 'Next steps:'));
-
-  if (!github) {
-    const isInsideGit = await isInsideGitRepo();
-    if (!isInsideGit) {
-      Logger.println(`  ${styleText('yellow', '!')} Initialize a git repository first, for example:`);
-      Logger.println(`    ${shellCommand('git init')}`);
-      Logger.println(`    ${shellCommand('git add .')}`);
-      Logger.println(`    ${shellCommand('git commit -m "Initial commit"')}`);
-      Logger.println();
-    } else {
-      const isClean = await isGitWorkingDirectoryClean();
-      if (!isClean) {
-        Logger.println(`  ${styleText('yellow', '!')} Commit your changes first:`);
-        Logger.println(`    ${shellCommand('git add .')}`);
-        Logger.println(`    ${shellCommand('git commit -m "My changes"')}`);
-        Logger.println();
-      }
-    }
-  }
-
-  if (github) {
-    Logger.println(
-      `  ${styleText('blue', '→')} Push changes to ${styleText('blue', `${github.owner}/${github.name}`)} GitHub repository to trigger a deployment, or ${styleText('blue', 'clever restart')} the latest pushed commit`,
-    );
-  } else {
-    Logger.println(
-      `  ${styleText('blue', '→')} Run ${styleText('blue', 'clever deploy')} ${isTask ? 'to execute your task' : 'to deploy your application'}`,
-    );
-  }
-
-  Logger.println(
-    `  ${styleText('blue', '→')} Manage your application at: ${styleText('underline', `${conf.GOTO_URL}/${app.id}`)}`,
-  );
-  Logger.println('');
-}
-
-function shellCommand(command) {
-  return `${styleText('grey', '$')} ${styleText('yellow', command)}`;
-}
-
-function printFieldsAsTable(indent, fields) {
-  const fieldsWithValues = Object.fromEntries(Object.entries(fields).filter(([_, value]) => typeof value === 'string'));
-  const labelMaxWidth = Math.max(...Object.keys(fieldsWithValues).map((label) => label.length));
-  return Object.entries(fieldsWithValues).forEach(([label, value]) => {
-    Logger.println(`${' '.repeat(indent)}${label.padEnd(labelMaxWidth, ' ')}  ${styleText('grey', value)}`);
-  });
-}

package/src/commands/database.js

@@ -1,73 +0,0 @@
-import { getBackups } from '@clevercloud/client/esm/api/v2/backups.js';
-import fs from 'node:fs';
-import { Writable } from 'node:stream';
-import { formatTable } from '../format-table.js';
-import { Logger } from '../logger.js';
-import { findOwnerId } from '../models/addon.js';
-import { resolveAddonId, resolveRealId } from '../models/ids-resolver.js';
-import { sendToApi } from '../models/send-to-api.js';
-
-export async function listBackups(params) {
-  const { org, format } = params.options;
-  const [addonIdOrRealId] = params.args;
-
-  const realId = await resolveRealId(addonIdOrRealId);
-  const addonId = await resolveAddonId(addonIdOrRealId);
-  const ownerId = await findOwnerId(org, realId);
-
-  const backups = await getBackups({ ownerId, ref: realId }).then(sendToApi);
-
-  if (backups.length === 0 && format === 'human') {
-    Logger.println('There are no backups yet');
-    return;
-  }
-
-  const sortedBackups = backups.sort((a, b) => a.creation_date.localeCompare(b.creation_date));
-
-  switch (format) {
-    case 'json': {
-      const formattedBackups = sortedBackups.map((backup) => {
-        return {
-          addonId: addonId,
-          backupId: backup.backup_id,
-          creationDate: backup.creation_date,
-          downloadUrl: backup.download_url,
-          ownerId: ownerId,
-          realId: realId,
-          status: backup.status,
-        };
-      });
-      Logger.printJson(formattedBackups);
-      break;
-    }
-    case 'human': {
-      const formattedLines = sortedBackups.map((backup) => [backup.backup_id, backup.creation_date, backup.status]);
-
-      const head = ['BACKUP ID', 'CREATION DATE', 'STATUS'];
-
-      Logger.println(formatTable([head, ...formattedLines]));
-    }
-  }
-}
-
-export async function downloadBackups(params) {
-  const { org, output } = params.options;
-  const [addonIdOrRealId, backupId] = params.args;
-
-  const addonId = await resolveRealId(addonIdOrRealId);
-  const ownerId = await findOwnerId(org, addonId);
-
-  const backups = await getBackups({ ownerId, ref: addonId }).then(sendToApi);
-  const backup = backups.find((backup) => backup.backup_id === backupId);
-
-  if (backup == null) {
-    throw new Error('no backup with this ID');
-  }
-
-  const response = await globalThis.fetch(backup.download_url);
-  if (!response.ok) {
-    throw new Error('Failed to download backup');
-  }
-
-  await response.body.pipeTo(Writable.toWeb(output ? fs.createWriteStream(output) : process.stdout));
-}

package/src/commands/delete.js

@@ -1,24 +0,0 @@
-import { styleText } from '../lib/style-text.js';
-import { Logger } from '../logger.js';
-import * as AppConfig from '../models/app_configuration.js';
-import * as Application from '../models/application.js';
-
-export async function deleteApp(params) {
-  const { alias, app: appIdOrName, yes: skipConfirmation } = params.options;
-  const { ownerId, appId } = await Application.resolveId(appIdOrName, alias);
-
-  const app = await Application.get(ownerId, appId);
-  if (app == null) {
-    throw new Error("The application doesn't exist");
-  }
-
-  // delete app
-  await Application.deleteApp(app, skipConfirmation);
-  Logger.printSuccess(`Application ${styleText('green', styleText('bold', `${app.name}`))} successfully deleted!`);
-  Logger.println(`  ${styleText('grey', '•')} Application ID: ${styleText('grey', app.id)}`);
-
-  const wasUnlinked = await AppConfig.removeLinkedApplication({ appId, alias });
-  if (wasUnlinked) {
-    Logger.println(`  ${styleText('blue', '→')} Local alias ${styleText('blue', alias || app.name)} unlinked`);
-  }
-}

package/src/commands/deploy.js

@@ -1,133 +0,0 @@
-import { getAllDeployments } from '@clevercloud/client/esm/api/v2/application.js';
-import dedent from 'dedent';
-import { styleText } from '../lib/style-text.js';
-import { Logger } from '../logger.js';
-import * as AppConfig from '../models/app_configuration.js';
-import * as Application from '../models/application.js';
-import * as ExitStrategy from '../models/exit-strategy-option.js';
-import * as git from '../models/git.js';
-import * as Log from '../models/log-v4.js';
-import { sendToApi } from '../models/send-to-api.js';
-
-// Once the API call to redeploy() has been triggered successfully,
-// the rest (waiting for deployment state to evolve and displaying logs) is done with auto retry (resilient to network failures)
-export async function deploy(params) {
-  const {
-    alias,
-    branch: branchName,
-    tag: tagName,
-    quiet,
-    force,
-    follow,
-    'same-commit-policy': sameCommitPolicy,
-    'exit-on': exitOnDeploy,
-  } = params.options;
-
-  const exitStrategy = ExitStrategy.get(follow, exitOnDeploy);
-
-  const appData = await AppConfig.getAppDetails({ alias });
-  const { ownerId, appId } = appData;
-
-  const branchRefspec = await getBranchToDeploy(branchName, tagName);
-  const commitIdToPush = await git.getBranchCommit(branchRefspec);
-  const remoteHeadCommitId = await git.getRemoteCommit(appData.deployUrl);
-  const deployedCommitId = await Application.get(ownerId, appId).then(({ commitId }) => commitId);
-
-  await git.addRemote(appData.alias, appData.deployUrl);
-
-  if (commitIdToPush === remoteHeadCommitId) {
-    switch (sameCommitPolicy) {
-      case 'ignore':
-        Logger.printSuccess(`The application is up-to-date (${styleText('grey', remoteHeadCommitId)})`);
-        return;
-      case 'restart':
-        return restartOnSameCommit(ownerId, appId, commitIdToPush, quiet, false, exitStrategy);
-      case 'rebuild':
-        return restartOnSameCommit(ownerId, appId, commitIdToPush, quiet, true, exitStrategy);
-      case 'error':
-      default: {
-        const restartCommand =
-          commitIdToPush !== deployedCommitId ? `clever restart --commit ${commitIdToPush}` : 'clever restart';
-        throw new Error(dedent`
-          Remote HEAD has the same commit as the one to push ${styleText('grey', `(${remoteHeadCommitId})`)}, your application is up-to-date.
-          Create a new commit, use ${styleText('blue', restartCommand)} or the ${styleText('blue', '--same-commit-policy')} option.
-        `);
-      }
-    }
-  }
-
-  // It's sometimes tricky to figure out the deployment ID for the current git push.
-  // We on have the commit ID but there in a situation where the last deployment was cancelled, it may have the same commit ID.
-  // So before pushing, we get the last deployments so we can after the push figure out which deployment is new…
-  const knownDeployments = await getAllDeployments({ id: ownerId, appId, limit: 5 }).then(sendToApi);
-
-  Logger.println(dedent`
-    ${styleText('bold', `🚀 Deploying ${styleText('green', appData.name)}`)}
-       Application ID  ${styleText('grey', `${appId}`)}
-       Organisation ID ${styleText('grey', `${ownerId}`)}
-  `);
-
-  Logger.println();
-
-  Logger.println(styleText('bold', '🔀 Git information'));
-  if (remoteHeadCommitId == null || deployedCommitId == null) {
-    Logger.println(`   ${styleText('yellow', '!')} App is brand new, no commits on remote yet`);
-  } else {
-    Logger.println(`   Remote head     ${styleText('yellow', remoteHeadCommitId)} (${branchRefspec})`);
-    Logger.println(`   Deployed commit ${styleText('yellow', deployedCommitId)}`);
-  }
-  Logger.println(
-    `   Local commit    ${styleText('yellow', commitIdToPush)} ${styleText('blue', '[will be deployed]')}`,
-  );
-
-  Logger.println();
-
-  Logger.println(dedent`
-    ${styleText('bold', '🔄 Deployment progress')}
-       ${styleText('blue', '→ Pushing source code to Clever Cloud…')}
-  `);
-
-  await git.push(appData.deployUrl, commitIdToPush, force).catch(async (e) => {
-    const isShallow = await git.isShallow();
-    if (isShallow) {
-      throw new Error(
-        'Failed to push your source code because your repository is shallow and therefore cannot be pushed to the Clever Cloud remote.',
-      );
-    } else {
-      throw e;
-    }
-  });
-
-  await Logger.println(`   ${styleText('green', '✓ Code pushed to Clever Cloud')}`);
-
-  return Log.watchDeploymentAndDisplayLogs({
-    ownerId,
-    appId,
-    commitId: commitIdToPush,
-    knownDeployments,
-    quiet,
-    exitStrategy,
-  });
-}
-
-async function restartOnSameCommit(ownerId, appId, commitIdToPush, quiet, withoutCache, exitStrategy) {
-  const cacheSuffix = withoutCache ? ' without using cache' : '';
-  Logger.println(`🔄 Restarting ${styleText('bold', appId)}${cacheSuffix} ${styleText('grey', `(${commitIdToPush})`)}`);
-
-  const restart = await Application.redeploy(ownerId, appId, commitIdToPush, withoutCache);
-  return Log.watchDeploymentAndDisplayLogs({ ownerId, appId, deploymentId: restart.deploymentId, quiet, exitStrategy });
-}
-
-async function getBranchToDeploy(branchName, tagName) {
-  if (tagName) {
-    const useTag = await git.isExistingTag(tagName);
-    if (useTag) {
-      const tagRefspec = await git.getFullBranch(tagName);
-      return tagRefspec;
-    } else {
-      throw new Error(`Tag ${tagName} doesn't exist locally`);
-    }
-  } else {
-    return await git.getFullBranch(branchName);
-  }
-}

package/src/commands/diag.js

@@ -1,126 +0,0 @@
-import { releaseInfo as getLinuxInfos } from 'linux-release-info';
-import os from 'node:os';
-import pkg from '../../package.json' with { type: 'json' };
-import { styleText } from '../lib/style-text.js';
-import { Logger } from '../logger.js';
-import { conf, loadOAuthConf } from '../models/configuration.js';
-import * as User from '../models/user.js';
-
-export async function diag(params) {
-  const { format } = params.options;
-
-  /** @type {string} */
-  const userId = await User.getCurrentId().catch(() => null);
-  const authDetails = await loadOAuthConf();
-
-  function getAuthState() {
-    if (authDetails.token == null) {
-      return 'not connected';
-    }
-    if (userId == null) {
-      return 'authentication failed';
-    }
-    return 'authenticated';
-  }
-
-  const formattedDiag = {
-    version: pkg.version,
-    commitId: pkg.commitId,
-    nodeVersion: process.version,
-    platform: os.platform(),
-    release: os.release(),
-    arch: process.arch,
-    shell: getShell(),
-    terminal: getTerminal(),
-    isPackaged: process.pkg != null,
-    execPath: process.execPath,
-    configFile: conf.CONFIGURATION_FILE,
-    authSource: authDetails.source,
-    oAuthToken: authDetails.token,
-    authState: getAuthState(),
-    userId,
-  };
-
-  const linuxInfos = await getLinuxInfos()
-    .then(({ pretty_name, name, id }) => pretty_name || name || id)
-    .catch(() => null);
-  if (linuxInfos != null) {
-    formattedDiag.linuxInfos = linuxInfos;
-  }
-
-  switch (format) {
-    case 'json': {
-      Logger.printJson(formattedDiag);
-      break;
-    }
-    case 'human':
-    default: {
-      Logger.println('clever-tools  ' + styleText('green', formattedDiag.version));
-      // Only available in built binaries
-      if (formattedDiag.commitId) {
-        Logger.println('Commit        ' + styleText('green', formattedDiag.commitId));
-      }
-      Logger.println('Node.js       ' + styleText('green', formattedDiag.nodeVersion));
-      Logger.println('Platform      ' + styleText('green', formattedDiag.platform));
-      Logger.println('Release       ' + styleText('green', formattedDiag.release));
-      Logger.println('Architecture  ' + styleText('green', formattedDiag.arch));
-      if (formattedDiag.linuxInfos != null) {
-        Logger.println('Linux         ' + styleText('green', formattedDiag.linuxInfos));
-      }
-      Logger.println('Shell         ' + styleText('green', formattedDiag.shell));
-      Logger.println('Terminal      ' + styleText('green', formattedDiag.terminal));
-      Logger.println('Packaged      ' + styleText('green', formattedDiag.isPackaged));
-      Logger.println('Exec path     ' + styleText('green', formattedDiag.execPath));
-      Logger.println('Config file   ' + styleText('green', formattedDiag.configFile));
-
-      Logger.println('Auth source   ' + styleText('green', formattedDiag.authSource));
-
-      const token =
-        formattedDiag.oAuthToken == null ? styleText('red', '(none)') : styleText('green', formattedDiag.oAuthToken);
-      Logger.println('oAuth token   ' + token);
-
-      switch (formattedDiag.authState) {
-        case 'authenticated': {
-          Logger.println('User ID       ' + styleText('green', formattedDiag.userId));
-          break;
-        }
-        case 'authentication failed': {
-          Logger.println('User ID       ' + styleText('red', 'Authentication failed'));
-          break;
-        }
-        case 'not connected': {
-          Logger.println('User ID       ' + styleText('red', 'Not connected'));
-        }
-      }
-    }
-  }
-}
-
-function getShell() {
-  const platform = os.platform();
-
-  if (platform === 'win32') {
-    if (process.env.PSModulePath) {
-      if (process.env.WT_SESSION) {
-        return 'PowerShell (Windows Terminal)';
-      }
-      if (process.env.PSVersionTable || process.env.POWERSHELL_DISTRIBUTION_CHANNEL) {
-        return 'PowerShell Core';
-      }
-      return 'Windows PowerShell';
-    }
-    if (process.env.WT_SESSION) {
-      return 'Windows Terminal (cmd)';
-    }
-    return process.env.ComSpec || 'cmd.exe';
-  }
-
-  return process.env.SHELL || 'unknown';
-}
-
-function getTerminal() {
-  if (process.env.WT_SESSION) {
-    return 'Windows Terminal';
-  }
-  return process.env.TERM_PROGRAM || process.env.TERMINAL_EMULATOR || process.env.TERM;
-}