@adobe/aio-cli-plugin-app 10.1.1 → 10.2.1

package/README.md

@@ -71,7 +71,7 @@ DESCRIPTION
   Create, run, test, and deploy Adobe I/O Apps
 ```
 
-_See code: [src/commands/app/index.js](https://github.com/adobe/aio-cli-plugin-app/blob/10.1.1/src/commands/app/index.js)_
+_See code: [src/commands/app/index.js](https://github.com/adobe/aio-cli-plugin-app/blob/10.2.1/src/commands/app/index.js)_
 
 ## `aio app add`
 

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "10.1.1",
+  "version": "10.2.1",
   "commands": {
     "app:build": {
       "id": "app:build",
@@ -237,6 +237,13 @@
           "type": "boolean",
           "description": "[default: true] Update log forwarding configuration on server",
           "allowNo": true
+        },
+        "feature-event-hooks": {
+          "name": "feature-event-hooks",
+          "type": "boolean",
+          "description": "[default: false] Enable event hooks feature",
+          "hidden": true,
+          "allowNo": true
         }
       },
       "args": {}
@@ -492,6 +499,46 @@
         }
       }
     },
+    "app:install": {
+      "id": "app:install",
+      "description": "(Pre-release) This command will support installing apps packaged by '<%= config.bin %> app pack'.\n",
+      "strict": true,
+      "pluginName": "@adobe/aio-cli-plugin-app",
+      "pluginAlias": "@adobe/aio-cli-plugin-app",
+      "pluginType": "core",
+      "hidden": true,
+      "aliases": [],
+      "flags": {
+        "verbose": {
+          "name": "verbose",
+          "type": "boolean",
+          "char": "v",
+          "description": "Verbose output",
+          "allowNo": false
+        },
+        "version": {
+          "name": "version",
+          "type": "boolean",
+          "description": "Show version",
+          "allowNo": false
+        },
+        "output": {
+          "name": "output",
+          "type": "option",
+          "char": "o",
+          "description": "The packaged app output folder path",
+          "multiple": false,
+          "default": "."
+        }
+      },
+      "args": {
+        "path": {
+          "name": "path",
+          "description": "Path to the app package to install",
+          "required": true
+        }
+      }
+    },
     "app:logs": {
       "id": "app:logs",
       "description": "Fetch logs for an Adobe I/O App\n",
@@ -572,6 +619,46 @@
       },
       "args": {}
     },
+    "app:pack": {
+      "id": "app:pack",
+      "description": "(Pre-release) This command will support packaging apps for redistribution.\n",
+      "strict": true,
+      "pluginName": "@adobe/aio-cli-plugin-app",
+      "pluginAlias": "@adobe/aio-cli-plugin-app",
+      "pluginType": "core",
+      "hidden": true,
+      "aliases": [],
+      "flags": {
+        "verbose": {
+          "name": "verbose",
+          "type": "boolean",
+          "char": "v",
+          "description": "Verbose output",
+          "allowNo": false
+        },
+        "version": {
+          "name": "version",
+          "type": "boolean",
+          "description": "Show version",
+          "allowNo": false
+        },
+        "output": {
+          "name": "output",
+          "type": "option",
+          "char": "o",
+          "description": "The packaged app output file path",
+          "multiple": false,
+          "default": "app.zip"
+        }
+      },
+      "args": {
+        "path": {
+          "name": "path",
+          "description": "Path to the app directory to package",
+          "default": "."
+        }
+      }
+    },
     "app:run": {
       "id": "app:run",
       "description": "Run an Adobe I/O App",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adobe/aio-cli-plugin-app",
   "description": "Create, Build and Deploy Adobe I/O Applications",
-  "version": "10.1.1",
+  "version": "10.2.1",
   "author": "Adobe Inc.",
   "bugs": "https://github.com/adobe/aio-cli-plugin-app/issues",
   "dependencies": {
@@ -14,35 +14,38 @@
     "@adobe/aio-lib-ims": "^6.0.0",
     "@adobe/aio-lib-runtime": "^5.0.0",
     "@adobe/aio-lib-templates": "^2.2.0",
-    "@adobe/aio-lib-web": "^6.0.1",
+    "@adobe/aio-lib-web": "^6.1.0",
     "@adobe/generator-aio-app": "^5.1.0",
     "@adobe/generator-app-common-lib": "^0.3.3",
     "@adobe/inquirer-table-checkbox": "^1.2.0",
     "@oclif/core": "^1.15.0",
     "@parcel/core": "^2.7.0",
     "@parcel/reporter-cli": "^2.7.0",
-    "ajv": "^6",
+    "ajv": "^8",
+    "ajv-formats": "^2.1.1",
+    "archiver": "^5.3.1",
     "chalk": "^4",
     "chokidar": "^3.5.2",
     "debug": "^4.1.1",
     "dedent-js": "^1.0.1",
     "dotenv": "^16",
     "execa": "^5.0.0",
-    "fs-extra": "^10",
+    "fs-extra": "^11.1.1",
     "get-port": "^5",
     "hjson": "^3.2.1",
     "http-terminator": "^3",
     "hyperlinker": "^1.0.0",
     "inquirer": "^8",
-    "js-yaml": "^4",
+    "js-yaml": "^4.1.0",
     "lodash.clonedeep": "^4.5.0",
     "node-fetch": "^2.6.7",
     "ora": "^5",
     "pure-http": "^3",
     "serve-static": "^1.14.1",
     "term-size": "^2.2.1",
+    "unzipper": "^0.10.11",
     "upath": "^2",
-    "which": "^2.0.1",
+    "which": "^3.0.0",
     "yeoman-environment": "^3.2.0"
   },
   "devDependencies": {
@@ -61,7 +64,6 @@
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^6.0.0",
     "jest": "^29.5.0",
-    "jest-plugin-fs": "^2.9.0",
     "nock": "^13.2.9",
     "oclif": "^3.2.0",
     "stdout-stderr": "^0.1.9"
@@ -75,7 +77,7 @@
     "bin/openwhisk-standalone-config/",
     "oclif.manifest.json",
     "src",
-    "schema/config.schema.json"
+    "schema"
   ],
   "homepage": "https://github.com/adobe/aio-cli-plugin-app",
   "keywords": [

package/schema/app.config.yaml.schema.json

@@ -0,0 +1,157 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://adobe.io/schemas/app-builder/app.config.yaml.json/v1",
+  "type": "object",
+  "properties": {
+    "application": { "$ref": "#/definitions/application" },
+    "extensions": { "$ref": "#/definitions/extensions" }
+  },
+  "oneOf": [
+    {
+      "required": ["application"],
+      "allOf": [
+        { "not": { "required": ["extensions"] } }
+      ]
+    },
+    {
+      "required": ["extensions"],
+      "allOf": [
+        { "not": { "required": ["application"] } }
+      ]
+    }
+  ],
+  "definitions": {
+    "application": {
+      "type": "object",
+      "properties": {
+        "runtimeManifest": { "$ref": "#/definitions/runtimeManifest" },
+        "actions": { "type": "string" },
+        "unitTest": { "type": "string" },
+        "e2eTest": { "type": "string" },
+        "dist": { "type": "string" },
+        "tvmurl": { "type": "string" },
+        "awsaccesskeyid": { "type": "string" },
+        "awssecretaccesskey": { "type": "string" },
+        "s3bucket": { "type": "string" },
+        "events": { "type": "object" },
+        "hostname": { "type": "string" },
+        "htmlcacheduration": { "type": "number" },
+        "jscacheduration": { "type": "number" },
+        "csscacheduration": { "type": "number" },
+        "imagecacheduration": { "type": "number" },
+        "hooks": { "$ref": "#/definitions/hooks" },
+        "web": { "$ref": "#/definitions/web" }
+      },
+      "required": ["runtimeManifest"]
+    },
+    "extensions": {
+      "type": "object",
+      "patternProperties": {
+        "^[A-Za-z0-9-_/\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff]{1,20}$": { 
+          "$ref": "#/definitions/extension"
+        }
+      },
+      "additionalProperties": false
+    },
+    "extension": {
+      "type": "object",
+      "properties": {
+        "$include": { "type": "string" }
+      }
+    },
+    "web": {
+      "anyOf": [
+        {
+          "type": "string"
+        }, 
+        {
+          "type": "object",
+          "properties": {
+            "response-headers": { "type": "object" }
+          }
+        }
+      ]
+    },
+    "runtimeManifest": {
+      "type": "object",
+      "properties": {
+        "packages": { "$ref": "#/definitions/packages" }
+      },
+      "required": ["packages"]
+    },
+    "packages": {
+      "type": "object",
+      "patternProperties": {
+        "^[A-Za-z0-9-_\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff]{1,20}$": { 
+          "$ref": "#/definitions/package"
+        }
+      },
+      "additionalProperties": false
+    },
+    "package": {
+      "type": "object",
+      "properties": {
+        "license": { "type": "string" },
+        "actions": { "$ref": "#/definitions/actions" }
+      }
+    },
+    "actions": {
+      "type": "object",
+      "patternProperties": {
+        "^[A-Za-z0-9-_\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff]{1,20}$": { 
+          "$ref": "#/definitions/action"
+        }
+      },
+      "additionalProperties": false
+    },
+    "action": {
+      "type": "object",
+      "properties": {
+        "function": { "type": "string" },
+        "web": { "type": "string" },
+        "runtime": { "type": "string" },
+        "inputs": { "$ref": "#/definitions/inputs" },
+        "annotations": { "$ref": "#/definitions/annotations" }
+      },
+      "required": ["function", "runtime"]
+    },
+    "inputs": {
+      "type": "object",
+      "patternProperties": {
+        "^[A-Za-z0-9-_\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff]{1,20}$": { 
+          "type": ["string", "boolean"]
+        }
+      },
+      "additionalProperties": false
+    },
+    "annotations": {
+      "type": "object",
+      "patternProperties": {
+        "^[A-Za-z0-9-_\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff]{1,20}$": { 
+          "type": ["string", "boolean"]
+        }
+      },
+      "additionalProperties": false
+    },
+    "hooks": {
+      "type": "object",
+      "properties": {
+        "pre-app-build": { "type": "string" },
+        "post-app-build": { "type": "string" },
+        "build-actions": { "type": "string" },
+        "build-static": { "type": "string" },
+        "pre-app-deploy": { "type": "string" },
+        "post-app-deploy": { "type": "string" },
+        "deploy-actions": { "type": "string" },
+        "deploy-static": { "type": "string" },
+        "pre-app-undeploy": { "type": "string" },
+        "post-app-undeploy": { "type": "string" },
+        "undeploy-actions": { "type": "string" },
+        "undeploy-static": { "type": "string" },
+        "pre-app-run": { "type": "string" },
+        "post-app-run": { "type": "string" },
+        "serve-static": { "type": "string" }
+      }
+    }
+  }
+}

package/schema/config.schema.json

@@ -102,7 +102,7 @@
                 },
                 "ims_org_id": {
                     "type": "string",
-                    "format": "email"
+                    "pattern": "^(\\w+)@(\\w+)"
                 }
             },
             "required": [ "id", "name", "ims_org_id" ]

package/schema/deploy.yaml.schema.json

@@ -0,0 +1,107 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://adobe.io/schemas/app-builder/deploy.yaml.json/v1",
+  "type": "object",
+  "properties": {
+    "application": { "$ref": "#/definitions/application" },
+    "workspaces": { "$ref": "#/definitions/workspaces" },
+    "meshConfig": { "$ref": "#/definitions/meshConfig" },
+    "extensions": { "$ref": "#/definitions/extensions" },
+    "apis": { "$ref": "#/definitions/apis" },
+    "runtime": { 
+      "type": "boolean",
+      "default": true
+    }
+  },
+  "required": ["application", "workspaces", "runtime"],
+  "definitions": {
+    "application": {
+      "type": "object",
+      "properties": {
+        "id": { "type": "string" },
+        "version": { "type": "string" }
+      },
+      "required": ["id", "version"]
+    },
+    "workspaces": {
+      "type": "array",
+      "items": { "$ref": "#/definitions/workspace" },
+      "default": []
+    },
+    "meshConfig": {
+      "type": "object",
+      "properties": {
+        "meshConfig": { "$ref": "#/definitions/meshConfigNested" },
+        "meshId": {
+          "type": "string"
+        },
+        "lastUpdatedBy": { "type": "object" },
+        "lastUpdated": {
+          "type": "string",
+          "pattern": "(\\d{4})-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2}):(\\d{2}(?:\\.\\d*)?)((-(\\d{2}):(\\d{2})|Z)?)"
+        },
+        "meshStatus": { "type": "string" }
+      },
+      "required": ["meshConfig", "meshId"]
+    },
+    "meshConfigNested": {
+      "type": "object",
+      "properties": {
+        "sources": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/meshConfigSource" },
+          "default": []
+        }
+      }
+    },
+    "meshConfigSource": {
+      "type": "object",
+      "properties": {
+        "name": { "type": "string" },
+        "handler": { "$ref": "#/definitions/meshConfigSourceHandler" }
+      },
+      "required": ["name", "handler"]
+    },
+    "meshConfigSourceHandler": {
+      "type": "object",
+      "properties": {
+        "graphql": { "$ref": "#/definitions/graphql" }
+      }
+    },
+    "graphql": {
+      "type": "object",
+      "properties": {
+        "handler": {
+          "type": "string",
+          "format": "uri"
+        }
+      }
+    },
+    "workspace": {
+      "type": "string",
+      "pattern": "^[A-Za-z0-9\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff]{1,20}$"
+    },
+    "extensions": {
+      "type": "array",
+      "items": { "$ref": "#/definitions/extension" } 
+    },
+    "extension": {
+      "type": "object",
+      "properties": {
+        "extensionPointId": { "type": "string" }
+      },
+      "required": ["extensionPointId"]
+    },
+    "apis": {
+      "type": "array",
+      "items": { "$ref": "#/definitions/api" } 
+    },
+    "api": {
+      "type": "object",
+      "properties": {
+        "code": { "type": "string" }
+      },
+      "required": ["code"]
+    }
+  }
+}

package/schema/index.js

@@ -0,0 +1,19 @@
+/*
+Copyright 2023 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 { USER_CONFIG_FILE, DEPLOY_CONFIG_FILE, IMPORT_CONFIG_FILE } = require('../src/lib/defaults')
+
+module.exports = {
+  [IMPORT_CONFIG_FILE]: require('./config.schema.json'),
+  [USER_CONFIG_FILE]: require('./app.config.yaml.schema.json'),
+  [DEPLOY_CONFIG_FILE]: require('./deploy.yaml.schema.json')
+}

package/src/BaseCommand.js

@@ -165,6 +165,10 @@ class BaseCommand extends Command {
   get appVersion () {
     return this.pjson.version
   }
+
+  preRelease () {
+    this.log(chalk.yellow('Pre-release warning: This command is in pre-release, and not suitable for production.'))
+  }
 }
 
 BaseCommand.flags = {

package/src/TemplatesCommand.js

@@ -152,6 +152,8 @@ class TemplatesCommand extends AddCommand {
 
     if (templates.length <= 0) {
       aioLogger.debug('installTemplates: standalone-app')
+      // technically runHook can quietly fail, but we are choosing to ignore it as these are telemetry events
+      // and not mission critical
       await this.config.runHook('telemetry', { data: 'installTemplates:standalone-app' })
     } else {
       aioLogger.debug(`installTemplates: ${templates}`)

package/src/commands/app/deploy.js

@@ -143,6 +143,15 @@ class Deploy extends BuildCommand {
 
     try {
       await runScript(config.hooks['pre-app-deploy'])
+
+      if (flags['feature-event-hooks']) {
+        this.log('feature-event-hooks is enabled, running pre-deploy-event-reg hook')
+        const hookResults = await this.config.runHook('pre-deploy-event-reg', { appConfig: config })
+        if (hookResults?.failures?.length > 0) {
+          // output should be "Error : <plugin-name> : <error-message>\n" for each failure
+          this.error(hookResults.failures.map(f => `${f.plugin.name} : ${f.error.message}`).join('\nError: '), { exit: 1 })
+        }
+      }
     } catch (err) {
       this.log(err)
     }
@@ -158,11 +167,15 @@ class Deploy extends BuildCommand {
         try {
           const script = await runScript(config.hooks['deploy-actions'])
           if (!script) {
-            await this.config.runHook('deploy-actions', {
+            const hookResults = await this.config.runHook('deploy-actions', {
               appConfig: config,
               filterEntities: filterActions || [],
               isLocalDev: false
             })
+            if (hookResults?.failures?.length > 0) {
+              // output should be "Error : <plugin-name> : <error-message>\n" for each failure
+              this.error(hookResults.failures.map(f => `${f.plugin.name} : ${f.error.message}`).join('\nError: '), { exit: 1 })
+            }
             deployedRuntimeEntities = await rtLib.deployActions(config, { filterEntities }, onProgress)
           }
 
@@ -239,6 +252,14 @@ class Deploy extends BuildCommand {
 
     try {
       await runScript(config.hooks['post-app-deploy'])
+      if (flags['feature-event-hooks']) {
+        this.log('feature-event-hooks is enabled, running post-deploy-event-reg hook')
+        const hookResults = await this.config.runHook('post-deploy-event-reg', { appConfig: config })
+        if (hookResults?.failures?.length > 0) {
+          // output should be "Error : <plugin-name> : <error-message>\n" for each failure
+          this.error(hookResults.failures.map(f => `${f.plugin.name} : ${f.error.message}`).join('\nError: '), { exit: 1 })
+        }
+      }
     } catch (err) {
       this.log(err)
     }
@@ -341,6 +362,12 @@ Deploy.flags = {
     description: '[default: true] Update log forwarding configuration on server',
     default: true,
     allowNo: true
+  }),
+  'feature-event-hooks': Flags.boolean({
+    description: '[default: false] Enable event hooks feature',
+    default: false,
+    allowNo: true,
+    hidden: true
   })
 }
 

package/src/commands/app/install.js

@@ -0,0 +1,166 @@
+/*
+Copyright 2023 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 { Flags } = require('@oclif/core')
+const aioLogger = require('@adobe/aio-lib-core-logging')('@adobe/aio-cli-plugin-app:install', { provider: 'debug' })
+const path = require('node:path')
+const fs = require('fs-extra')
+const execa = require('execa')
+const unzipper = require('unzipper')
+const { validateJsonWithSchema } = require('../../lib/install-helper')
+const jsYaml = require('js-yaml')
+const { USER_CONFIG_FILE, DEPLOY_CONFIG_FILE } = require('../../lib/defaults')
+const ora = require('ora')
+const chalk = require('chalk')
+
+class InstallCommand extends BaseCommand {
+  async run () {
+    const { args, flags } = await this.parse(InstallCommand)
+
+    this.preRelease()
+
+    aioLogger.debug(`flags: ${JSON.stringify(flags, null, 2)}`)
+    aioLogger.debug(`args: ${JSON.stringify(args, null, 2)}`)
+
+    // resolve to absolute path before any chdir
+    args.path = path.resolve(args.path)
+    aioLogger.debug(`args.path (resolved): ${args.path}`)
+
+    let outputPath = flags.output
+    // change the cwd if necessary
+    if (outputPath !== '.') {
+      outputPath = path.resolve(flags.output)
+      // TODO: confirm if dir exists for overwrite
+      await fs.ensureDir(outputPath)
+      process.chdir(outputPath)
+      aioLogger.debug(`changed current working directory to: ${outputPath}`)
+    }
+
+    try {
+      await this.validateZipDirectoryStructure(args.path)
+      await this.unzipFile(args.path, outputPath)
+      await this.validateConfig(outputPath, USER_CONFIG_FILE)
+      await this.validateConfig(outputPath, DEPLOY_CONFIG_FILE)
+      await this.npmInstall(flags.verbose)
+      await this.runTests()
+      this.spinner.succeed('Install done.')
+    } catch (e) {
+      this.spinner.fail(e.message)
+      this.error(flags.verbose ? e : e.message)
+    }
+  }
+
+  get spinner () {
+    if (!this._spinner) {
+      this._spinner = ora()
+    }
+    return this._spinner
+  }
+
+  diffArray (expected, actual) {
+    const _expected = expected ?? []
+    const _actual = actual ?? []
+    return _expected.filter(item => !_actual.includes(item))
+  }
+
+  async validateZipDirectoryStructure (zipFilePath) {
+    aioLogger.debug(`validateZipDirectoryStructure: ${zipFilePath}`)
+
+    const expectedFiles = [USER_CONFIG_FILE, DEPLOY_CONFIG_FILE, 'package.json']
+    const foundFiles = []
+
+    this.spinner.start(`Validating integrity of app package at ${zipFilePath}...`)
+
+    const zip = fs.createReadStream(zipFilePath).pipe(unzipper.Parse({ forceStream: true }))
+    for await (const entry of zip) {
+      const fileName = entry.path
+
+      if (expectedFiles.includes(fileName)) {
+        foundFiles.push(fileName)
+      }
+      entry.autodrain()
+    }
+
+    const diff = this.diffArray(expectedFiles, foundFiles)
+    if (diff.length > 0) {
+      throw new Error(`The app package ${zipFilePath} is missing these files: ${JSON.stringify(diff, null, 2)}`)
+    }
+    this.spinner.succeed(`Validated integrity of app package at ${zipFilePath}`)
+  }
+
+  async unzipFile (zipFilePath, destFolderPath) {
+    aioLogger.debug(`unzipFile: ${zipFilePath} to be extracted to ${destFolderPath}`)
+
+    this.spinner.start(`Extracting app package to ${destFolderPath}...`)
+    return unzipper.Open.file(zipFilePath)
+      .then((d) => d.extract({ path: destFolderPath }))
+      .then(() => this.spinner.succeed(`Extracted app package to ${destFolderPath}`))
+  }
+
+  async validateConfig (outputPath, configFileName, configFilePath = path.join(outputPath, configFileName)) {
+    this.spinner.start(`Validating ${configFileName}...`)
+    aioLogger.debug(`validateConfig: ${configFileName} at ${configFilePath}`)
+
+    const configFileJson = jsYaml.load(fs.readFileSync(configFilePath).toString())
+    const { valid, errors } = validateJsonWithSchema(configFileJson, configFileName)
+    if (!valid) {
+      throw new Error(`Missing or invalid keys in ${configFileName}: ${JSON.stringify(errors, null, 2)}`)
+    } else {
+      this.spinner.succeed(`Validated ${configFileName}`)
+    }
+  }
+
+  async npmInstall (isVerbose) {
+    this.spinner.start('Running npm install...')
+    const stdio = isVerbose ? 'inherit' : 'ignore'
+    return execa('npm', ['install'], { stdio })
+      .then(() => {
+        this.spinner.succeed('Ran npm install')
+      })
+  }
+
+  async runTests (isVerbose) {
+    this.spinner.start('Running app tests...')
+    return this.config.runCommand('app:test').then((result) => {
+      if (result === 0) { // success
+        this.spinner.succeed('App tests passed')
+      } else {
+        throw new Error('App tests failed')
+      }
+    })
+  }
+}
+
+InstallCommand.hidden = true // hide from help for pre-release
+
+InstallCommand.description = chalk.yellow(`(Pre-release) This command will support installing apps packaged by '<%= config.bin %> app pack'.
+`)
+
+InstallCommand.flags = {
+  ...BaseCommand.flags,
+  output: Flags.string({
+    description: 'The packaged app output folder path',
+    char: 'o',
+    default: '.'
+  })
+}
+
+InstallCommand.args = [
+  {
+    name: 'path',
+    description: 'Path to the app package to install',
+    required: true
+  }
+]
+
+module.exports = InstallCommand

package/src/commands/app/pack.js

@@ -0,0 +1,296 @@
+/*
+Copyright 2023 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 { Flags } = require('@oclif/core')
+const path = require('node:path')
+const fs = require('fs-extra')
+const aioLogger = require('@adobe/aio-lib-core-logging')('@adobe/aio-cli-plugin-app:pack', { provider: 'debug' })
+const archiver = require('archiver')
+const yaml = require('js-yaml')
+const execa = require('execa')
+const { loadConfigFile, writeFile } = require('../../lib/import-helper')
+const { getObjectValue } = require('../../lib/app-helper')
+const ora = require('ora')
+const chalk = require('chalk')
+
+const DEFAULTS = {
+  OUTPUT_ZIP_FILE: 'app.zip',
+  ARTIFACTS_FOLDER: 'app-package',
+  DEPLOY_YAML_FILE: 'deploy.yaml'
+}
+
+class Pack extends BaseCommand {
+  async run () {
+    const { args, flags } = await this.parse(Pack)
+
+    this.preRelease()
+
+    aioLogger.debug(`flags: ${JSON.stringify(flags, null, 2)}`)
+    aioLogger.debug(`args: ${JSON.stringify(args, null, 2)}`)
+
+    const appConfig = this.getFullConfig()
+
+    // resolve to absolute path before any chdir
+    const outputZipFile = path.resolve(flags.output)
+
+    // change the cwd if necessary
+    if (args.path !== '.') {
+      const resolvedPath = path.resolve(args.path)
+      process.chdir(resolvedPath)
+      aioLogger.debug(`changed current working directory to: ${resolvedPath}`)
+    }
+
+    try {
+      // 1. create artifacts phase
+      this.spinner.start(`Creating package artifacts folder '${DEFAULTS.ARTIFACTS_FOLDER}'...`)
+      await fs.emptyDir(DEFAULTS.ARTIFACTS_FOLDER)
+      this.spinner.succeed(`Created package artifacts folder '${DEFAULTS.ARTIFACTS_FOLDER}'`)
+
+      // ACNA-2038
+      // not artifacts folder should exist before we fire the event
+      await this.config.runHook('pre-pack', { appConfig, artifactsFolder: DEFAULTS.ARTIFACTS_FOLDER })
+
+      // 2. copy files to package phase
+      this.spinner.start('Copying project files...')
+      const fileList = await this.filesToPack([flags.output])
+      await this.copyPackageFiles(DEFAULTS.ARTIFACTS_FOLDER, fileList)
+      this.spinner.succeed('Copied project files')
+
+      // 3. add/modify artifacts phase
+      this.spinner.start('Creating configuration files...')
+      await this.createDeployYamlFile(appConfig)
+      this.spinner.succeed('Created configuration files')
+
+      this.spinner.start('Adding code-download annotations...')
+      await this.addCodeDownloadAnnotation(appConfig)
+      this.spinner.succeed('Added code-download annotations')
+
+      // doing this before zip so other things can be added to the zip
+      await this.config.runHook('post-pack', { appConfig, artifactsFolder: DEFAULTS.ARTIFACTS_FOLDER })
+
+      // 4. zip package phase
+      this.spinner.start(`Zipping package artifacts folder '${DEFAULTS.ARTIFACTS_FOLDER}' to '${outputZipFile}'...`)
+      await fs.remove(outputZipFile)
+      await this.zipHelper(DEFAULTS.ARTIFACTS_FOLDER, outputZipFile)
+      this.spinner.succeed(`Zipped package artifacts folder '${DEFAULTS.ARTIFACTS_FOLDER}' to '${outputZipFile}'`)
+    } catch (e) {
+      this.spinner.fail(e.message)
+      this.error(flags.verbose ? e : e.message)
+    }
+
+    this.spinner.succeed('Packaging done.')
+  }
+
+  get spinner () {
+    if (!this._spinner) {
+      this._spinner = ora()
+    }
+    return this._spinner
+  }
+
+  /**
+   * Creates the deploy.yaml file
+   *
+   * @param {object} appConfig the app's configuration file
+   */
+  async createDeployYamlFile (appConfig) {
+    // get extensions
+    let extensions
+    if (appConfig.implements?.filter(item => item !== 'application').length > 0) {
+      extensions = appConfig.implements.map(ext => ({ extensionPointId: ext }))
+    }
+
+    // get workspaces
+    let workspaces
+    if (appConfig.aio?.project?.workspace?.name) {
+      workspaces = []
+      workspaces.push(appConfig.aio?.project?.workspace?.name)
+    }
+
+    // get apis
+    let apis
+    if (appConfig.aio?.project?.workspace?.details?.services?.length > 0) {
+      apis = appConfig.aio.project.workspace.details.services.map(service => ({ code: service.code }))
+    }
+
+    // read name and version from package.json
+    const application = {
+      id: appConfig.packagejson.name,
+      version: appConfig.packagejson.version
+    }
+
+    let meshConfig
+    // ACNA-2041
+    // get the mesh config by running the `aio api-mesh:get` command (if available)
+    // in the interim, we need to process the output to get the proper json config
+    // TODO: send a PR to their plugin to have a `--json` flag
+    const command = await this.config.findCommand('api-mesh:get')
+    if (command) {
+      this.spinner.start('Getting api-mesh config...')
+      const { stdout } = await execa('aio', ['api-mesh', 'get'], { cwd: process.cwd() })
+      // until we get the --json flag, we parse the output
+      const idx = stdout.indexOf('{')
+      meshConfig = JSON.parse(stdout.substring(idx))
+      aioLogger.debug(`api-mesh:get - ${JSON.stringify(meshConfig, null, 2)}`)
+      this.spinner.succeed('Got api-mesh config')
+    } else {
+      aioLogger.debug('api-mesh:get command was not found, meshConfig is not available for app:pack')
+    }
+
+    const deployJson = {
+      $schema: 'http://json-schema.org/draft-07/schema',
+      $id: 'https://adobe.io/schemas/app-builder-templates/1',
+      application,
+      extensions,
+      workspaces,
+      apis,
+      meshConfig,
+      runtime: true // always true for App Builder apps
+    }
+
+    await writeFile(
+      path.join(DEFAULTS.ARTIFACTS_FOLDER, DEFAULTS.DEPLOY_YAML_FILE),
+      yaml.dump(deployJson),
+      { overwrite: true })
+  }
+
+  /**
+   * Copies a list of files to a folder.
+   *
+   * @param {string} destinationFolder the destination folder for the files
+   * @param {Array<string>} filesList a list of files to copy
+   */
+  async copyPackageFiles (destinationFolder, filesList) {
+    for (const src of filesList) {
+      const dest = path.join(destinationFolder, src)
+      if (await fs.pathExists(src)) {
+        aioLogger.debug(`Copying ${src} to ${dest}`)
+        await fs.copy(src, dest)
+      } else {
+        aioLogger.debug(`Skipping copy for ${src} (path does not exist)`)
+      }
+    }
+  }
+
+  /**
+   * Zip a file/folder using archiver
+   *
+   * @param {string} filePath path of file/folder to zip
+   * @param {string} out output path
+   * @param {boolean} pathInZip internal path in zip
+   * @returns {Promise} returns with a blank promise when done
+   */
+  zipHelper (filePath, out, pathInZip = false) {
+    aioLogger.debug(`Creating zip of file/folder '${filePath}'`)
+    const stream = fs.createWriteStream(out)
+    const archive = archiver('zip', { zlib: { level: 9 } })
+
+    return new Promise((resolve, reject) => {
+      stream.on('close', () => resolve())
+      archive.pipe(stream)
+      archive.on('error', err => reject(err))
+
+      let stats
+      try {
+        stats = fs.lstatSync(filePath) // throws if enoent
+      } catch (e) {
+        archive.destroy()
+        reject(e)
+      }
+
+      if (stats.isDirectory()) {
+        archive.directory(filePath, pathInZip)
+      } else { //  if (stats.isFile()) {
+        archive.file(filePath, { name: pathInZip || path.basename(filePath) })
+      }
+      archive.finalize()
+    })
+  }
+
+  /**
+   * Gets a list of files that are to be packed.
+   *
+   * This runs `npm pack` to get the list.
+   *
+   * @param {Array<string>} filesToExclude a list of files to exclude
+   * @param {string} workingDirectory the working directory to run `npm pack` in
+   * @returns {Array<string>} a list of files that are to be packed
+   */
+  async filesToPack (filesToExclude = [], workingDirectory = process.cwd()) {
+    const { stdout } = await execa('npm', ['pack', '--dry-run', '--json'], { cwd: workingDirectory })
+
+    const { files } = JSON.parse(stdout)[0]
+    return files
+      .map(file => file.path)
+      .filter(file => !filesToExclude.includes(file))
+  }
+
+  /**
+   * An annotation called code-download will be added to all actions in app.config.yaml
+   * (and linked yaml configs for example in extensions). This value will be set to false.
+   * The annotation will by default be true if not set.
+   *
+   * @param {object} appConfig the app's configuration file
+   */
+  async addCodeDownloadAnnotation (appConfig) {
+    // get the configFiles that have runtime manifests
+    const configFiles = []
+    for (const [, value] of Object.entries(appConfig.includeIndex)) {
+      const { key } = value
+      if (key === 'runtimeManifest' || key === 'application.runtimeManifest') {
+        configFiles.push(value)
+      }
+    }
+
+    // for each configFile, we modify each action to have the "code-download: false" annotation
+    for (const configFile of configFiles) {
+      const configFilePath = path.join(DEFAULTS.ARTIFACTS_FOLDER, configFile.file)
+      const { values } = loadConfigFile(configFilePath)
+
+      const runtimeManifest = getObjectValue(values, configFile.key)
+      for (const [, pkgManifest] of Object.entries(runtimeManifest.packages)) {
+        // key is the package name (unused), value is the package manifest. we iterate through each package's "actions"
+        for (const [, actionManifest] of Object.entries(pkgManifest.actions)) {
+          // key is the action name (unused), value is the action manifest. we add the "code-download: false" annotation
+          actionManifest.annotations['code-download'] = false
+        }
+      }
+
+      // write back the modified manifest to disk
+      await writeFile(configFilePath, yaml.dump(values), { overwrite: true })
+    }
+  }
+}
+
+Pack.hidden = true // hide from help for pre-release
+
+Pack.description = chalk.yellow(`(Pre-release) This command will support packaging apps for redistribution.
+`)
+
+Pack.flags = {
+  ...BaseCommand.flags,
+  output: Flags.string({
+    description: 'The packaged app output file path',
+    char: 'o',
+    default: DEFAULTS.OUTPUT_ZIP_FILE
+  })
+}
+
+Pack.args = [
+  {
+    name: 'path',
+    description: 'Path to the app directory to package',
+    default: '.'
+  }
+]
+
+module.exports = Pack

package/src/commands/app/test.js

@@ -48,6 +48,7 @@ class Test extends BaseCommand {
 
     this.printReport(totalResults)
     process.exitCode = exitCode
+    return exitCode
   }
 
   printReport (totalResults) {

package/src/lib/app-helper.js

@@ -505,7 +505,32 @@ const createWebExportFilter = (filterValue) => {
   }
 }
 
+/**
+ * Get property from object with case insensitivity.
+ *
+ * @param {object} obj the object to wrap
+ * @param {string} key the key
+ * @private
+ */
+function getObjectProp (obj, key) {
+  return obj[Object.keys(obj).find(k => k.toLowerCase() === key.toLowerCase())]
+}
+
+/**
+ * Get a value in an object by dot notation.
+ *
+ * @param {object} obj the object to wrap
+ * @param {string} key the key
+ * @returns {object} the value
+ */
+function getObjectValue (obj, key) {
+  const keys = (key || '').toString().split('.')
+  return keys.filter(o => o.trim()).reduce((o, i) => o && getObjectProp(o, i), obj)
+}
+
 module.exports = {
+  getObjectValue,
+  getObjectProp,
   createWebExportFilter,
   isNpmInstalled,
   isGitInstalled,

package/src/lib/defaults.js

@@ -30,7 +30,9 @@ module.exports = {
   defaultHttpServerPort: 9080,
   AIO_CONFIG_WORKSPACE_SERVICES: 'project.workspace.details.services',
   AIO_CONFIG_ORG_SERVICES: 'project.org.details.services',
+  IMPORT_CONFIG_FILE: 'config.json',
   USER_CONFIG_FILE: 'app.config.yaml',
+  DEPLOY_CONFIG_FILE: 'deploy.yaml',
   LEGACY_RUNTIME_MANIFEST: 'manifest.yml',
   INCLUDE_DIRECTIVE: '$include',
   APPLICATION_CONFIG_KEY: 'application',

package/src/lib/deploy-actions.js

@@ -34,11 +34,16 @@ module.exports = async (config, isLocalDev = false, log = () => {}, filter = fal
     }
     if (inprocHook) {
       const hookFilterEntities = Array.isArray(filter) ? filter : []
-      await inprocHook('deploy-actions', {
+      const hookResults = await inprocHook('deploy-actions', {
         appConfig: config,
         filterEntities: hookFilterEntities,
         isLocalDev
       })
+      if (hookResults?.failures?.length > 0) {
+        // output should be "Error : <plugin-name> : <error-message>\n" for each failure
+        log('Error: ' + hookResults.failures.map(f => `${f.plugin.name} : ${f.error.message}`).join('\nError: '))
+        throw new Error(`Hook 'deploy-actions' failed with ${hookResults.failures[0].error}`)
+      }
     }
     const entities = await deployActions(config, deployConfig, log)
     if (entities.actions) {

package/src/lib/import-helper.js

@@ -17,8 +17,8 @@ const fs = require('fs-extra')
 const inquirer = require('inquirer')
 const yaml = require('js-yaml')
 const hjson = require('hjson')
-const Ajv = require('ajv')
 const { EOL } = require('os')
+const { validateJsonWithSchema } = require('./install-helper')
 
 const AIO_FILE = '.aio'
 const ENV_FILE = '.env'
@@ -33,21 +33,6 @@ const CONSOLE_CONFIG_KEY = 'console'
 // this into an init/constructor as it might create mocking issues in jest
 const prompt = inquirer.createPromptModule({ output: process.stderr })
 
-/**
- * Validate the config json
- *
- * @param {object} configJson the json to validate
- * @returns {object} with keys valid (boolean) and errors (object). errors is null if no errors
- */
-function validateConfig (configJson) {
-  /* eslint-disable-next-line node/no-unpublished-require */
-  const schema = require('../../schema/config.schema.json')
-  const ajv = new Ajv({ allErrors: true })
-  const validate = ajv.compile(schema)
-
-  return { valid: validate(configJson), errors: validate.errors }
-}
-
 /**
  * Load a config file
  *
@@ -92,7 +77,7 @@ function loadConfigFile (fileOrBuffer) {
  */
 function loadAndValidateConfigFile (fileOrBuffer) {
   const res = loadConfigFile(fileOrBuffer)
-  const { valid: configIsValid, errors: configErrors } = validateConfig(res.values)
+  const { valid: configIsValid, errors: configErrors } = validateJsonWithSchema(res.values, 'config.json')
   if (!configIsValid) {
     const message = `Missing or invalid keys in config: ${JSON.stringify(configErrors, null, 2)}`
     throw new Error(message)
@@ -616,7 +601,7 @@ async function importConfigJson (configFileOrBuffer, destinationFolder = process
 }
 
 module.exports = {
-  validateConfig,
+  writeFile,
   loadConfigFile,
   loadAndValidateConfigFile,
   writeConsoleConfig,

package/src/lib/install-helper.js

@@ -0,0 +1,37 @@
+/*
+Copyright 2023 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 Ajv = require('ajv')
+const ajvAddFormats = require('ajv-formats')
+
+/**
+ * Validate the file json with one of our schemas.
+ *
+ * @param {object} fileJson the json to validate
+ * @param {string} schemaName one of config.json, app.config.yaml, deploy.yaml
+ * @returns {object} with keys valid (boolean) and errors (object). errors is null if no errors
+ */
+function validateJsonWithSchema (fileJson, schemaName) {
+  /* eslint-disable-next-line node/no-unpublished-require */
+  const schemas = require('../../schema/index')
+  const ajv = new Ajv({
+    allErrors: true,
+    allowUnionTypes: true
+  })
+  ajvAddFormats(ajv)
+
+  const validate = ajv.compile(schemas[schemaName])
+  return { valid: validate(fileJson), errors: validate.errors }
+}
+
+module.exports = {
+  validateJsonWithSchema
+}