adapt-cli 2.1.13 → 3.0.0

package/lib/integration/Plugin.js

@@ -0,0 +1,403 @@
+import slug from 'speakingurl'
+import globs from 'globs'
+import bower from 'bower'
+import endpointParser from 'bower-endpoint-parser'
+import semver from 'semver'
+import fs from 'fs-extra'
+import path from 'path'
+import getBowerRegistryConfig from './getBowerRegistryConfig.js'
+import { ADAPT_ALLOW_PRERELEASE, PLUGIN_TYPES, PLUGIN_TYPE_FOLDERS, PLUGIN_DEFAULT_TYPE } from '../util/constants.js'
+/** @typedef {import("./Project.js").default} Project */
+const semverOptions = { includePrerelease: ADAPT_ALLOW_PRERELEASE }
+
+// when a bower command errors this is the maximum number of attempts the command will be repeated
+const BOWER_MAX_TRY = 5
+
+export default class Plugin {
+  /**
+   * @param {Object} options
+   * @param {string} options.name
+   * @param {string} options.requestedVersion
+   * @param {boolean} options.isContrib
+   * @param {boolean} options.isCompatibleEnabled whether to target the latest compatible version for all plugin installations (overrides requestedVersion)
+   * @param {Project} options.project
+   * @param {string} options.cwd
+   * @param {Object} options.logger
+   */
+  constructor ({
+    name,
+    requestedVersion = '*',
+    isContrib = false,
+    isCompatibleEnabled = false,
+    project,
+    cwd = (project?.cwd ?? process.cwd()),
+    logger
+  } = {}) {
+    this.logger = logger
+    /** @type {Project} */
+    this.project = project
+    this.cwd = cwd
+    this.BOWER_REGISTRY_CONFIG = getBowerRegistryConfig({ cwd: this.cwd })
+    const endpoint = name + '#' + (isCompatibleEnabled ? '*' : requestedVersion)
+    const ep = endpointParser.decompose(endpoint)
+    this.sourcePath = null
+    this.name = ep.name || ep.source
+    this.packageName = (/^adapt-/i.test(this.name) ? '' : 'adapt-') + (!isContrib ? '' : 'contrib-') + slug(this.name, { maintainCase: true })
+    // the constraint given by the user
+    this.requestedVersion = requestedVersion
+    // the most recent version of the plugin compatible with the given framework
+    this.latestCompatibleSourceVersion = null
+    // a non-wildcard constraint resolved to the highest version of the plugin that satisfies the requestedVersion and is compatible with the framework
+    this.matchedVersion = null
+    // a flag describing if the plugin can be updated
+    this.canBeUpdated = null
+
+    const isNameAPath = /\\|\//g.test(this.name)
+    const isVersionAPath = /\\|\//g.test(this.requestedVersion)
+    const isLocalPath = (isNameAPath || isVersionAPath)
+    if (isLocalPath) {
+      // wait to name the plugin until the local config file is loaded
+      this.sourcePath = isNameAPath ? this.name : this.requestedVersion
+      this.name = isVersionAPath ? this.packageName : ''
+      this.packageName = isNameAPath ? '' : this.packageName
+      this.requestedVersion = '*'
+    }
+    // the path of the source files
+    this.projectPath = null
+    // the project plugin .bower.json or bower.json
+    this._projectInfo = null
+    // the result of a query to the server or disk for source files
+    this._sourceInfo = null
+    // server given versions
+    this._versionsInfo = null
+
+    Plugin.instances.push(this)
+  }
+
+  /**
+   * the installed version is the latest version
+   * @returns {boolean|null}
+   */
+  get isUpToDate () {
+    const canCheckSourceAgainstProject = (this.latestSourceVersion && this.projectVersion)
+    if (!canCheckSourceAgainstProject) return null
+    const isLatestVersion = (this.projectVersion === this.latestSourceVersion)
+    const isLatestMatchedVersion = (this.projectVersion === this.matchedVersion)
+    const isProjectVersionGreater = semver.gt(this.projectVersion, this.matchedVersion)
+    return (isLatestVersion || isLatestMatchedVersion || isProjectVersionGreater)
+  }
+
+  /**
+   * the most recent version of the plugin
+   * @returns {string|null}
+   */
+  get latestSourceVersion () {
+    return (this._sourceInfo?.version || null)
+  }
+
+  /**
+   * the installed version of the plugin
+   * @returns {string|null}
+   */
+  get projectVersion () {
+    return (this._projectInfo?.version || null)
+  }
+
+  /**
+   * a list of tags denoting the source versions of the plugin
+   * @returns {[string]}
+   */
+  get sourceVersions () {
+    return this._versionsInfo
+  }
+
+  /**
+   * plugin will be or was installed from a local source
+   * @returns {boolean}
+   */
+  get isLocalSource () {
+    return Boolean(this.sourcePath || this?._projectInfo?._wasInstalledFromPath)
+  }
+
+  /**
+   * check if source path is a zip
+   * @returns {boolean}
+   */
+  get isLocalSourceZip () {
+    return Boolean(this.isLocalSource && (this.sourcePath?.includes('.zip') || this._projectInfo?._source?.includes('.zip')))
+  }
+
+  /** @returns {boolean} */
+  get isVersioned () {
+    return Boolean(this.sourceVersions?.length)
+  }
+
+  /**
+   * is a contrib plugin
+   * @returns {boolean}
+   */
+  get isContrib () {
+    return /^adapt-contrib/.test(this.packageName)
+  }
+
+  /**
+   * whether querying the server or disk for plugin information worked
+   * @returns {boolean}
+   */
+  get isPresent () {
+    return Boolean(this._projectInfo || this._sourceInfo)
+  }
+
+  /**
+   * has user requested version
+   * @returns {boolean}
+   */
+  get hasUserRequestVersion () {
+    return (this.requestedVersion !== '*')
+  }
+
+  /**
+   * the supplied a constraint is valid and supported by the plugin
+   * @returns {boolean|null}
+   */
+  get hasValidRequestVersion () {
+    return (this.latestSourceVersion)
+      ? semver.validRange(this.requestedVersion, semverOptions) &&
+        (this.isVersioned
+          ? semver.maxSatisfying(this.sourceVersions, this.requestedVersion, semverOptions) !== null
+          : semver.satisfies(this.latestSourceVersion, this.requestedVersion)
+        )
+      : null
+  }
+
+  /** @returns {boolean} */
+  get hasFrameworkCompatibleVersion () {
+    return (this.latestCompatibleSourceVersion !== null)
+  }
+
+  async fetchSourceInfo () {
+    if (this.isLocalSource) return await this.fetchLocalSourceInfo()
+    await this.fetchBowerInfo()
+  }
+
+  async fetchLocalSourceInfo () {
+    if (this._sourceInfo) return this._sourceInfo
+    this._sourceInfo = null
+    if (!this.isLocalSource) throw new Error('Plugin name or version must be a path to the source')
+    if (this.isLocalSourceZip) throw new Error('Cannot install from zip files')
+    this._sourceInfo = await new Promise((resolve, reject) => {
+      // get bower.json data
+      const paths = [
+        path.resolve(this.cwd, `${this.sourcePath}/bower.json`)
+      ]
+      const bowerJSON = paths.reduce((bowerJSON, bowerJSONPath) => {
+        if (bowerJSON) return bowerJSON
+        if (!fs.existsSync(bowerJSONPath)) return null
+        return fs.readJSONSync(bowerJSONPath)
+      }, null)
+      resolve(bowerJSON)
+    })
+    if (!this._sourceInfo) return
+    this.name = this._sourceInfo.name
+    this.matchedVersion = this.latestSourceVersion
+    this.packageName = this.name
+  }
+
+  async fetchBowerInfo () {
+    if (this._sourceInfo) return this._sourceInfo
+    this._sourceInfo = null
+    if (this.isLocalSource) return
+    const perform = async (attemptCount = 0) => {
+      try {
+        return await new Promise((resolve, reject) => {
+          bower.commands.info(`${this.packageName}`, null, { cwd: this.cwd, registry: this.BOWER_REGISTRY_CONFIG })
+            .on('end', resolve)
+            .on('error', reject)
+        })
+      } catch (err) {
+        const isFinished = (err?.code === 'ENOTFOUND' || attemptCount >= BOWER_MAX_TRY)
+        if (isFinished) return null
+        return await perform(attemptCount++)
+      }
+    }
+    const info = await perform()
+    if (!info) return
+    this._sourceInfo = info.latest
+    this._versionsInfo = info.versions.filter(version => semverOptions.includePrerelease ? true : !semver.prerelease(version))
+  }
+
+  async fetchProjectInfo () {
+    if (this._projectInfo) return this._projectInfo
+    this._projectInfo = null
+    this._projectInfo = await new Promise((resolve, reject) => {
+      // get bower.json data
+      globs([
+        `${this.cwd.replace(/\\/g, '/')}/src/*/${this.packageName}/.bower.json`,
+        `${this.cwd.replace(/\\/g, '/')}/src/*/${this.packageName}/bower.json`
+      ], (err, matches) => {
+        if (err) return resolve(null)
+        const tester = new RegExp(`/${this.packageName}/`, 'i')
+        const match = matches.find(match => tester.test(match))
+        if (!match) {
+          // widen the search
+          globs([
+            `${this.cwd.replace(/\\/g, '/')}/src/**/.bower.json`,
+            `${this.cwd.replace(/\\/g, '/')}/src/**/bower.json`
+          ], (err, matches) => {
+            if (err) return resolve(null)
+            const tester = new RegExp(`/${this.packageName}/`, 'i')
+            const match = matches.find(match => tester.test(match))
+            if (!match) return resolve(null)
+            this.projectPath = path.resolve(match, '../')
+            resolve(fs.readJSONSync(match))
+          })
+          return
+        }
+        this.projectPath = path.resolve(match, '../')
+        resolve(fs.readJSONSync(match))
+      })
+    })
+    if (!this._projectInfo) return
+    this.name = this._projectInfo.name
+    this.packageName = this.name
+  }
+
+  async findCompatibleVersion (framework) {
+    const getBowerVersionInfo = async (version) => {
+      const perform = async (attemptCount = 0) => {
+        try {
+          return await new Promise((resolve, reject) => {
+            bower.commands.info(`${this.packageName}@${version}`, null, { cwd: this.cwd, registry: this.BOWER_REGISTRY_CONFIG })
+              .on('end', resolve)
+              .on('error', reject)
+          })
+        } catch (err) {
+          const isFinished = (err?.code === 'ENOTFOUND' || attemptCount >= BOWER_MAX_TRY)
+          if (isFinished) return null
+          return await perform(attemptCount++)
+        }
+      }
+      return await perform()
+    }
+    const getMatchingVersion = async () => {
+      if (this.isLocalSource) {
+        const info = this.projectVersion ? this._projectInfo : this._sourceInfo
+        const satisfiesConstraint = !this.hasValidRequestVersion || semver.satisfies(info.version, this.requestedVersion, semverOptions)
+        const satisfiesFramework = semver.satisfies(framework, info.framework)
+        if (satisfiesFramework && satisfiesConstraint) this.latestCompatibleSourceVersion = info.version
+        return info.version
+      }
+
+      if (!this.isPresent) return null
+
+      // check if the latest version is compatible
+      const satisfiesConstraint = !this.hasValidRequestVersion || semver.satisfies(this._sourceInfo.version, this.requestedVersion, semverOptions)
+      const satisfiesFramework = semver.satisfies(framework, this._sourceInfo.framework, semverOptions)
+      if (!this.latestCompatibleSourceVersion && satisfiesFramework) this.latestCompatibleSourceVersion = this.latestSourceVersion
+      if (satisfiesConstraint && satisfiesFramework) {
+        return this.latestSourceVersion
+      }
+
+      if (!this.isVersioned) return null
+
+      // find the highest version that is compatible with the framework and constraint
+      const searchVersionInfo = async (framework, versionIndex = 0) => {
+        const versioninfo = await getBowerVersionInfo(this.sourceVersions[versionIndex])
+        // give up if there is any failure to obtain version info
+        if (!this.isPresent) return null
+        // check that the proposed plugin is compatible with the contraint and installed framework
+        const satisfiesConstraint = !this.hasValidRequestVersion || semver.satisfies(versioninfo.version, this.requestedVersion, semverOptions)
+        const satisfiesFramework = semver.satisfies(framework, versioninfo.framework, semverOptions)
+        if (!this.latestCompatibleSourceVersion && satisfiesFramework) this.latestCompatibleSourceVersion = versioninfo.version
+        const checkNext = (!satisfiesFramework || !satisfiesConstraint)
+        const hasNoMoreVersions = (versionIndex + 1 >= this.sourceVersions.length)
+        if (checkNext && hasNoMoreVersions) return null
+        if (checkNext) return await searchVersionInfo(framework, versionIndex + 1)
+        return versioninfo.version
+      }
+      return await searchVersionInfo(framework)
+    }
+    this.matchedVersion = await getMatchingVersion()
+    this.canBeUpdated = (this.projectVersion && this.matchedVersion) && (this.projectVersion !== this.matchedVersion)
+  }
+
+  /**
+   * @returns {string}
+   */
+  async getType () {
+    if (this._type) return this._type
+    const info = await this.getInfo()
+    const foundAttributeType = PLUGIN_TYPES.find(type => info[type])
+    const foundKeywordType = info.keywords
+      .map(keyword => {
+        const typematches = PLUGIN_TYPES.filter(type => keyword?.toLowerCase()?.includes(type))
+        return typematches.length ? typematches[0] : null
+      })
+      .filter(Boolean)[0]
+    return (this._type = foundAttributeType || foundKeywordType || PLUGIN_DEFAULT_TYPE)
+  }
+
+  async getTypeFolder () {
+    const type = await this.getType()
+    return PLUGIN_TYPE_FOLDERS[type]
+  }
+
+  async getInfo () {
+    if (this._projectInfo) return this._projectInfo
+    if (!this._sourceInfo) await this.fetchSourceInfo()
+    return this._sourceInfo
+  }
+
+  async getRepositoryUrl () {
+    if (this._repositoryUrl) return this._repositoryUrl
+    if (this.isLocalSource) return
+    const url = await new Promise((resolve, reject) => {
+      bower.commands.lookup(this.packageName, { cwd: this.cwd, registry: this.BOWER_REGISTRY_CONFIG })
+        .on('end', resolve)
+        .on('error', reject)
+    })
+    return (this._repositoryUrl = url)
+  }
+
+  /** @returns {string} */
+  toString () {
+    const isAny = (this.projectVersion === '*' || this.projectVersion === null)
+    return `${this.packageName}${isAny ? '' : `@${this.projectVersion}`}`
+  }
+
+  async getSchemaPaths () {
+    if (this.isLocalSource) await this.fetchLocalSourceInfo()
+    else if (this.project) await this.fetchProjectInfo()
+    else throw new Error(`Cannot fetch schemas from remote plugin: ${this.name}`)
+    const pluginPath = this.projectPath ?? this.sourcePath
+    return new Promise((resolve, reject) => {
+      return globs(path.resolve(this.cwd, pluginPath, '**/*.schema.json'), (err, matches) => {
+        if (err) return reject(err)
+        resolve(matches)
+      })
+    })
+  }
+
+  /**
+   * Read plugin data from pluginPath
+   * @param {Object} options
+   * @param {string} options.pluginPath Path to source directory
+   * @param {string} [options.projectPath=process.cwd()] Optional path to potential installation project
+   * @returns {Plugin}
+   */
+  static async fromPath ({
+    pluginPath,
+    projectPath = process.cwd()
+  }) {
+    const plugin = new Plugin({
+      name: pluginPath,
+      cwd: projectPath
+    })
+    await plugin.fetchLocalSourceInfo()
+    return plugin
+  }
+
+  static get instances () {
+    return (Plugin._instances = Plugin._instances || [])
+  }
+}

package/lib/integration/PluginManagement/autenticate.js

@@ -0,0 +1,56 @@
+import chalk from 'chalk'
+import inquirer from 'inquirer'
+import request from 'request'
+import getBowerRegistryConfig from '../getBowerRegistryConfig.js'
+import path from 'path'
+
+export default async function authenticate ({
+  pluginName,
+  cwd = process.cwd()
+} = {}) {
+  cwd = path.resolve(process.cwd(), cwd)
+  const BOWER_REGISTRY_CONFIG = getBowerRegistryConfig({ cwd })
+  // check if github, do github device oauth workflow
+  // if not github, send request to repo anyway
+  const questions = [
+    {
+      name: 'username',
+      message: chalk.cyan('GitHub username')
+    },
+    {
+      name: 'token',
+      message: chalk.cyan('GitHub personal access token (with public_repo access)'),
+      type: 'password',
+      mask: '*'
+    }
+  ]
+  if (!pluginName) {
+    questions.unshift({
+      name: 'pluginName',
+      message: chalk.cyan('Plugin name'),
+      default: pluginName
+    })
+  }
+  const confirmation = await inquirer.prompt(questions)
+  if (!pluginName) {
+    ({ pluginName } = confirmation)
+  }
+  const { username, token } = confirmation
+  return new Promise((resolve, reject) => {
+    request({
+      uri: `${BOWER_REGISTRY_CONFIG.register}authenticate/${username}/${pluginName}?access_token=${token}`,
+      method: 'GET',
+      headers: { 'User-Agent': 'adapt-cli' },
+      followRedirect: false
+    }, (err, res, body) => {
+      if (err) return reject(err)
+      if (res.statusCode !== 200) reject(new Error(`The server responded with ${res.statusCode}`))
+      try {
+        const bodyJSON = JSON.parse(body)
+        resolve({ username, token, pluginName, ...bodyJSON })
+      } catch (err) {
+        reject(err)
+      }
+    })
+  })
+}

package/lib/integration/PluginManagement/install.js

@@ -0,0 +1,222 @@
+import chalk from 'chalk'
+import { eachOfSeries } from 'async'
+import { createPromptTask } from '../../util/createPromptTask.js'
+import { errorPrinter, packageNamePrinter, versionPrinter } from './print.js'
+import { eachOfLimitProgress, eachOfSeriesProgress } from '../../util/promises.js'
+import Project from '../Project.js'
+import Target from '../Target.js'
+import bower from 'bower'
+import { difference } from 'lodash-es'
+import path from 'path'
+
+export default async function install ({
+  plugins,
+  dev = false,
+  isInteractive = true,
+  isDryRun = false, // whether to summarise installation without modifying anything
+  isCompatibleEnabled = false,
+  isClean = false,
+  cwd = process.cwd(),
+  logger = null
+}) {
+  cwd = path.resolve(process.cwd(), cwd)
+  isClean && await new Promise(resolve => bower.commands.cache.clean().on('end', resolve))
+  const project = new Project({ cwd, logger })
+  project.tryThrowInvalidPath()
+
+  logger?.log(chalk.cyan(`${dev ? 'cloning' : 'installing'} adapt dependencies...`))
+
+  const targets = await getInstallTargets({ logger, project, plugins, isCompatibleEnabled })
+  if (!targets?.length) return targets
+
+  await loadPluginData({ logger, project, targets })
+  await conflictResolution({ logger, targets, isInteractive, dev })
+  if (isDryRun) {
+    await summariseDryRun({ logger, targets })
+    return targets
+  }
+  const installTargetsToBeInstalled = targets.filter(target => target.isToBeInstalled)
+  if (installTargetsToBeInstalled.length) {
+    await eachOfSeriesProgress(
+      installTargetsToBeInstalled,
+      target => target.install({ clone: dev }),
+      percentage => logger?.logProgress?.(`${chalk.bold.cyan('<info>')} Installing plugins ${percentage}% complete`)
+    )
+    logger?.log(`${chalk.bold.cyan('<info>')} Installing plugins 100% complete`)
+    const manifestDependencies = await project.getManifestDependencies()
+    await updateManifest({ logger, project, targets, manifestDependencies, isInteractive })
+  }
+  await summariseInstallation({ logger, targets, dev })
+  return targets
+}
+
+/**
+ * @param {Object} options
+ * @param {Project} options.project
+ * @param {[string]} options.plugins
+ */
+async function getInstallTargets ({ logger, project, plugins, isCompatibleEnabled }) {
+  if (typeof plugins === 'string') plugins = [plugins]
+  /** whether adapt.json is being used to compile the list of plugins to install */
+  const isEmpty = !plugins?.length
+  /** a list of plugin name/version pairs */
+  const itinerary = isEmpty
+    ? await project.getManifestDependencies()
+    : plugins.reduce((itinerary, arg) => {
+      const [name, version = '*'] = arg.split(/[#@]/)
+      // Duplicates are removed by assigning to object properties
+      itinerary[name] = version
+      return itinerary
+    }, {})
+  const pluginNames = Object.entries(itinerary).map(([name, version]) => `${name}#${version}`)
+
+  /**
+   * @type {[Target]}
+   */
+  const targets = pluginNames.length
+    ? pluginNames.map(nameVersion => {
+      const [name, requestedVersion] = nameVersion.split(/[#@]/)
+      return new Target({ name, requestedVersion, isCompatibleEnabled, project, logger })
+    })
+    : await project.getInstallTargets()
+  return targets
+}
+
+/**
+ * @param {Object} options
+ * @param {Project} options.project
+ * @param {[Target]} options.targets
+ */
+async function loadPluginData ({ logger, project, targets }) {
+  const frameworkVersion = project.version
+  await eachOfLimitProgress(
+    targets,
+    target => target.fetchSourceInfo(),
+    percentage => logger?.logProgress?.(`${chalk.bold.cyan('<info>')} Getting plugin info ${percentage}% complete`)
+  )
+  logger?.log(`${chalk.bold.cyan('<info>')} Getting plugin info 100% complete`)
+  await eachOfLimitProgress(
+    targets,
+    target => target.findCompatibleVersion(frameworkVersion),
+    percentage => logger?.logProgress?.(`${chalk.bold.cyan('<info>')} Finding compatible source versions ${percentage}% complete`)
+  )
+  logger?.log(`${chalk.bold.cyan('<info>')} Finding compatible source versions 100% complete`)
+  await eachOfLimitProgress(
+    targets,
+    target => target.markInstallable(),
+    percentage => logger?.logProgress?.(`${chalk.bold.cyan('<info>')} Marking installable ${percentage}% complete`)
+  )
+  logger?.log(`${chalk.bold.cyan('<info>')} Marking installable 100% complete`)
+}
+
+/**
+ * @param {Object} options
+ * @param {[Target]} options.targets
+ */
+async function conflictResolution ({ logger, targets, isInteractive, dev }) {
+  /** @param {Target} target */
+  async function checkVersion (target) {
+    const canApplyRequested = target.hasValidRequestVersion &&
+      (target.hasFrameworkCompatibleVersion
+        ? (target.latestCompatibleSourceVersion !== target.matchedVersion)
+        : (target.latestSourceVersion !== target.matchedVersion))
+    if (!isInteractive) {
+      if (canApplyRequested) return target.markRequestedForInstallation()
+      return target.markSkipped()
+    }
+    const choices = [
+      dev && { name: 'master [master]', value: 'm' },
+      canApplyRequested && { name: `requested version [${target.matchedVersion}]`, value: 'r' },
+      target.hasFrameworkCompatibleVersion
+        ? { name: `latest compatible version [${target.latestCompatibleSourceVersion}]`, value: 'l' }
+        : { name: `latest version [${target.latestSourceVersion}]`, value: 'l' },
+      { name: 'skip', value: 's' }
+    ].filter(Boolean)
+    const result = await createPromptTask({ message: chalk.reset(target.packageName), choices, type: 'list', default: 's' })
+    const installMasterBranch = (result === 'm')
+    const installRequested = (result === 'r')
+    const installLatest = result === 'l'
+    const skipped = result === 's'
+    if (installMasterBranch) target.markMasterForInstallation()
+    if (installRequested) target.markRequestedForInstallation()
+    if (installLatest && target.hasFrameworkCompatibleVersion) target.markLatestCompatibleForInstallation()
+    if (installLatest && !target.hasFrameworkCompatibleVersion) target.markLatestForInstallation()
+    if (skipped) target.markSkipped()
+  }
+  function add (list, header, prompt) {
+    if (!list.length) return
+    return {
+      header: chalk.cyan('<info> ') + header,
+      list,
+      prompt
+    }
+  }
+  const allQuestions = [
+    add(targets.filter(target => !target.hasFrameworkCompatibleVersion), 'There is no compatible version of the following plugins:', checkVersion),
+    add(targets.filter(target => target.hasFrameworkCompatibleVersion && !target.hasValidRequestVersion), 'The version requested is invalid, there are newer compatible versions of the following plugins:', checkVersion),
+    add(targets.filter(target => target.hasFrameworkCompatibleVersion && target.hasValidRequestVersion && !target.isApplyLatestCompatibleVersion), 'There are newer compatible versions of the following plugins:', checkVersion)
+  ].filter(Boolean)
+  if (allQuestions.length === 0) return
+  for (const question of allQuestions) {
+    logger?.log(question.header)
+    await eachOfSeries(question.list, question.prompt)
+  }
+}
+
+/**
+ * @param {Object} options
+ * @param {Project} options.project
+ * @param {[Target]} options.targets
+ */
+async function updateManifest ({ project, targets, manifestDependencies, isInteractive }) {
+  if (targets.filter(target => target.isInstallSuccessful).length === 0) return
+  if (difference(targets.filter(target => target.isInstallSuccessful).map(target => target.packageName), Object.keys(manifestDependencies)).length === 0) return
+  if (isInteractive) {
+    const shouldUpdate = await createPromptTask({
+      message: chalk.white('Update the manifest (adapt.json)?'),
+      type: 'confirm',
+      default: true
+    })
+    if (!shouldUpdate) return
+  }
+  targets.forEach(target => target.isInstallSuccessful && project.add(target))
+}
+
+/**
+ * @param {Object} options
+ * @param {[Target]} options.targets
+ */
+function summariseDryRun ({ logger, targets }) {
+  const toBeInstalled = targets.filter(target => target.isToBeInstalled)
+  const toBeSkipped = targets.filter(target => !target.isToBeInstalled || target.isSkipped)
+  const missing = targets.filter(target => target.isMissing)
+  summarise(logger, toBeSkipped, packageNamePrinter, 'The following plugins will be skipped:')
+  summarise(logger, missing, packageNamePrinter, 'There was a problem locating the following plugins:')
+  summarise(logger, toBeInstalled, versionPrinter, 'The following plugins will be installed:')
+}
+
+/**
+ * @param {Object} options
+ * @param {[Target]} options.targets
+ */
+function summariseInstallation ({ logger, targets, dev }) {
+  const installSucceeded = targets.filter(target => target.isInstallSuccessful)
+  const installSkipped = targets.filter(target => !target.isToBeInstalled || target.isSkipped)
+  const installErrored = targets.filter(target => target.isInstallFailure)
+  const missing = targets.filter(target => target.isMissing)
+  const noneInstalled = (installSucceeded.length === 0)
+  const allInstalledSuccessfully = (installErrored.length === 0 && missing.length === 0)
+  const someInstalledSuccessfully = (!noneInstalled && !allInstalledSuccessfully)
+  summarise(logger, installSkipped, packageNamePrinter, 'The following plugins were skipped:')
+  summarise(logger, missing, packageNamePrinter, 'There was a problem locating the following plugins:')
+  summarise(logger, installErrored, errorPrinter, 'The following plugins could not be installed:')
+  if (noneInstalled) logger?.log(chalk.cyanBright('None of the requested plugins could be installed'))
+  else if (allInstalledSuccessfully) summarise(logger, installSucceeded, dev ? packageNamePrinter : versionPrinter, 'All requested plugins were successfully installed. Summary of installation:')
+  else if (someInstalledSuccessfully) summarise(logger, installSucceeded, dev ? packageNamePrinter : versionPrinter, 'The following plugins were successfully installed:')
+}
+
+function summarise (logger, list, iterator, header) {
+  if (!list || !iterator || list.length === 0) return
+  logger?.log(chalk.cyanBright(header))
+  list.forEach(item => iterator(item, logger))
+}