@knocklabs/cli 0.1.0-rc.0 → 0.1.0-rc.2

package/README.md

@@ -16,7 +16,7 @@ $ npm install -g @knocklabs/cli
 $ knock COMMAND
 running command...
 $ knock (--version)
-@knocklabs/cli/0.1.0-rc.0 darwin-arm64 node-v16.4.0
+@knocklabs/cli/0.1.0-rc.2 linux-x64 node-v16.4.2
 $ knock --help [COMMAND]
 USAGE
   $ knock COMMAND
@@ -27,6 +27,8 @@ USAGE
 # Commands
 
 <!-- commands -->
+* [`knock commit`](#knock-commit)
+* [`knock commit promote`](#knock-commit-promote)
 * [`knock help [COMMANDS]`](#knock-help-commands)
 * [`knock ping`](#knock-ping)
 * [`knock plugins`](#knock-plugins)
@@ -38,10 +40,41 @@ USAGE
 * [`knock plugins:uninstall PLUGIN...`](#knock-pluginsuninstall-plugin-1)
 * [`knock plugins:uninstall PLUGIN...`](#knock-pluginsuninstall-plugin-2)
 * [`knock plugins update`](#knock-plugins-update)
+* [`knock workflow activate WORKFLOWKEY`](#knock-workflow-activate-workflowkey)
 * [`knock workflow get WORKFLOWKEY`](#knock-workflow-get-workflowkey)
 * [`knock workflow list`](#knock-workflow-list)
 * [`knock workflow pull [WORKFLOWKEY]`](#knock-workflow-pull-workflowkey)
 * [`knock workflow push [WORKFLOWKEY]`](#knock-workflow-push-workflowkey)
+* [`knock workflow validate [WORKFLOWKEY]`](#knock-workflow-validate-workflowkey)
+
+## `knock commit`
+
+```
+USAGE
+  $ knock commit --service-token <value> [--environment development] [-m <value>] [--force]
+
+FLAGS
+  -m, --commit-message=<value>  Use the given value as the commit message
+  --environment=<option>        [default: development] Committing changes applies to the development environment only,
+                                use `commit promote` to promote changes to a later environment
+                                <options: development>
+  --force
+  --service-token=<value>       (required) The service token to authenticate with
+```
+
+_See code: [dist/commands/commit/index.ts](https://github.com/knocklabs/knock-cli/blob/v0.1.0-rc.2/dist/commands/commit/index.ts)_
+
+## `knock commit promote`
+
+```
+USAGE
+  $ knock commit promote --service-token <value> --to <value> [--force]
+
+FLAGS
+  --force
+  --service-token=<value>  (required) The service token to authenticate with
+  --to=<value>             (required) The destination environment to promote changes from the preceding environment
+```
 
 ## `knock help [COMMANDS]`
 
@@ -61,7 +94,7 @@ DESCRIPTION
   Display help for knock.
 ```
 
-_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v5.2.2/src/commands/help.ts)_
+_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v5.2.6/src/commands/help.ts)_
 
 ## `knock ping`
 
@@ -72,7 +105,7 @@ USAGE
   $ knock ping --service-token <value>
 
 FLAGS
-  --service-token=<value>  (required) service token to authenticate with
+  --service-token=<value>  (required) The service token to authenticate with
 
 DESCRIPTION
   Ping the Knock management API to verify access.
@@ -81,7 +114,7 @@ EXAMPLES
   $ knock ping
 ```
 
-_See code: [dist/commands/ping.ts](https://github.com/knocklabs/knock-cli/blob/v0.1.0-rc.0/dist/commands/ping.ts)_
+_See code: [dist/commands/ping.ts](https://github.com/knocklabs/knock-cli/blob/v0.1.0-rc.2/dist/commands/ping.ts)_
 
 ## `knock plugins`
 
@@ -101,7 +134,7 @@ EXAMPLES
   $ knock plugins
 ```
 
-_See code: [@oclif/plugin-plugins](https://github.com/oclif/plugin-plugins/blob/v2.3.0/src/commands/plugins/index.ts)_
+_See code: [@oclif/plugin-plugins](https://github.com/oclif/plugin-plugins/blob/v2.3.2/src/commands/plugins/index.ts)_
 
 ## `knock plugins:install PLUGIN...`
 
@@ -316,17 +349,31 @@ DESCRIPTION
   Update installed plugins.
 ```
 
+## `knock workflow activate WORKFLOWKEY`
+
+```
+USAGE
+  $ knock workflow activate WORKFLOWKEY --service-token <value> --environment <value> [--status true|false] [--force]
+
+FLAGS
+  --environment=<value>    (required)
+  --force
+  --service-token=<value>  (required) The service token to authenticate with
+  --status=<option>        [default: true]
+                           <options: true|false>
+```
+
 ## `knock workflow get WORKFLOWKEY`
 
 ```
 USAGE
-  $ knock workflow get [WORKFLOWKEY] --service-token <value> [--environment <value>] [--hide-uncommitted-changes]
+  $ knock workflow get WORKFLOWKEY --service-token <value> [--environment <value>] [--hide-uncommitted-changes]
     [--json]
 
 FLAGS
   --environment=<value>       [default: development]
   --hide-uncommitted-changes
-  --service-token=<value>     (required) service token to authenticate with
+  --service-token=<value>     (required) The service token to authenticate with
 
 GLOBAL FLAGS
   --json  Format output as json.
@@ -345,7 +392,7 @@ FLAGS
   --environment=<value>       [default: development]
   --hide-uncommitted-changes
   --limit=<value>
-  --service-token=<value>     (required) service token to authenticate with
+  --service-token=<value>     (required) The service token to authenticate with
 
 GLOBAL FLAGS
   --json  Format output as json.
@@ -360,18 +407,32 @@ USAGE
 FLAGS
   --environment=<value>       [default: development]
   --hide-uncommitted-changes
-  --service-token=<value>     (required) service token to authenticate with
+  --service-token=<value>     (required) The service token to authenticate with
 ```
 
 ## `knock workflow push [WORKFLOWKEY]`
 
 ```
 USAGE
-  $ knock workflow push [WORKFLOWKEY] --service-token <value> [--environment development]
+  $ knock workflow push [WORKFLOWKEY] --service-token <value> [--environment development] [-m <value> --commit]
+
+FLAGS
+  -m, --commit-message=<value>  Use the given value as the commit message
+  --commit                      Push and commit the workflow(s) at the same time
+  --environment=<option>        [default: development] Pushing a workflow is only allowed in the development environment
+                                <options: development>
+  --service-token=<value>       (required) The service token to authenticate with
+```
+
+## `knock workflow validate [WORKFLOWKEY]`
+
+```
+USAGE
+  $ knock workflow validate [WORKFLOWKEY] --service-token <value> [--environment development]
 
 FLAGS
-  --environment=<option>   [default: development]
+  --environment=<option>   [default: development] Validating a workflow is only done in the development environment
                            <options: development>
-  --service-token=<value>  (required) service token to authenticate with
+  --service-token=<value>  (required) The service token to authenticate with
 ```
 <!-- commandsstop -->

package/dist/commands/commit/index.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>Commit
+});
+const _core = require("@oclif/core");
+const _enquirer = /*#__PURE__*/ _interopRequireDefault(require("enquirer"));
+const _baseCommand = /*#__PURE__*/ _interopRequireDefault(require("../../lib/base-command"));
+const _const = require("../../lib/helpers/const");
+const _request = require("../../lib/helpers/request");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+// TODO(KNO-2647): Abstract this out as a helper.
+const promptToConfirm = async ()=>{
+    try {
+        const { input  } = await _enquirer.default.prompt({
+            type: "confirm",
+            name: "input",
+            message: "Commit all changes in the development environment?"
+        });
+        return input;
+    } catch (error) {
+        console.log(error);
+    }
+};
+class Commit extends _baseCommand.default {
+    async run() {
+        const { flags  } = this.props;
+        // Confirm first as we are about to commit changes to go live in the
+        // development environment, unless forced.
+        if (!flags.force) {
+            const input = await promptToConfirm();
+            if (!input) return;
+        }
+        await (0, _request.withSpinner)(()=>this.apiV1.commitAllChanges(this.props));
+        this.log(`‣ Successfully committed all changes in \`${flags.environment}\` environment`);
+    }
+}
+Commit.flags = {
+    environment: _core.Flags.string({
+        summary: "Committing changes applies to the development environment only, use `commit promote` to promote changes to a later environment",
+        default: _const.KnockEnv.Development,
+        options: [
+            _const.KnockEnv.Development
+        ]
+    }),
+    "commit-message": _core.Flags.string({
+        summary: "Use the given value as the commit message",
+        char: "m"
+    }),
+    force: _core.Flags.boolean()
+};

package/dist/commands/commit/promote.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>CommitPromote
+});
+const _core = require("@oclif/core");
+const _enquirer = /*#__PURE__*/ _interopRequireDefault(require("enquirer"));
+const _baseCommand = /*#__PURE__*/ _interopRequireDefault(require("../../lib/base-command"));
+const _request = require("../../lib/helpers/request");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const promptToConfirm = async ({ flags  })=>{
+    try {
+        const { input  } = await _enquirer.default.prompt({
+            type: "confirm",
+            name: "input",
+            message: `Promote all changes to \`${flags.to}\` environment?`
+        });
+        return input;
+    } catch (error) {
+        console.log(error);
+    }
+};
+class CommitPromote extends _baseCommand.default {
+    async run() {
+        const { flags  } = this.props;
+        // Confirm first as we are about to promote changes to go live in the target
+        // environment, unless forced.
+        if (!flags.force) {
+            const input = await promptToConfirm(this.props);
+            if (!input) return;
+        }
+        await (0, _request.withSpinner)(()=>this.apiV1.promoteAllChanges(this.props));
+        this.log(`‣ Successfully promoted all changes to \`${flags.to}\` environment`);
+    }
+}
+CommitPromote.flags = {
+    to: _core.Flags.string({
+        summary: "The destination environment to promote changes from the preceding environment",
+        required: true
+    }),
+    force: _core.Flags.boolean()
+};

package/dist/commands/workflow/activate.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>WorkflowActivate
+});
+const _core = require("@oclif/core");
+const _enquirer = /*#__PURE__*/ _interopRequireDefault(require("enquirer"));
+const _baseCommand = /*#__PURE__*/ _interopRequireDefault(require("../../lib/base-command"));
+const _flag = require("../../lib/helpers/flag");
+const _request = require("../../lib/helpers/request");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const promptToConfirm = async ({ flags , args  })=>{
+    const action = flags.status ? "Activate" : "Deactivate";
+    try {
+        const { input  } = await _enquirer.default.prompt({
+            type: "confirm",
+            name: "input",
+            message: `${action} \`${args.workflowKey}\` workflow in \`${flags.environment}\` environment?`
+        });
+        return input;
+    } catch (error) {
+        console.log(error);
+    }
+};
+class WorkflowActivate extends _baseCommand.default {
+    async run() {
+        const { args , flags  } = this.props;
+        // 1. Confirm before activating or deactivating the workflow, unless forced.
+        if (!flags.force) {
+            const input = await promptToConfirm(this.props);
+            if (!input) return;
+        }
+        // 2. Proceed to make a request to set the workflow status.
+        const actioning = flags.status ? "Activating" : "Deactivating";
+        await (0, _request.withSpinner)(()=>{
+            return this.apiV1.activateWorkflow(this.props);
+        }, {
+            action: `‣ ${actioning}`
+        });
+        const actioned = flags.status ? "activated" : "deactivated";
+        this.log(`‣ Successfully ${actioned} \`${args.workflowKey}\` workflow in \`${flags.environment}\` environment`);
+    }
+}
+WorkflowActivate.flags = {
+    // Do not default to any env for this command, since this action runs
+    // directly in each environment outside the commit and promote flow.
+    environment: _core.Flags.string({
+        required: true
+    }),
+    status: (0, _flag.booleanStr)({
+        default: true
+    }),
+    force: _core.Flags.boolean()
+};
+WorkflowActivate.args = [
+    {
+        name: "workflowKey",
+        required: true
+    }
+];

package/dist/commands/workflow/new.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>WorkflowNew
+});
+const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
+const _core = require("@oclif/core");
+const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
+const _baseCommand = /*#__PURE__*/ _interopRequireDefault(require("../../lib/base-command"));
+const _object = require("../../lib/helpers/object");
+const _spinner = /*#__PURE__*/ _interopRequireWildcard(require("../../lib/helpers/spinner"));
+const _workflow = /*#__PURE__*/ _interopRequireWildcard(require("../../lib/marshal/workflow"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+class WorkflowNew extends _baseCommand.default {
+    async run() {
+        const { args , flags  } = this.props;
+        const { cwd , resourceDir  } = this.runContext;
+        _spinner.start("‣ Validating");
+        // 1. Ensure we aren't in any existing resource directory already.
+        // TODO: In the future, maybe check for the project context and if we are in
+        // /workflows directory.
+        if (resourceDir) {
+            return this.error(`Cannot generate inside an existing ${resourceDir.type} directory`);
+        }
+        // 2. Ensure the workflow key is in the valid format.
+        const workflowKeyError = _workflow.validateWorkflowKey(args.workflowKey);
+        if (workflowKeyError) {
+            return this.error(`Invalid workflow key \`${args.workflowKey}\` (${workflowKeyError})`);
+        }
+        // 3. Parse and validate the steps flag, if given.
+        const [steps, stepsError] = _workflow.parseStepsInput(flags.steps || "");
+        if (stepsError) {
+            return this.error(`Invalid --steps \`${flags.steps}\` (${stepsError})`);
+        }
+        // 4. Ensure not to overwrite any existing path accidentally.
+        const newWorkflowDirPath = _nodePath.resolve(cwd, args.workflowKey);
+        const pathExists = await _fsExtra.pathExists(newWorkflowDirPath);
+        if (pathExists && !flags.force) {
+            return this.error(`Cannot overwrite an existing path at ${newWorkflowDirPath}` + " (use --force to overwrite)");
+        }
+        _spinner.stop();
+        // 5-A. We are good to generate a new workflow directory.
+        const dirContext = {
+            type: "workflow",
+            key: args.workflowKey,
+            abspath: newWorkflowDirPath,
+            exists: await _workflow.isWorkflowDir(newWorkflowDirPath)
+        };
+        const attrs = {
+            name: args.workflowKey,
+            steps
+        };
+        await _workflow.generateWorkflowDir(dirContext, attrs);
+        this.log(`‣ Successfully generated a workflow directory at ${dirContext.abspath}`);
+        // 5-B. Lastly warn if this workflow already exists in Knock.
+        const isExistingWorkflow = await this.checkExistingWorkflow();
+        if (isExistingWorkflow) {
+            this.log("");
+            this.warn(`Workflow \`${args.workflowKey}\` already exists in \`development\` environment`);
+        }
+    }
+    async checkExistingWorkflow() {
+        const props = (0, _object.merge)(this.props, {
+            flags: {
+                environment: "development"
+            }
+        });
+        try {
+            const resp = await this.apiV1.getWorkflow(props);
+            return resp.status === 200;
+        } catch  {}
+    }
+}
+WorkflowNew.flags = {
+    steps: _core.Flags.string({
+        aliases: [
+            "step"
+        ]
+    }),
+    force: _core.Flags.boolean()
+};
+WorkflowNew.args = [
+    {
+        name: "workflowKey",
+        required: true
+    }
+];
+// TODO(KNO-3072): Unhide after we move the generator logic to the backend.
+WorkflowNew.hidden = true;

package/dist/commands/workflow/pull.js

@@ -92,8 +92,8 @@ class WorkflowPull extends _baseCommand.default {
             });
             return this.apiV1.getWorkflow(props);
         });
-        // 3. Write the workflow with the workflow directory context.
-        await _workflow.writeWorkflowDir(resp.data, dirContext);
+        // 3. Write the fetched workflow to create or update the workflow directory.
+        await _workflow.writeWorkflowDirFromData(dirContext, resp.data);
         const action = dirContext.exists ? "updated" : "created";
         this.log(`‣ Successfully ${action} \`${dirContext.key}\` at ${dirContext.abspath}`);
     }

package/dist/commands/workflow/push.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "default", {
 const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
 const _core = require("@oclif/core");
 const _baseCommand = /*#__PURE__*/ _interopRequireDefault(require("../../lib/base-command"));
+const _const = require("../../lib/helpers/const");
 const _dirContext = require("../../lib/helpers/dir-context");
 const _error = require("../../lib/helpers/error");
 const _object = require("../../lib/helpers/object");
@@ -84,7 +85,7 @@ class WorkflowPush extends _baseCommand.default {
         });
         // 4. Update the workflow directory with the successfully pushed workflow
         // payload from the server.
-        await _workflow.writeWorkflowDir(resp.data.workflow, dirContext);
+        await _workflow.writeWorkflowDirFromData(dirContext, resp.data.workflow);
         this.log(`‣ Successfully pushed \`${dirContext.key}\`, and updated ${dirContext.abspath}`);
     }
     async getWorkflowDirContext() {
@@ -112,11 +113,21 @@ class WorkflowPush extends _baseCommand.default {
     }
 }
 WorkflowPush.flags = {
-    // TODO: Maybe make environments into an enum.
     environment: _core.Flags.string({
-        default: "development",
+        summary: "Pushing a workflow is only allowed in the development environment",
+        default: _const.KnockEnv.Development,
         options: [
-            "development"
+            _const.KnockEnv.Development
+        ]
+    }),
+    commit: _core.Flags.boolean({
+        summary: "Push and commit the workflow(s) at the same time"
+    }),
+    "commit-message": _core.Flags.string({
+        summary: "Use the given value as the commit message",
+        char: "m",
+        dependsOn: [
+            "commit"
         ]
     })
 };

package/dist/commands/workflow/validate.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>WorkflowValidate
+});
+const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
+const _core = require("@oclif/core");
+const _baseCommand = /*#__PURE__*/ _interopRequireDefault(require("../../lib/base-command"));
+const _const = require("../../lib/helpers/const");
+const _dirContext = require("../../lib/helpers/dir-context");
+const _error = require("../../lib/helpers/error");
+const _object = require("../../lib/helpers/object");
+const _request = require("../../lib/helpers/request");
+const _workflow = /*#__PURE__*/ _interopRequireWildcard(require("../../lib/marshal/workflow"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+class WorkflowValidate extends _baseCommand.default {
+    async run() {
+        // 1. Retrieve the target workflow directory context.
+        const dirContext = await this.getWorkflowDirContext();
+        this.log(`‣ Reading \`${dirContext.key}\` at ${dirContext.abspath}`);
+        // 2. Read the workflow.json with its template files.
+        const [workflow, errors] = await _workflow.readWorkflowDir(dirContext, {
+            withTemplateFiles: true
+        });
+        if (errors.length > 0) {
+            this.error(`Found the following errors in \`${dirContext.key}\` ${_workflow.WORKFLOW_JSON}\n\n` + (0, _error.formatErrors)(errors));
+        }
+        // 3. Validate the compiled workflow data.
+        await (0, _request.withSpinner)(()=>{
+            const props = (0, _object.merge)(this.props, {
+                args: {
+                    workflowKey: dirContext.key
+                }
+            });
+            return this.apiV1.validateWorkflow(props, workflow);
+        }, {
+            action: "‣ Validating"
+        });
+        this.log(`‣ Successfully validated \`${dirContext.key}\``);
+    }
+    async getWorkflowDirContext() {
+        const { workflowKey  } = this.props.args;
+        const { resourceDir , cwd: runCwd  } = this.runContext;
+        if (resourceDir) {
+            const target = {
+                commandId: _baseCommand.default.id,
+                type: "workflow",
+                key: workflowKey
+            };
+            return (0, _dirContext.ensureResourceDirForTarget)(resourceDir, target);
+        }
+        if (workflowKey) {
+            const dirPath = _nodePath.resolve(runCwd, workflowKey);
+            const exists = await _workflow.isWorkflowDir(dirPath);
+            return exists ? {
+                type: "workflow",
+                key: workflowKey,
+                abspath: dirPath,
+                exists
+            } : this.error(`Cannot locate a workflow directory for \`${workflowKey}\``);
+        }
+        return this.error("Missing 1 required arg:\nworkflowKey");
+    }
+}
+WorkflowValidate.flags = {
+    environment: _core.Flags.string({
+        summary: "Validating a workflow is only done in the development environment",
+        default: _const.KnockEnv.Development,
+        options: [
+            _const.KnockEnv.Development
+        ]
+    })
+};
+WorkflowValidate.args = [
+    {
+        name: "workflowKey",
+        required: false
+    }
+];