@knocklabs/cli 0.3.1 → 1.0.0

package/dist/commands/partial/open.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return PartialOpen;
+    }
+});
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _browser = require("../../lib/helpers/browser");
+const _error = require("../../lib/helpers/error");
+const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/helpers/flag"));
+const _request = require("../../lib/helpers/request");
+const _urls = require("../../lib/urls");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(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 _interop_require_wildcard(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 = {
+        __proto__: null
+    };
+    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 PartialOpen extends _basecommand.default {
+    async run() {
+        const whoamiResp = await this.apiV1.whoami();
+        if (!(0, _request.isSuccessResp)(whoamiResp)) {
+            const message = (0, _request.formatErrorRespMessage)(whoamiResp);
+            _core.ux.error(new _error.ApiError(message));
+        }
+        const { account_slug } = whoamiResp.data;
+        const { partialKey } = this.props.args;
+        const { environment, branch } = this.props.flags;
+        const envOrBranch = branch !== null && branch !== void 0 ? branch : environment;
+        const url = (0, _urls.viewPartialUrl)(this.sessionContext.dashboardOrigin, account_slug, envOrBranch, partialKey);
+        this.log(`‣ Opening partial \`${partialKey}\` in the Knock dashboard...`);
+        this.log(`  ${url}`);
+        await _browser.browser.openUrl(url);
+    }
+}
+_define_property(PartialOpen, "summary", "Open a partial in the Knock dashboard.");
+_define_property(PartialOpen, "flags", {
+    environment: _core.Flags.string({
+        default: "development",
+        summary: "The environment to use."
+    }),
+    branch: _flag.branch
+});
+_define_property(PartialOpen, "args", {
+    partialKey: _core.Args.string({
+        required: true
+    })
+});

package/dist/commands/partial/pull.js

@@ -16,6 +16,7 @@ const _error = require("../../lib/helpers/error");
 const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/helpers/flag"));
 const _objectisomorphic = require("../../lib/helpers/object.isomorphic");
 const _page = require("../../lib/helpers/page");
+const _projectconfig = require("../../lib/helpers/project-config");
 const _request = require("../../lib/helpers/request");
 const _ux = require("../../lib/helpers/ux");
 const _partial = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/partial"));
@@ -119,11 +120,8 @@ class PartialPull extends _basecommand.default {
     // Pull all partials
     async pullAllPartials() {
         const { flags } = this.props;
-        const defaultToCwd = {
-            abspath: this.runContext.cwd,
-            exists: true
-        };
-        const targetDirCtx = flags["partials-dir"] || defaultToCwd;
+        const partialsIndexDirCtx = await (0, _projectconfig.resolveResourceDir)(this.projectConfig, "partial", this.runContext.cwd);
+        const targetDirCtx = flags["partials-dir"] || partialsIndexDirCtx;
         const prompt = targetDirCtx.exists ? `Pull latest partials into ${targetDirCtx.abspath}?\n  This will overwrite the contents of this directory.` : `Create a new partials directory at ${targetDirCtx.abspath}?`;
         const input = flags.force || await (0, _ux.promptToConfirm)(prompt);
         if (!input) return;
@@ -171,10 +169,11 @@ class PartialPull extends _basecommand.default {
             };
             return (0, _runcontext.ensureResourceDirForTarget)(resourceDir, target);
         }
+        const partialsIndexDirCtx = await (0, _projectconfig.resolveResourceDir)(this.projectConfig, "partial", runCwd);
         // Not inside any existing partial directory, which means either create a
         // new partial directory in the cwd, or update it if there is one already.
         if (partialKey) {
-            const dirPath = _nodepath.resolve(runCwd, partialKey);
+            const dirPath = _nodepath.resolve(partialsIndexDirCtx.abspath, partialKey);
             const exists = await _partial.isPartialDir(dirPath);
             return {
                 type: "partial",

package/dist/commands/partial/push.js

@@ -83,7 +83,7 @@ class PartialPush extends _basecommand.default {
     async run() {
         const { flags } = this.props;
         // 1. First read all partial directories found for the given command.
-        const target = await _partial.ensureValidCommandTarget(this.props, this.runContext);
+        const target = await _partial.ensureValidCommandTarget(this.props, this.runContext, this.projectConfig);
         const [partials, readErrors] = await _partial.readAllForCommandTarget(target, {
             withExtractedFiles: true
         });

package/dist/commands/partial/validate.js

@@ -80,7 +80,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
 class PartialValidate extends _basecommand.default {
     async run() {
         // 1. Read all partial directories found for the given command.
-        const target = await _partial.ensureValidCommandTarget(this.props, this.runContext);
+        const target = await _partial.ensureValidCommandTarget(this.props, this.runContext, this.projectConfig);
         const [partials, readErrors] = await _partial.readAllForCommandTarget(target, {
             withExtractedFiles: true
         });

package/dist/commands/pull.js

@@ -12,6 +12,7 @@ const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
 const _core = require("@oclif/core");
 const _basecommand = /*#__PURE__*/ _interop_require_default(require("../lib/base-command"));
 const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../lib/helpers/flag"));
+const _projectconfig = require("../lib/helpers/project-config");
 const _ux = require("../lib/helpers/ux");
 const _resources = require("../lib/resources");
 const _pull = /*#__PURE__*/ _interop_require_default(require("./guide/pull"));
@@ -82,7 +83,11 @@ function _interop_require_wildcard(obj, nodeInterop) {
 class Pull extends _basecommand.default {
     async run() {
         const { flags } = this.props;
-        const targetDirCtx = flags["knock-dir"];
+        // Resolve knock directory: flag takes precedence, otherwise use knock.json
+        const targetDirCtx = await (0, _projectconfig.resolveKnockDir)(flags["knock-dir"], this.projectConfig);
+        if (!targetDirCtx) {
+            this.error("No knock directory specified. Either provide --knock-dir flag or run `knock init` to create a knock.json configuration file.");
+        }
         const prompt = targetDirCtx.exists ? `Pull latest resources into ${targetDirCtx.abspath}?\n  This will overwrite the contents of this directory.` : `Create a new resources directory at ${targetDirCtx.abspath}?`;
         const input = flags.force || await (0, _ux.promptToConfirm)(prompt);
         if (!input) return;
@@ -123,7 +128,7 @@ _define_property(Pull, "flags", {
     branch: _flag.branch,
     "knock-dir": _flag.dirPath({
         summary: "The target directory path to pull all resources into.",
-        required: true
+        required: false
     }),
     "hide-uncommitted-changes": _core.Flags.boolean({
         summary: "Hide any uncommitted changes."

package/dist/commands/push.js

@@ -14,6 +14,7 @@ const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
 const _basecommand = /*#__PURE__*/ _interop_require_default(require("../lib/base-command"));
 const _const = require("../lib/helpers/const");
 const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../lib/helpers/flag"));
+const _projectconfig = require("../lib/helpers/project-config");
 const _resources = require("../lib/resources");
 const _push = /*#__PURE__*/ _interop_require_default(require("./guide/push"));
 const _push1 = /*#__PURE__*/ _interop_require_default(require("./layout/push"));
@@ -83,9 +84,10 @@ function _interop_require_wildcard(obj, nodeInterop) {
 class Push extends _basecommand.default {
     async run() {
         const { flags } = this.props;
-        const targetDirCtx = flags["knock-dir"];
-        if (!targetDirCtx.exists) {
-            this.error(`Directory ${targetDirCtx.abspath} does not exist`);
+        // Resolve knock directory: flag takes precedence, otherwise use knock.json
+        const targetDirCtx = await (0, _projectconfig.resolveKnockDir)(flags["knock-dir"], this.projectConfig);
+        if (!targetDirCtx) {
+            this.error("No knock directory specified. Either provide --knock-dir flag or run `knock init` to create a knock.json configuration file.");
         }
         const args = [
             "--all",
@@ -133,7 +135,7 @@ _define_property(Push, "flags", {
     branch: _flag.branch,
     "knock-dir": _flag.dirPath({
         summary: "The target directory path to find all resources to push.",
-        required: true
+        required: false
     }),
     commit: _core.Flags.boolean({
         summary: "Push and commit the resource(s) at the same time"

package/dist/commands/translation/pull.js

@@ -79,7 +79,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 class TranslationPull extends _basecommand.default {
     async run() {
-        const target = await _translation.ensureValidCommandTarget(this.props, this.runContext);
+        const target = await _translation.ensureValidCommandTarget(this.props, this.runContext, this.projectConfig);
         switch(target.type){
             case "translationFile":
                 return this.pullOneTranslation(target.context);

package/dist/commands/translation/push.js

@@ -82,7 +82,7 @@ class TranslationPush extends _basecommand.default {
     async run() {
         const { flags } = this.props;
         // 1. First read all translation files found for the given command.
-        const target = await _translation.ensureValidCommandTarget(this.props, this.runContext);
+        const target = await _translation.ensureValidCommandTarget(this.props, this.runContext, this.projectConfig);
         const [translations, readErrors] = await _translation.readAllForCommandTarget(target);
         if (readErrors.length > 0) {
             this.error((0, _error.formatErrors)(readErrors, {

package/dist/commands/translation/validate.js

@@ -79,7 +79,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 class TranslationValidate extends _basecommand.default {
     async run() {
-        const target = await _translation.ensureValidCommandTarget(this.props, this.runContext);
+        const target = await _translation.ensureValidCommandTarget(this.props, this.runContext, this.projectConfig);
         const [translations, readErrors] = await _translation.readAllForCommandTarget(target);
         if (readErrors.length > 0) {
             this.error((0, _error.formatErrors)(readErrors, {

package/dist/commands/workflow/new.js

@@ -10,11 +10,17 @@ Object.defineProperty(exports, "default", {
 });
 const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
 const _core = require("@oclif/core");
-const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _enquirer = require("enquirer");
 const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
 const _const = require("../../lib/helpers/const");
+const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/helpers/flag"));
+const _projectconfig = require("../../lib/helpers/project-config");
+const _string = require("../../lib/helpers/string");
 const _ux = require("../../lib/helpers/ux");
 const _workflow = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/workflow"));
+const _generator = require("../../lib/marshal/workflow/generator");
+const _runcontext = require("../../lib/run-context");
+const _push = /*#__PURE__*/ _interop_require_default(require("./push"));
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -76,75 +82,194 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 class WorkflowNew extends _basecommand.default {
     async run() {
-        const { args, flags } = this.props;
-        const { cwd, resourceDir } = this.runContext;
-        _ux.spinner.start("‣ Validating");
+        const { flags } = this.props;
+        const { resourceDir } = this.runContext;
         // 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`);
+            return this.error(`Cannot create a new workflow inside an existing ${resourceDir.type} directory`);
         }
-        // 2. Ensure the workflow key is in the valid format.
-        const workflowKeyError = _workflow.validateWorkflowKey(args.workflowKey);
+        // 2. Prompt for name and key if not provided
+        let name = flags.name;
+        let key = flags.key;
+        if (!name) {
+            const nameResponse = await (0, _enquirer.prompt)({
+                type: "input",
+                name: "name",
+                message: "Workflow name",
+                validate: (value)=>{
+                    if (!value || value.trim().length === 0) {
+                        return "Workflow name is required";
+                    }
+                    return true;
+                }
+            });
+            name = nameResponse.name;
+        }
+        if (!key) {
+            const keyResponse = await (0, _enquirer.prompt)({
+                type: "input",
+                name: "key",
+                message: "Workflow key (immutable slug)",
+                initial: (0, _string.slugify)(name),
+                validate: (value)=>{
+                    if (!value || value.trim().length === 0) {
+                        return "Workflow key is required";
+                    }
+                    const keyError = _workflow.validateWorkflowKey(value);
+                    if (keyError) {
+                        return `Invalid workflow key: ${keyError}`;
+                    }
+                    return true;
+                }
+            });
+            key = keyResponse.key;
+        }
+        // Validate the workflow key
+        const workflowKeyError = _workflow.validateWorkflowKey(key);
         if (workflowKeyError) {
-            return this.error(`Invalid workflow key \`${args.workflowKey}\` (${workflowKeyError})`);
+            return this.error(`Invalid workflow key \`${key}\` (${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})`);
+        const workflowDirCtx = await this.getWorkflowDirContext(key);
+        const promptMessage = workflowDirCtx.exists ? `Found \`${workflowDirCtx.key}\` at ${workflowDirCtx.abspath}, overwrite?` : `Create a new workflow directory \`${workflowDirCtx.key}\` at ${workflowDirCtx.abspath}?`;
+        // Check if the workflow directory already exists, and prompt to confirm if not.
+        const input = flags.force || await (0, _ux.promptToConfirm)(promptMessage);
+        if (!input) return;
+        // Generate the workflow either from a template or from scratch
+        await (flags.template ? this.fromTemplate(workflowDirCtx, name, flags.template) : this.fromSteps(workflowDirCtx, name, flags.steps));
+        if (flags.push) {
+            _ux.spinner.start("‣ Pushing workflow to Knock");
+            try {
+                await _push.default.run([
+                    key
+                ]);
+            } catch (error) {
+                this.error(`Failed to push workflow to Knock: ${error}`);
+            } finally{
+                _ux.spinner.stop();
+            }
         }
-        // 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)");
+        this.log(`‣ Successfully created workflow \`${key}\``);
+    }
+    async fromTemplate(workflowDirCtx, name, templateString) {
+        // When being called from the template string, we want to try and generate
+        // the workflow from the provided template.
+        const channelsByType = await this.listAllChannelsByType();
+        _ux.spinner.start(`‣ Generating workflow from template \`${templateString}\``);
+        try {
+            await _workflow.generateWorkflowFromTemplate(workflowDirCtx, templateString, {
+                name
+            }, channelsByType);
+        } catch (error) {
+            this.error(`Failed to generate workflow from template: ${error}`);
+        } finally{
+            _ux.spinner.stop();
         }
-        _ux.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,
+    }
+    async fromSteps(workflowDirCtx, name, stepStr) {
+        const channelsByType = await this.listAllChannelsByType();
+        const channelTypes = Object.keys(channelsByType);
+        const availableStepTypes = _workflow.getAvailableStepTypes(channelTypes);
+        let steps = [];
+        // Stuff with steps
+        if (stepStr) {
+            // Parse steps from flag
+            const [parsedSteps, stepsError] = (0, _generator.parseStepsInput)(stepStr, availableStepTypes);
+            if (stepsError) {
+                return this.error(`Invalid --steps \`${stepStr}\` (${stepsError})`);
+            }
+            steps = parsedSteps || [];
+        } else {
+            // Prompt for steps with multiselect
+            const stepChoices = availableStepTypes.map((stepType)=>({
+                    name: stepType,
+                    message: _generator.StepTagChoices[stepType]
+                }));
+            const stepsResponse = await (0, _enquirer.prompt)({
+                type: "multiselect",
+                name: "steps",
+                message: "(optional) Select step types to bootstrap the workflow with",
+                choices: stepChoices
+            });
+            steps = (stepsResponse === null || stepsResponse === void 0 ? void 0 : stepsResponse.steps) || [];
+        }
+        // 6. Generate the workflow directory with scaffolded steps
+        await _workflow.generateWorkflowDir(workflowDirCtx, {
+            name,
             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 \`${flags.environment}\` environment`);
+        }, channelsByType);
+    }
+    async getWorkflowDirContext(workflowKey) {
+        const { resourceDir, cwd: runCwd } = this.runContext;
+        // Inside an existing resource dir, use it if valid for the target workflow.
+        if (resourceDir) {
+            const target = {
+                commandId: _basecommand.default.id,
+                type: "workflow",
+                key: workflowKey
+            };
+            return (0, _runcontext.ensureResourceDirForTarget)(resourceDir, target);
+        }
+        // Default to knock project config first if present, otherwise cwd.
+        const dirCtx = await (0, _projectconfig.resolveResourceDir)(this.projectConfig, "workflow", runCwd);
+        // Not inside any existing workflow directory, which means either create a
+        // new worfklow directory in the cwd, or update it if there is one already.
+        if (workflowKey) {
+            const dirPath = _nodepath.resolve(dirCtx.abspath, workflowKey);
+            const exists = await _workflow.isWorkflowDir(dirPath);
+            return {
+                type: "workflow",
+                key: workflowKey,
+                abspath: dirPath,
+                exists
+            };
         }
+        // Not in any workflow directory, nor a workflow key arg was given so error.
+        return this.error("Missing 1 required arg:\nworkflowKey");
     }
-    async checkExistingWorkflow() {
-        try {
-            const resp = await this.apiV1.getWorkflow(this.props);
-            return resp.status === 200;
-        } catch  {}
+    async listAllChannelsByType() {
+        const channels = await this.apiV1.listAllChannels();
+        // Group channels by type
+        // eslint-disable-next-line unicorn/no-array-reduce
+        const channelsByType = channels.reduce((acc, channel)=>({
+                ...acc,
+                [channel.type]: [
+                    ...acc[channel.type] || [],
+                    channel
+                ]
+            }), {});
+        return channelsByType;
     }
 }
+_define_property(WorkflowNew, "summary", "Create a new workflow with a minimal configuration.");
 _define_property(WorkflowNew, "flags", {
+    name: _core.Flags.string({
+        summary: "The name of the workflow",
+        char: "n"
+    }),
+    key: _core.Flags.string({
+        summary: "The key of the workflow",
+        char: "k"
+    }),
     steps: _core.Flags.string({
-        aliases: [
-            "step"
-        ]
+        summary: "Comma-separated list of step types to include in the workflow",
+        char: "s"
     }),
-    force: _core.Flags.boolean(),
     environment: _core.Flags.string({
-        hidden: true,
+        summary: "The environment to create the workflow in. Defaults to development.",
         default: _const.KnockEnv.Development
+    }),
+    branch: _flag.branch,
+    force: _core.Flags.boolean({
+        summary: "Force the creation of the workflow directory without confirmation."
+    }),
+    push: _core.Flags.boolean({
+        summary: "Whether or not to push the workflow to Knock after creation.",
+        default: false,
+        char: "p"
+    }),
+    template: _core.Flags.string({
+        summary: "The template repository to use for the workflow. Should be `workflows/{type}`. You cannot use this flag with --steps.",
+        char: "t"
     })
 });
-_define_property(WorkflowNew, "args", {
-    workflowKey: _core.Args.string({
-        required: true
-    })
-});
-// TODO(KNO-3072): Unhide after we move the generator logic to the backend.
-_define_property(WorkflowNew, "hidden", true);
+_define_property(WorkflowNew, "args", {});

package/dist/commands/workflow/open.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return WorkflowOpen;
+    }
+});
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _browser = require("../../lib/helpers/browser");
+const _error = require("../../lib/helpers/error");
+const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/helpers/flag"));
+const _request = require("../../lib/helpers/request");
+const _urls = require("../../lib/urls");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(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 _interop_require_wildcard(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 = {
+        __proto__: null
+    };
+    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 WorkflowOpen extends _basecommand.default {
+    async run() {
+        const whoamiResp = await this.apiV1.whoami();
+        if (!(0, _request.isSuccessResp)(whoamiResp)) {
+            const message = (0, _request.formatErrorRespMessage)(whoamiResp);
+            _core.ux.error(new _error.ApiError(message));
+        }
+        const { account_slug } = whoamiResp.data;
+        const { workflowKey } = this.props.args;
+        const { environment, branch } = this.props.flags;
+        const envOrBranch = branch !== null && branch !== void 0 ? branch : environment;
+        const url = (0, _urls.viewWorkflowUrl)(this.sessionContext.dashboardOrigin, account_slug, envOrBranch, workflowKey);
+        this.log(`‣ Opening workflow \`${workflowKey}\` in the Knock dashboard...`);
+        this.log(`  ${url}`);
+        await _browser.browser.openUrl(url);
+    }
+}
+_define_property(WorkflowOpen, "summary", "Open a workflow in the Knock dashboard.");
+_define_property(WorkflowOpen, "flags", {
+    environment: _core.Flags.string({
+        default: "development",
+        summary: "The environment to use."
+    }),
+    branch: _flag.branch
+});
+_define_property(WorkflowOpen, "args", {
+    workflowKey: _core.Args.string({
+        required: true
+    })
+});