@knocklabs/cli 0.3.0 → 1.0.0-rc.1

package/dist/commands/init.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return Init;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
+const _enquirer = /*#__PURE__*/ _interop_require_default(require("enquirer"));
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../lib/base-command"));
+const _projectconfig = require("../lib/helpers/project-config");
+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 Init extends _basecommand.default {
+    async run() {
+        const configPath = _nodepath.resolve(process.cwd(), _projectconfig.PROJECT_CONFIG_FILE_NAME);
+        // 1. Check if knock.json already exists
+        const configExists = await _fsextra.pathExists(configPath);
+        if (configExists) {
+            this.error(`A ${_projectconfig.PROJECT_CONFIG_FILE_NAME} file already exists in this directory. Aborting.`);
+        }
+        // 2. Prompt user for the knock directory location
+        const { knockDir } = await _enquirer.default.prompt({
+            type: "input",
+            name: "knockDir",
+            message: "Where do you want to store your Knock resources?",
+            initial: ".knock"
+        });
+        // 3. Create the knock directory and resource subdirectories
+        const knockDirPath = _nodepath.resolve(process.cwd(), knockDir);
+        await _fsextra.ensureDir(knockDirPath);
+        // 4. Write the knock.json configuration file
+        await _fsextra.outputJson(configPath, {
+            $schema: "https://schemas.knock.app/cli/knock.json",
+            knockDir
+        }, {
+            spaces: 2
+        });
+        this.log(`‣ Successfully initialized Knock project at ${process.cwd()}`);
+        this.log(`‣ Resources directory: ${knockDir}`);
+    }
+    constructor(...args){
+        super(...args), _define_property(this, "requiresAuth", false);
+    }
+}
+_define_property(Init, "summary", "Initialize a new Knock project with a knock.json configuration file.");
+_define_property(Init, "description", "Creates a knock.json configuration file in the current directory " + "to store project-level settings like the knock resources directory.");

package/dist/commands/layout/new.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return EmailLayoutNew;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
+const _core = require("@oclif/core");
+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 _emaillayout = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/email-layout"));
+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, {
+            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 EmailLayoutNew extends _basecommand.default {
+    async run() {
+        const { flags } = this.props;
+        const { resourceDir } = this.runContext;
+        // 1. Ensure we aren't in any existing resource directory already.
+        if (resourceDir) {
+            return this.error(`Cannot create a new email layout inside an existing ${resourceDir.type} directory`);
+        }
+        // 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: "Email layout name",
+                validate: (value)=>{
+                    if (!value || value.trim().length === 0) {
+                        return "Email layout name is required";
+                    }
+                    return true;
+                }
+            });
+            name = nameResponse.name;
+        }
+        if (!key) {
+            const keyResponse = await (0, _enquirer.prompt)({
+                type: "input",
+                name: "key",
+                message: "Email layout key (immutable slug)",
+                initial: (0, _string.slugify)(name),
+                validate: (value)=>{
+                    if (!value || value.trim().length === 0) {
+                        return "Email layout key is required";
+                    }
+                    const keyError = _emaillayout.validateEmailLayoutKey(value);
+                    if (keyError) {
+                        return `Invalid email layout key: ${keyError}`;
+                    }
+                    return true;
+                }
+            });
+            key = keyResponse.key;
+        }
+        // Validate the email layout key
+        const emailLayoutKeyError = _emaillayout.validateEmailLayoutKey(key);
+        if (emailLayoutKeyError) {
+            return this.error(`Invalid email layout key \`${key}\` (${emailLayoutKeyError})`);
+        }
+        const emailLayoutDirCtx = await this.getEmailLayoutDirContext(key);
+        const promptMessage = emailLayoutDirCtx.exists ? `Found \`${emailLayoutDirCtx.key}\` at ${emailLayoutDirCtx.abspath}, overwrite?` : `Create a new email layout directory \`${emailLayoutDirCtx.key}\` at ${emailLayoutDirCtx.abspath}?`;
+        // Check if the email layout directory already exists, and prompt to confirm if not.
+        const input = flags.force || await (0, _ux.promptToConfirm)(promptMessage);
+        if (!input) return;
+        // Generate the email layout either from a template or from scratch
+        await (flags.template ? this.fromTemplate(emailLayoutDirCtx, name, flags.template) : this.fromScratch(emailLayoutDirCtx, name));
+        if (flags.push) {
+            _ux.spinner.start("‣ Pushing email layout to Knock");
+            try {
+                await _push.default.run([
+                    key
+                ]);
+            } catch (error) {
+                this.error(`Failed to push email layout to Knock: ${error}`);
+            } finally{
+                _ux.spinner.stop();
+            }
+        }
+        this.log(`‣ Successfully created email layout \`${key}\``);
+    }
+    async fromTemplate(emailLayoutDirCtx, name, templateString) {
+        // When being called from the template string, we want to try and generate
+        // the email layout from the provided template.
+        _ux.spinner.start(`‣ Generating email layout from template \`${templateString}\``);
+        try {
+            await _emaillayout.generateEmailLayoutFromTemplate(emailLayoutDirCtx, templateString, {
+                name
+            });
+        } catch (error) {
+            this.error(`Failed to generate email layout from template: ${error}`);
+        } finally{
+            _ux.spinner.stop();
+        }
+    }
+    async fromScratch(emailLayoutDirCtx, name) {
+        // Generate the email layout directory with scaffolded content
+        await _emaillayout.generateEmailLayoutDir(emailLayoutDirCtx, {
+            name
+        });
+    }
+    async getEmailLayoutDirContext(emailLayoutKey) {
+        const { resourceDir, cwd: runCwd } = this.runContext;
+        // Inside an existing resource dir, use it if valid for the target email layout.
+        if (resourceDir) {
+            const target = {
+                commandId: _basecommand.default.id,
+                type: "email_layout",
+                key: emailLayoutKey
+            };
+            return (0, _runcontext.ensureResourceDirForTarget)(resourceDir, target);
+        }
+        // Default to knock project config first if present, otherwise cwd.
+        const dirCtx = await (0, _projectconfig.resolveResourceDir)(this.projectConfig, "email_layout", runCwd);
+        // Not inside any existing email layout directory, which means either create a
+        // new email layout directory in the cwd, or update it if there is one already.
+        if (emailLayoutKey) {
+            const dirPath = _nodepath.resolve(dirCtx.abspath, emailLayoutKey);
+            const exists = await _emaillayout.isEmailLayoutDir(dirPath);
+            return {
+                type: "email_layout",
+                key: emailLayoutKey,
+                abspath: dirPath,
+                exists
+            };
+        }
+        // Not in any email layout directory, nor an email layout key arg was given so error.
+        return this.error("Missing 1 required arg:\nemailLayoutKey");
+    }
+}
+_define_property(EmailLayoutNew, "summary", "Create a new email layout with a minimal configuration.");
+_define_property(EmailLayoutNew, "flags", {
+    name: _core.Flags.string({
+        summary: "The name of the email layout",
+        char: "n"
+    }),
+    key: _core.Flags.string({
+        summary: "The key of the email layout",
+        char: "k"
+    }),
+    environment: _core.Flags.string({
+        summary: "The environment to create the email layout in. Defaults to development.",
+        default: _const.KnockEnv.Development
+    }),
+    branch: _flag.branch,
+    force: _core.Flags.boolean({
+        summary: "Force the creation of the email layout directory without confirmation."
+    }),
+    push: _core.Flags.boolean({
+        summary: "Whether or not to push the email layout to Knock after creation.",
+        default: false,
+        char: "p"
+    }),
+    template: _core.Flags.string({
+        summary: "The template to use for the email layout. Should be `email-layouts/{key}`."
+    })
+});
+_define_property(EmailLayoutNew, "args", {});

package/dist/commands/layout/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 _emaillayout = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/email-layout"));
@@ -119,11 +120,8 @@ class EmailLayoutPull extends _basecommand.default {
     // Pull all email layouts
     async pullAllEmailLayouts() {
         const { flags } = this.props;
-        const defaultToCwd = {
-            abspath: this.runContext.cwd,
-            exists: true
-        };
-        const targetDirCtx = flags["layouts-dir"] || defaultToCwd;
+        const layoutsIndexDirCtx = await (0, _projectconfig.resolveResourceDir)(this.projectConfig, "email_layout", this.runContext.cwd);
+        const targetDirCtx = flags["layouts-dir"] || layoutsIndexDirCtx;
         const prompt = targetDirCtx.exists ? `Pull latest layouts into ${targetDirCtx.abspath}?\n  This will overwrite the contents of this directory.` : `Create a new layouts directory at ${targetDirCtx.abspath}?`;
         const input = flags.force || await (0, _ux.promptToConfirm)(prompt);
         if (!input) return;
@@ -171,10 +169,11 @@ class EmailLayoutPull extends _basecommand.default {
             };
             return (0, _runcontext.ensureResourceDirForTarget)(resourceDir, target);
         }
+        const layoutsIndexDirCtx = await (0, _projectconfig.resolveResourceDir)(this.projectConfig, "email_layout", runCwd);
         // Not inside any existing email layout directory, which means either create a
         // new email layout directory in the cwd, or update it if there is one already.
         if (emailLayoutKey) {
-            const dirPath = _nodepath.resolve(runCwd, emailLayoutKey);
+            const dirPath = _nodepath.resolve(layoutsIndexDirCtx.abspath, emailLayoutKey);
             const exists = await _emaillayout.isEmailLayoutDir(dirPath);
             return {
                 type: "email_layout",

package/dist/commands/layout/push.js

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

package/dist/commands/layout/validate.js

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

package/dist/commands/message-type/new.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return MessageTypeNew;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
+const _core = require("@oclif/core");
+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 _messagetype = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/message-type"));
+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, {
+            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 MessageTypeNew extends _basecommand.default {
+    async run() {
+        const { flags } = this.props;
+        const { resourceDir } = this.runContext;
+        // 1. Ensure we aren't in any existing resource directory already.
+        if (resourceDir) {
+            return this.error(`Cannot create a new message type inside an existing ${resourceDir.type} directory`);
+        }
+        // 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: "Message type name",
+                validate: (value)=>{
+                    if (!value || value.trim().length === 0) {
+                        return "Message type name is required";
+                    }
+                    return true;
+                }
+            });
+            name = nameResponse.name;
+        }
+        if (!key) {
+            const keyResponse = await (0, _enquirer.prompt)({
+                type: "input",
+                name: "key",
+                message: "Message type key (immutable slug)",
+                initial: (0, _string.slugify)(name),
+                validate: (value)=>{
+                    if (!value || value.trim().length === 0) {
+                        return "Message type key is required";
+                    }
+                    const keyError = _messagetype.validateMessageTypeKey(value);
+                    if (keyError) {
+                        return `Invalid message type key: ${keyError}`;
+                    }
+                    return true;
+                }
+            });
+            key = keyResponse.key;
+        }
+        // Validate the message type key
+        const messageTypeKeyError = _messagetype.validateMessageTypeKey(key);
+        if (messageTypeKeyError) {
+            return this.error(`Invalid message type key \`${key}\` (${messageTypeKeyError})`);
+        }
+        const messageTypeDirCtx = await this.getMessageTypeDirContext(key);
+        const promptMessage = messageTypeDirCtx.exists ? `Found \`${messageTypeDirCtx.key}\` at ${messageTypeDirCtx.abspath}, overwrite?` : `Create a new message type directory \`${messageTypeDirCtx.key}\` at ${messageTypeDirCtx.abspath}?`;
+        // Check if the message type directory already exists, and prompt to confirm if not.
+        const input = flags.force || await (0, _ux.promptToConfirm)(promptMessage);
+        if (!input) return;
+        // Generate the message type either from a template or from scratch
+        await (flags.template ? this.fromTemplate(messageTypeDirCtx, name, flags.template) : this.fromScratch(messageTypeDirCtx, name));
+        if (flags.push) {
+            _ux.spinner.start("‣ Pushing message type to Knock");
+            try {
+                await _push.default.run([
+                    key
+                ]);
+            } catch (error) {
+                this.error(`Failed to push message type to Knock: ${error}`);
+            } finally{
+                _ux.spinner.stop();
+            }
+        }
+        this.log(`‣ Successfully created message type \`${key}\``);
+    }
+    async fromTemplate(messageTypeDirCtx, name, templateString) {
+        // When being called from the template string, we want to try and generate
+        // the message type from the provided template.
+        _ux.spinner.start(`‣ Generating message type from template \`${templateString}\``);
+        try {
+            await _messagetype.generateMessageTypeFromTemplate(messageTypeDirCtx, templateString, {
+                name
+            });
+        } catch (error) {
+            this.error(`Failed to generate message type from template: ${error}`);
+        } finally{
+            _ux.spinner.stop();
+        }
+    }
+    async fromScratch(messageTypeDirCtx, name) {
+        // Generate the message type directory with scaffolded content
+        await _messagetype.generateMessageTypeDir(messageTypeDirCtx, {
+            name
+        });
+    }
+    async getMessageTypeDirContext(messageTypeKey) {
+        const { resourceDir, cwd: runCwd } = this.runContext;
+        // Inside an existing resource dir, use it if valid for the target message type.
+        if (resourceDir) {
+            const target = {
+                commandId: _basecommand.default.id,
+                type: "message_type",
+                key: messageTypeKey
+            };
+            return (0, _runcontext.ensureResourceDirForTarget)(resourceDir, target);
+        }
+        // Default to knock project config first if present, otherwise cwd.
+        const dirCtx = await (0, _projectconfig.resolveResourceDir)(this.projectConfig, "message_type", runCwd);
+        // Not inside any existing message type directory, which means either create a
+        // new message type directory in the cwd, or update it if there is one already.
+        if (messageTypeKey) {
+            const dirPath = _nodepath.resolve(dirCtx.abspath, messageTypeKey);
+            const exists = await _messagetype.isMessageTypeDir(dirPath);
+            return {
+                type: "message_type",
+                key: messageTypeKey,
+                abspath: dirPath,
+                exists
+            };
+        }
+        // Not in any message type directory, nor a message type key arg was given so error.
+        return this.error("Missing 1 required arg:\nmessageTypeKey");
+    }
+}
+_define_property(MessageTypeNew, "summary", "Create a new message type with a minimal configuration.");
+_define_property(MessageTypeNew, "flags", {
+    name: _core.Flags.string({
+        summary: "The name of the message type",
+        char: "n"
+    }),
+    key: _core.Flags.string({
+        summary: "The key of the message type",
+        char: "k"
+    }),
+    environment: _core.Flags.string({
+        summary: "The environment to create the message type in. Defaults to development.",
+        default: _const.KnockEnv.Development
+    }),
+    branch: _flag.branch,
+    force: _core.Flags.boolean({
+        summary: "Force the creation of the message type directory without confirmation."
+    }),
+    push: _core.Flags.boolean({
+        summary: "Whether or not to push the message type to Knock after creation.",
+        default: false,
+        char: "p"
+    }),
+    template: _core.Flags.string({
+        summary: "The template to use for the message type. Should be `message-types/{key}`."
+    })
+});
+_define_property(MessageTypeNew, "args", {});

package/dist/commands/message-type/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 _messagetype = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/message-type"));
@@ -122,6 +123,7 @@ class MessageTypePull extends _basecommand.default {
     async getMessageTypeDirContext() {
         const { messageTypeKey } = this.props.args;
         const { resourceDir, cwd: runCwd } = this.runContext;
+        const messageTypesIndexDirCtx = await (0, _projectconfig.resolveResourceDir)(this.projectConfig, "message_type", runCwd);
         // Inside an existing resource dir, use it if valid for the target message
         // type.
         if (resourceDir) {
@@ -136,7 +138,7 @@ class MessageTypePull extends _basecommand.default {
         // a new message type directory in the cwd, or update it if there is one
         // already.
         if (messageTypeKey) {
-            const dirPath = _nodepath.resolve(runCwd, messageTypeKey);
+            const dirPath = _nodepath.resolve(messageTypesIndexDirCtx.abspath, messageTypeKey);
             const exists = await _messagetype.isMessageTypeDir(dirPath);
             return {
                 type: "message_type",
@@ -153,11 +155,8 @@ class MessageTypePull extends _basecommand.default {
    * Pull all message types
    */ async pullAllMessageTypes() {
         const { flags } = this.props;
-        const defaultToCwd = {
-            abspath: this.runContext.cwd,
-            exists: true
-        };
-        const targetDirCtx = flags["message-types-dir"] || defaultToCwd;
+        const messageTypesIndexDirCtx = await (0, _projectconfig.resolveResourceDir)(this.projectConfig, "message_type", this.runContext.cwd);
+        const targetDirCtx = flags["message-types-dir"] || messageTypesIndexDirCtx;
         const prompt = targetDirCtx.exists ? `Pull latest message types into ${targetDirCtx.abspath}?\n  This will overwrite the contents of this directory.` : `Create a new message types directory at ${targetDirCtx.abspath}?`;
         const input = flags.force || await (0, _ux.promptToConfirm)(prompt);
         if (!input) return;

package/dist/commands/message-type/push.js

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

package/dist/commands/message-type/validate.js

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