@adobe/aio-cli-plugin-app 8.2.0 → 8.5.0

package/src/commands/app/config/get/log-forwarding/errors.js

@@ -0,0 +1,46 @@
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const BaseCommand = require('../../../../../BaseCommand')
+const rtLib = require('@adobe/aio-lib-runtime')
+const ora = require('ora')
+
+class ErrorsCommand extends BaseCommand {
+  async run () {
+    const spinner = ora()
+    const lf = await this.getLogForwarding()
+    spinner.start('Checking for errors...')
+    const res = await lf.getErrors()
+    const destinationMessage = res.configured_forwarder !== undefined
+      ? ` for the last configured destination '${res.configured_forwarder}'`
+      : ''
+    if (res.errors && res.errors.length > 0) {
+      spinner.succeed(`Log forwarding errors${destinationMessage}:\n` + res.errors.join('\n'))
+    } else {
+      spinner.succeed(`No log forwarding errors${destinationMessage}`)
+    }
+  }
+
+  async getLogForwarding () {
+    const runtimeConfig = this.getFullConfig().aio.runtime
+    rtLib.utils.checkOpenWhiskCredentials({ ow: runtimeConfig })
+    const rt = await rtLib.init({
+      ...runtimeConfig,
+      api_key: runtimeConfig.auth
+    })
+    return rt.logForwarding
+  }
+}
+
+ErrorsCommand.description = 'Get log forwarding errors'
+ErrorsCommand.aliases = ['app:config:get:log-forwarding:errors', 'app:config:get:lf:errors']
+
+module.exports = ErrorsCommand

package/src/commands/app/config/get/log-forwarding.js

@@ -0,0 +1,50 @@
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const BaseCommand = require('../../../../BaseCommand')
+const LogForwarding = require('../../../../lib/log-forwarding')
+
+class LogForwardingCommand extends BaseCommand {
+  async run () {
+    const lf = await LogForwarding.init(this.getFullConfig().aio)
+
+    const localConfig = lf.getLocalConfig()
+    const serverConfig = await lf.getServerConfig()
+
+    if (!localConfig.isEqual(serverConfig)) {
+      this.log('Local and server log forwarding configuration is different')
+      let message = 'Run'
+      if (localConfig.isDefined()) {
+        message += " either 'aio app:deploy' to update the server, or"
+      }
+      message += " 'aio app:config:set:log-forwarding' to set new local and server configuration"
+      this.log(message)
+      this.log('Local configuration:')
+      this.printConfig(localConfig)
+      this.log('\nServer configuration:')
+    }
+    this.printConfig(serverConfig)
+  }
+
+  printConfig (config) {
+    if (config.isDefined()) {
+      this.log(`destination: ${config.getDestination()}`)
+      this.log('settings:', config.getSettings())
+    } else {
+      this.log('Not defined')
+    }
+  }
+}
+
+LogForwardingCommand.description = 'Get log forwarding destination configuration'
+LogForwardingCommand.aliases = ['app:config:get:log-forwarding', 'app:config:get:lf']
+
+module.exports = LogForwardingCommand

package/src/commands/app/config/index.js

@@ -0,0 +1,25 @@
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const HHelp = require('@oclif/plugin-help').default
+const BaseCommand = require('../../../BaseCommand')
+
+class IndexCommand extends BaseCommand {
+  async run () {
+    const help = new HHelp(this.config)
+    help.showHelp(['app:config', '--help'])
+  }
+}
+
+IndexCommand.description = 'Manage app config'
+IndexCommand.aliases = ['app:config', 'app:config']
+
+module.exports = IndexCommand

package/src/commands/app/config/set/index.js

@@ -0,0 +1,25 @@
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const HHelp = require('@oclif/plugin-help').default
+const BaseCommand = require('../../../../BaseCommand')
+
+class IndexCommand extends BaseCommand {
+  async run () {
+    const help = new HHelp(this.config)
+    help.showHelp(['app:config:set', '--help'])
+  }
+}
+
+IndexCommand.description = 'Set app config'
+IndexCommand.aliases = ['app:config:set']
+
+module.exports = IndexCommand

package/src/commands/app/config/set/log-forwarding.js

@@ -0,0 +1,46 @@
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const BaseCommand = require('../../../../BaseCommand')
+const LogForwarding = require('../../../../lib/log-forwarding')
+
+class LogForwardingCommand extends BaseCommand {
+  async run () {
+    const lf = await LogForwarding.init(this.getFullConfig().aio)
+
+    const destination = await this.promptDestination(lf.getSupportedDestinations())
+    const destinationSettingsConfig = lf.getSettingsConfig(destination)
+    const settings = await this.prompt(destinationSettingsConfig)
+    const lfConfig = new LogForwarding.LogForwardingConfig(destination, settings)
+
+    const res = await lf.updateServerConfig(lfConfig)
+    this.log(`Log forwarding is set to '${destination}'`)
+
+    const fullSanitizedConfig = lfConfig.getMergedConfig(lf.getConfigFromJson(res))
+    await lf.updateLocalConfig(fullSanitizedConfig)
+    this.log('Log forwarding settings are saved to the local configuration')
+  }
+
+  async promptDestination (supportedDestinations) {
+    const responses = await this.prompt([{
+      name: 'type',
+      message: 'select log forwarding destination',
+      type: 'list',
+      choices: supportedDestinations
+    }])
+    return responses.type
+  }
+}
+
+LogForwardingCommand.description = 'Set log forwarding destination configuration'
+LogForwardingCommand.aliases = ['app:config:set:log-forwarding', 'app:config:set:lf']
+
+module.exports = LogForwardingCommand

package/src/commands/app/delete/action.js

@@ -87,7 +87,7 @@ class DeleteActionCommand extends BaseCommand {
       // NOTE: (attempt) to delete test files. The test file must match the action name
       // file in the same folder, which is true in most cases, but won't work for asset compute action tests for example.
       try {
-        const pathToE2eTests = path.join(action.e2eTestsDir, action.actionName + '.e2e.js')
+        const pathToE2eTests = path.join(action.e2eTestsDir, action.actionName + '.e2e.test.js')
         const pathToUnitTests = path.join(action.unitTestsDir, action.actionName + '.test.js')
         fs.removeSync(pathToE2eTests)
         aioLogger.debug(`deleted '${pathToE2eTests}'`)

package/src/commands/app/delete/ci.js

@@ -24,7 +24,9 @@ class DeleteCICommand extends BaseCommand {
     const env = yeoman.createEnv()
     const gen = env.instantiate(generators['delete-ci'], {
       options: {
-        'skip-prompt': flags.yes
+        'skip-prompt': flags.yes,
+        // by default yeoman runs the install, we control installation from the app plugin
+        'skip-install': true
       }
     })
     await env.runGenerator(gen)

package/src/commands/app/deploy.js

@@ -21,6 +21,7 @@ const webLib = require('@adobe/aio-lib-web')
 const { flags } = require('@oclif/command')
 const { createWebExportFilter, runScript, buildExtensionPointPayloadWoMetadata, buildExcShellViewExtensionMetadata } = require('../../lib/app-helper')
 const rtLib = require('@adobe/aio-lib-runtime')
+const LogForwarding = require('../../lib/log-forwarding')
 
 class Deploy extends BuildCommand {
   async run () {
@@ -55,7 +56,36 @@ class Deploy extends BuildCommand {
     const spinner = ora()
 
     try {
-      // 1. deploy actions and web assets for each extension
+      const aioConfig = this.getFullConfig().aio
+      // 1. update log forwarding configuration
+      // note: it is possible that .aio file does not exist, which means there is no local lg config
+      if (aioConfig &&
+          aioConfig.project &&
+          aioConfig.project.workspace &&
+          flags['log-forwarding-update'] &&
+          flags.actions) {
+        spinner.start('Updating log forwarding configuration')
+        try {
+          const lf = await LogForwarding.init(aioConfig)
+          if (lf.isLocalConfigChanged()) {
+            const lfConfig = lf.getLocalConfigWithSecrets()
+            if (lfConfig.isDefined()) {
+              await lf.updateServerConfig(lfConfig)
+              spinner.succeed(chalk.green(`Log forwarding is set to '${lfConfig.getDestination()}'`))
+            } else {
+              if (flags.verbose) {
+                spinner.info(chalk.dim('Log forwarding is not updated: no configuration is provided'))
+              }
+            }
+          } else {
+            spinner.info(chalk.dim('Log forwarding is not updated: configuration not changed since last update'))
+          }
+        } catch (error) {
+          spinner.fail(chalk.red('Log forwarding is not updated.'))
+          throw error
+        }
+      }
+      // 2. deploy actions and web assets for each extension
       // Possible improvements:
       // - parallelize
       // - break into smaller pieces deploy, allowing to first deploy all actions then all web assets
@@ -64,9 +94,9 @@ class Deploy extends BuildCommand {
         const v = values[i]
         await this.deploySingleConfig(k, v, flags, spinner)
       }
-      // 2. deploy extension manifest
+
+      // 3. deploy extension manifest
       if (flags.publish) {
-        const aioConfig = this.getFullConfig().aio
         const payload = await this.publishExtensionPoints(libConsoleCLI, deployConfigs, aioConfig, flags['force-publish'])
         this.log(chalk.blue(chalk.bold(`New Extension Point(s) in Workspace '${aioConfig.project.workspace.name}': '${Object.keys(payload.endpoints)}'`)))
       } else {
@@ -84,12 +114,14 @@ class Deploy extends BuildCommand {
   }
 
   async deploySingleConfig (name, config, flags, spinner) {
-    const onProgress = !flags.verbose ? info => {
-      spinner.text = info
-    } : info => {
-      spinner.info(chalk.dim(`${info}`))
-      spinner.start()
-    }
+    const onProgress = !flags.verbose
+      ? info => {
+        spinner.text = info
+      }
+      : info => {
+        spinner.info(chalk.dim(`${info}`))
+        spinner.start()
+      }
 
     // build phase
     if (flags.build) {
@@ -300,6 +332,11 @@ Deploy.flags = {
   'web-optimize': flags.boolean({
     description: '[default: false] Enable optimization (minification) of web js/css/html',
     default: false
+  }),
+  'log-forwarding-update': flags.boolean({
+    description: '[default: true] Update log forwarding configuration on server',
+    default: true,
+    allowNo: true
   })
 }
 

package/src/commands/app/init.js

@@ -9,7 +9,7 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
-const BaseCommand = require('../../BaseCommand')
+const AddCommand = require('../../AddCommand')
 const yeoman = require('yeoman-environment')
 const path = require('path')
 const fs = require('fs-extra')
@@ -20,14 +20,14 @@ const { flags } = require('@oclif/command')
 const generators = require('@adobe/generator-aio-app')
 
 const { loadAndValidateConfigFile, importConfigJson } = require('../../lib/import')
-const { installPackages, atLeastOne } = require('../../lib/app-helper')
+const { atLeastOne } = require('../../lib/app-helper')
 
 const { ENTP_INT_CERTS_FOLDER, SERVICE_API_KEY_ENV, implPromptChoices } = require('../../lib/defaults')
 const cloneDeep = require('lodash.clonedeep')
 
 const DEFAULT_WORKSPACE = 'Stage'
 
-class InitCommand extends BaseCommand {
+class InitCommand extends AddCommand {
   async run () {
     const { args, flags } = this.parse(InitCommand)
 
@@ -56,11 +56,7 @@ class InitCommand extends BaseCommand {
     }
 
     // install packages, always at the end, so user can ctrl+c
-    if (!flags['skip-install']) {
-      await installPackages('.', { spinner, verbose: flags.verbose })
-    } else {
-      this.log('--skip-install, make sure to run \'npm install\' later on')
-    }
+    await this.runInstallPackages(flags, spinner)
 
     this.log(chalk.bold(chalk.green('✔ App initialization finished!')))
     this.log('> Tip: you can add more actions, web-assets and events to your project via the `aio app add` commands')
@@ -106,7 +102,7 @@ class InitCommand extends BaseCommand {
     // 3. select or create project
     const project = await this.selectOrCreateConsoleProject(consoleCLI, org)
     // 4. retrieve workspace details, defaults to Stage
-    const workspace = await this.retrieveWorkspaceFromName(consoleCLI, org, project, flags.workspace)
+    const workspace = await this.retrieveWorkspaceFromName(consoleCLI, org, project, flags)
     // 5. ask for exensionPoints, only allow selection for extensions that have services enabled in Org
     const extensionPoints = await this.selectExtensionPoints(flags, orgSupportedServices)
     // 6. add any required services to Workspace
@@ -143,7 +139,7 @@ class InitCommand extends BaseCommand {
       }
       return extList
     } else {
-      const choices = cloneDeep(implPromptChoices).filter(i => i.value.name !== 'application')
+      const choices = cloneDeep(implPromptChoices)
 
       // disable extensions that lack required services
       if (orgSupportedServices) {
@@ -190,12 +186,23 @@ class InitCommand extends BaseCommand {
     return project
   }
 
-  async retrieveWorkspaceFromName (consoleCLI, org, project, workspaceName) {
+  async retrieveWorkspaceFromName (consoleCLI, org, project, flags) {
+    const workspaceName = flags.workspace
     // get workspace details
     const workspaces = await consoleCLI.getWorkspaces(org.id, project.id)
-    const workspace = workspaces.find(w => w.name.toLowerCase() === workspaceName.toLowerCase())
+    let workspace = workspaces.find(w => w.name.toLowerCase() === workspaceName.toLowerCase())
     if (!workspace) {
-      throw new Error(`'--workspace=${workspaceName}' in Project '${project.name}' not found.`)
+      if (!flags['confirm-new-workspace']) {
+        const shouldNewWorkspace = await consoleCLI.prompt.promptConfirm(`Workspace '${workspaceName}' does not exist \n > Do you wish to create a new workspace?`)
+        if (!shouldNewWorkspace) {
+          this.error(`Workspace '${workspaceName}' does not exist and creation aborted`)
+        }
+      }
+      this.log(`'--workspace=${workspaceName}' in Project '${project.name}' not found. \n Creating one...`)
+      workspace = await consoleCLI.createWorkspace(org.id, project.id, {
+        name: workspaceName,
+        title: ''
+      })
     }
     return workspace
   }
@@ -245,14 +252,19 @@ class InitCommand extends BaseCommand {
 
   async runCodeGenerators (flags, extensionPoints, projectName) {
     let env = yeoman.createEnv()
-    // first run app generator that will generate the root skeleton
-    const appGen = env.instantiate(generators['base-app'], {
-      options: {
-        'skip-prompt': flags.yes,
-        'project-name': projectName
-      }
-    })
-    await env.runGenerator(appGen)
+    const initialGenerators = ['base-app', 'add-ci']
+    // first run app generator that will generate the root skeleton + ci
+    for (const generatorKey of initialGenerators) {
+      const appGen = env.instantiate(generators[generatorKey], {
+        options: {
+          'skip-prompt': flags.yes,
+          'project-name': projectName,
+          // by default yeoman runs the install, we control installation from the app plugin
+          'skip-install': true
+        }
+      })
+      await env.runGenerator(appGen)
+    }
 
     // Creating new Yeoman env here to workaround an issue where yeoman reuses the conflicter from previous environment.
     // https://github.com/yeoman/environment/issues/324
@@ -266,7 +278,9 @@ class InitCommand extends BaseCommand {
           options: {
             'skip-prompt': flags.yes,
             // do not prompt for overwrites
-            force: true
+            force: true,
+            // by default yeoman runs the install, we control installation from the app plugin
+            'skip-install': true
           }
         })
       await env.runGenerator(extGen)
@@ -295,17 +309,12 @@ InitCommand.description = `Create a new Adobe I/O App
 `
 
 InitCommand.flags = {
-  ...BaseCommand.flags,
+  ...AddCommand.flags,
   yes: flags.boolean({
     description: 'Skip questions, and use all default values',
     default: false,
     char: 'y'
   }),
-  'skip-install': flags.boolean({
-    description: 'Skip npm installation after files are created',
-    char: 's',
-    default: false
-  }),
   import: flags.string({
     description: 'Import an Adobe I/O Developer Console configuration file',
     char: 'i'
@@ -331,6 +340,10 @@ InitCommand.flags = {
     default: DEFAULT_WORKSPACE,
     char: 'w',
     exclusive: ['import'] // also no-login
+  }),
+  'confirm-new-workspace': flags.boolean({
+    description: 'Skip and confirm prompt for creating a new workspace',
+    default: false
   })
 }
 

package/src/commands/app/logs.js

@@ -11,10 +11,10 @@ governing permissions and limitations under the License.
 */
 
 const { flags } = require('@oclif/command')
-// const { cli } = require('cli-ux')
 const BaseCommand = require('../../BaseCommand')
 const { wrapError } = require('../../lib/app-helper')
 const rtLib = require('@adobe/aio-lib-runtime')
+const LogForwarding = require('../../lib/log-forwarding')
 
 class Logs extends BaseCommand {
   _processEachAction (fullConfig, processFn) {
@@ -40,6 +40,15 @@ class Logs extends BaseCommand {
       throw new Error('There are no backend implementations for this project folder.')
     }
 
+    const lf = await LogForwarding.init(fullConfig.aio)
+    const serverConfig = await lf.getServerConfig()
+    const logForwardingDestination = serverConfig.getDestination()
+    if (logForwardingDestination !== 'adobe_io_runtime') {
+      this.log(`Namespace is configured with custom log forwarding destination: '${logForwardingDestination}'. ` +
+        'Please use corresponding logging platform to view logs.')
+      return
+    }
+
     if (flags.limit < 1) {
       this.log('--limit should be > 0, using --limit=1')
       flags.limit = 1

package/src/commands/app/run.js

@@ -97,12 +97,14 @@ class Run extends BaseCommand {
       }
     }
 
-    const onProgress = !flags.verbose ? info => {
-      spinner.text = info
-    } : info => {
-      spinner.info(chalk.dim(`${info}`))
-      spinner.start()
-    }
+    const onProgress = !flags.verbose
+      ? info => {
+        spinner.text = info
+      }
+      : info => {
+        spinner.info(chalk.dim(`${info}`))
+        spinner.start()
+      }
 
     const frontendUrl = await runDev(config, this.config.dataDir, runOptions, onProgress)
     try {

package/src/commands/app/undeploy.js

@@ -72,12 +72,14 @@ class Undeploy extends BaseCommand {
   }
 
   async undeployOneExt (extName, config, flags, spinner) {
-    const onProgress = !flags.verbose ? info => {
-      spinner.text = info
-    } : info => {
-      spinner.info(chalk.dim(`${info}`))
-      spinner.start()
-    }
+    const onProgress = !flags.verbose
+      ? info => {
+        spinner.text = info
+      }
+      : info => {
+        spinner.info(chalk.dim(`${info}`))
+        spinner.start()
+      }
     // undeploy
     try {
       await runScript(config.hooks['pre-app-undeploy'])

package/src/commands/app/use.js

@@ -78,14 +78,6 @@ class Use extends BaseCommand {
         this.error(message)
       }
       newConfig = globalConfig
-      if (
-        currentConfigIsComplete &&
-        newConfig.org.id === currentConfig.org.id &&
-        newConfig.project.id === currentConfig.project.id &&
-        newConfig.workspace.id === currentConfig.workspace.id
-      ) {
-        this.error('The selected configuration is the same as the current configuration.')
-      }
     } else {
       // useOperation = 'workspace'
       if (!currentConfigIsComplete) {
@@ -190,37 +182,37 @@ class Use extends BaseCommand {
    * @returns {Buffer} the Adobe Developer Console configuration file for the workspace
    */
   async selectTargetWorkspaceInProject (consoleCLI, config, flags) {
-    const project = { name: config.project.name, id: config.project.id }
-    const currentWorkspace = { name: config.workspace.name, id: config.workspace.id }
-
-    // make sure user is not trying to switch to current workspace
-    const workspaceFlag = flags.workspace
-    if (workspaceFlag === currentWorkspace.name) {
-      this.cleanConsoleCLIOutput()
-      this.error(`--workspace=${workspaceFlag} is the same as the currently selected workspace, nothing to be done.`)
-    }
+    const { project, org } = config
+    const workspaceNameOrId = flags.workspace
 
     // retrieve all workspaces
     const workspaces = await consoleCLI.getWorkspaces(
-      config.org.id,
-      config.project.id
+      org.id,
+      project.id
     )
-    const workspacesButCurrent = workspaces.filter(w => w.id !== currentWorkspace.id)
-
     let workspace
-
-    if (workspaceFlag) {
-      // workspace name is given, make sure the workspace is in there
-      workspace = workspacesButCurrent.find(w => w.name === workspaceFlag)
-      if (!workspace) {
-        this.cleanConsoleCLIOutput()
-        this.error(`--workspace=${workspaceFlag} does not exist in current Project ${project.name}.`)
+    let workspaceData = { name: workspaceNameOrId }
+    // does not prompt if workspaceNameOrId is defined via the flag
+    workspace = await consoleCLI.promptForSelectWorkspace(workspaces, { workspaceId: workspaceNameOrId, workspaceName: workspaceNameOrId }, { allowCreate: true })
+    if (!workspace) {
+      aioLogger.debug(`--workspace=${workspaceNameOrId} was not found in the current Project ${project.name}`)
+      if (workspaceNameOrId) {
+        if (!flags['confirm-new-workspace']) {
+          const shouldNewWorkspace = await consoleCLI.prompt.promptConfirm(`Workspace '${workspaceNameOrId}' does not exist \n > Do you wish to create a new workspace?`)
+          if (!shouldNewWorkspace) {
+            this.error('Workspace creation aborted')
+          }
+        }
+      } else {
+        workspaceData = await consoleCLI.promptForCreateWorkspaceDetails()
       }
-    } else {
-      // workspace name is not given, let the user choose the
-      workspace = await consoleCLI.promptForSelectWorkspace(workspacesButCurrent)
+      aioLogger.debug(`Creating workspace: ${workspaceData.name}`)
+      workspace = await consoleCLI.createWorkspace(org.id, project.id, workspaceData)
+    }
+    return {
+      name: workspace.name,
+      id: workspace.id
     }
-    return { name: workspace.name, id: workspace.id }
   }
 
   /**
@@ -395,11 +387,15 @@ Use.flags = {
     exclusive: ['workspace']
   }),
   workspace: flags.string({
-    description: 'Specify the Adobe Developer Console Workspace name to import the configuration from',
+    description: 'Specify the Adobe Developer Console Workspace name or Workspace id to import the configuration from',
     default: '',
     char: 'w',
     exclusive: ['global', 'workspace-name']
   }),
+  'confirm-new-workspace': flags.boolean({
+    description: 'Skip and confirm prompt for creating a new workspace',
+    default: false
+  }),
   'workspace-name': flags.string({
     description: '[DEPRECATED]: please use --workspace instead',
     default: '',