@knocklabs/cli 0.3.0 → 1.0.0-rc.1

package/dist/lib/helpers/project-config.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get PROJECT_CONFIG_FILE_NAME () {
+        return PROJECT_CONFIG_FILE_NAME;
+    },
+    get ResourceDirectoriesByType () {
+        return ResourceDirectoriesByType;
+    },
+    get findAndReadProjectConfig () {
+        return findAndReadProjectConfig;
+    },
+    get findProjectConfig () {
+        return findProjectConfig;
+    },
+    get readProjectConfig () {
+        return readProjectConfig;
+    },
+    get resolveKnockDir () {
+        return resolveKnockDir;
+    },
+    get resolveResourceDir () {
+        return resolveResourceDir;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
+const _findup = /*#__PURE__*/ _interop_require_default(require("find-up"));
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _zod = require("zod");
+const _fs = require("./fs");
+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;
+}
+const PROJECT_CONFIG_FILE_NAME = "knock.json";
+/**
+ * Schema for the project configuration file.
+ */ const projectConfigSchema = _zod.z.object({
+    knockDir: _zod.z.string()
+});
+const findProjectConfig = async ()=>{
+    const configPath = await (0, _findup.default)(PROJECT_CONFIG_FILE_NAME);
+    return configPath;
+};
+const readProjectConfig = async (configPath)=>{
+    const rawConfig = await _fsextra.readJSON(configPath);
+    const config = projectConfigSchema.parse(rawConfig);
+    return config;
+};
+const resolveKnockDir = async (knockDirFlag, projectConfig)=>{
+    if (knockDirFlag) {
+        return knockDirFlag;
+    }
+    if (!projectConfig) {
+        return undefined;
+    }
+    // Project configuration exists, must is invalid. So we error out.
+    if ([
+        "",
+        undefined,
+        null
+    ].includes(projectConfig.knockDir)) {
+        throw new Error("No knock directory specified in the project configuration");
+    }
+    const abspath = _nodepath.isAbsolute(projectConfig.knockDir) ? projectConfig.knockDir : _nodepath.resolve(process.cwd(), projectConfig.knockDir);
+    const exists = await _fsextra.pathExists(abspath);
+    if (!exists || !await (0, _fs.isDirectory)(abspath)) {
+        throw new Error(`${projectConfig.knockDir} does not exist or is not a directory`);
+    }
+    return {
+        abspath,
+        exists
+    };
+};
+const findAndReadProjectConfig = async ()=>{
+    const configPath = await findProjectConfig();
+    if (!configPath) {
+        return undefined;
+    }
+    return readProjectConfig(configPath);
+};
+const ResourceDirectoriesByType = {
+    workflow: "workflows",
+    guide: "guides",
+    partial: "partials",
+    email_layout: "layouts",
+    message_type: "message-types",
+    translation: "translations"
+};
+const resolveResourceDir = async (projectConfig, resourceType, basePath = process.cwd())=>{
+    if (!projectConfig) {
+        return {
+            abspath: basePath,
+            exists: true
+        };
+    }
+    const absoluteKnockDir = _nodepath.isAbsolute(projectConfig.knockDir) ? projectConfig.knockDir : _nodepath.resolve(basePath, projectConfig.knockDir);
+    const resourceDir = ResourceDirectoriesByType[resourceType];
+    const absResourceDirPath = _nodepath.resolve(absoluteKnockDir, resourceDir);
+    const exists = await _fsextra.pathExists(absResourceDirPath);
+    if (exists && !await (0, _fs.isDirectory)(absResourceDirPath)) {
+        throw new Error(`${absResourceDirPath} is not a directory`);
+    }
+    return {
+        abspath: absResourceDirPath,
+        exists
+    };
+};

package/dist/lib/helpers/request.js

@@ -49,14 +49,13 @@ const formatErrorRespMessage = ({ status, data })=>{
     return message;
 };
 const formatMgmtError = (apiError)=>{
+    var _apiError_error_message, _apiError_error_errors;
     if (apiError.status === 500) {
         return "An internal server error occurred";
     }
-    var _apiError_error_message;
     // Prefer the error message from the error object over
     // the error message formatted by the Stainless SDK
     const description = `${(_apiError_error_message = apiError.error.message) !== null && _apiError_error_message !== void 0 ? _apiError_error_message : apiError.message} (status: ${apiError.status})`;
-    var _apiError_error_errors;
     const inputErrors = (_apiError_error_errors = apiError.error.errors) !== null && _apiError_error_errors !== void 0 ? _apiError_error_errors : [];
     if (Array.isArray(inputErrors) && inputErrors.length > 0) {
         const errs = inputErrors.map((e)=>new _error.JsonDataError(e.message, e.field));

package/dist/lib/helpers/string.js

@@ -1,6 +1,4 @@
-/*
- * Checks if a given string is in a slugified format.
- */ "use strict";
+"use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
@@ -21,7 +19,9 @@ _export(exports, {
         return slugify;
     }
 });
-const SLUG_FORMAT_RE = /^[\w-]+$/;
+/*
+ * Checks if a given string is in a slugified format.
+ */ const SLUG_FORMAT_RE = /^[\w-]+$/;
 const SLUG_LOWERCASE_FORMAT_RE = /^[\d_a-z-]+$/;
 const checkSlugifiedFormat = (input, opts = {})=>{
     const { onlyLowerCase = true } = opts;

package/dist/lib/helpers/typegen.js

@@ -44,10 +44,10 @@ function getLanguageFromExtension(extension) {
     }
 }
 function transformSchema(schema) {
+    var _schema_properties;
     if (schema.type === "object" && !schema.additionalProperties) {
         schema.additionalProperties = false;
     }
-    var _schema_properties;
     for (const key of Object.keys((_schema_properties = schema.properties) !== null && _schema_properties !== void 0 ? _schema_properties : {})){
         const property = schema.properties[key];
         if (property.type === "object") {

package/dist/lib/marshal/email-layout/generator.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get generateEmailLayoutDir () {
+        return generateEmailLayoutDir;
+    },
+    get generateEmailLayoutFromTemplate () {
+        return generateEmailLayoutFromTemplate;
+    },
+    get scaffoldEmailLayoutDirBundle () {
+        return scaffoldEmailLayoutDirBundle;
+    },
+    get validateEmailLayoutKey () {
+        return validateEmailLayoutKey;
+    }
+});
+const _lodash = require("lodash");
+const _string = require("../../helpers/string");
+const _templates = /*#__PURE__*/ _interop_require_wildcard(require("../../templates"));
+const _constisomorphic = require("../shared/const.isomorphic");
+const _processorisomorphic = require("./processor.isomorphic");
+const _reader = require("./reader");
+const _writer = require("./writer");
+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;
+}
+const validateEmailLayoutKey = (input)=>{
+    if (!(0, _string.checkSlugifiedFormat)(input, {
+        onlyLowerCase: true
+    })) {
+        return "must include only lowercase alphanumeric, dash, or underscore characters";
+    }
+    return undefined;
+};
+/*
+ * Returns the default scaffolded HTML layout content.
+ */ const defaultHtmlLayoutContent = ()=>{
+    return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>{{ title }}</title>
+</head>
+<body>
+  <div style="max-width: 600px; margin: 0 auto; padding: 20px;">
+    {{ content }}
+  </div>
+</body>
+</html>`;
+};
+/*
+ * Returns the default scaffolded text layout content.
+ */ const defaultTextLayoutContent = ()=>{
+    return `{{ content }}`;
+};
+/*
+ * Scaffolds a new email layout directory bundle with default content.
+ */ const scaffoldEmailLayoutDirBundle = (attrs)=>{
+    const htmlLayoutFilePath = "html_layout.html";
+    const textLayoutFilePath = "text_layout.txt";
+    const defaultHtmlContent = defaultHtmlLayoutContent();
+    const defaultTextContent = defaultTextLayoutContent();
+    const layoutJson = {
+        name: attrs.name,
+        [`html_layout${_constisomorphic.FILEPATH_MARKER}`]: htmlLayoutFilePath,
+        [`text_layout${_constisomorphic.FILEPATH_MARKER}`]: textLayoutFilePath
+    };
+    return {
+        [_processorisomorphic.LAYOUT_JSON]: layoutJson,
+        [htmlLayoutFilePath]: defaultHtmlContent,
+        [textLayoutFilePath]: defaultTextContent
+    };
+};
+const generateEmailLayoutDir = async (emailLayoutDirCtx, attrs)=>{
+    const bundle = scaffoldEmailLayoutDirBundle(attrs);
+    return (0, _writer.writeEmailLayoutDirFromBundle)(emailLayoutDirCtx, bundle);
+};
+const generateEmailLayoutFromTemplate = async (emailLayoutDirCtx, templateString, attrs)=>{
+    let tempDir;
+    try {
+        // Download the template directory into a temp directory
+        tempDir = await _templates.downloadTemplate(templateString);
+        // Create an email layout directory context for the temp directory
+        const tempEmailLayoutDirCtx = {
+            type: "email_layout",
+            key: "temp",
+            abspath: tempDir,
+            exists: true
+        };
+        // Read the layout.json from the temp directory we downloaded
+        const [emailLayout, errors] = await (0, _reader.readEmailLayoutDir)(tempEmailLayoutDirCtx, {
+            withExtractedFiles: true
+        });
+        if (errors.length > 0 || !emailLayout) {
+            throw new Error(`Invalid email layout template: ${errors.join(", ")}`);
+        }
+        // Modify the email layout data with the new attributes
+        const emailLayoutData = (0, _lodash.cloneDeep)(emailLayout);
+        emailLayoutData.name = attrs.name;
+        // Finally, we write the email layout into the target email layout directory
+        await (0, _writer.writeEmailLayoutDirFromData)(emailLayoutDirCtx, emailLayoutData);
+    } finally{
+        await _templates.cleanupTempDir(tempDir);
+    }
+};

package/dist/lib/marshal/email-layout/helpers.js

@@ -25,6 +25,7 @@ _export(exports, {
 const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
 const _core = require("@oclif/core");
 const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _projectconfig = require("../../helpers/project-config");
 const _processorisomorphic = require("./processor.isomorphic");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
@@ -74,7 +75,7 @@ const lsEmailLayoutJson = async (dirPath)=>{
     const exists = await _fsextra.pathExists(emailLayoutJsonPath);
     return exists ? emailLayoutJsonPath : undefined;
 };
-const ensureValidCommandTarget = async (props, runContext)=>{
+const ensureValidCommandTarget = async (props, runContext, projectConfig)=>{
     const { args, flags } = props;
     const { commandId, resourceDir: resourceDirCtx, cwd: runCwd } = runContext;
     // If the target resource is a different type than the current resource dir
@@ -86,19 +87,15 @@ const ensureValidCommandTarget = async (props, runContext)=>{
     if (flags.all && args.emailLayoutKey) {
         return _core.ux.error(`emailLayoutKey arg \`${args.emailLayoutKey}\` cannot also be provided when using --all`);
     }
+    // Default to knock project config first if present, otherwise cwd.
+    const layoutsIndexDirCtx = await (0, _projectconfig.resolveResourceDir)(projectConfig, "email_layout", runCwd);
     // --all flag is given, which means no layout key arg.
     if (flags.all) {
         // If --all flag used inside a layout directory, then require a layouts dir path.
         if (resourceDirCtx && !flags["layouts-dir"]) {
             return _core.ux.error("Missing required flag layouts-dir");
         }
-        // Targeting all layout dirs in the layouts index dir.
-        // TODO: Default to the knock project config first if present before cwd.
-        const defaultToCwd = {
-            abspath: runCwd,
-            exists: true
-        };
-        const indexDirCtx = flags["layouts-dir"] || defaultToCwd;
+        const indexDirCtx = flags["layouts-dir"] || layoutsIndexDirCtx;
         return {
             type: "emailLayoutsIndexDir",
             context: indexDirCtx
@@ -109,7 +106,7 @@ const ensureValidCommandTarget = async (props, runContext)=>{
         if (resourceDirCtx && resourceDirCtx.key !== args.emailLayoutKey) {
             return _core.ux.error(`Cannot run ${commandId} \`${args.emailLayoutKey}\` inside another layout directory:\n${resourceDirCtx.key}`);
         }
-        const targetDirPath = resourceDirCtx ? resourceDirCtx.abspath : _nodepath.resolve(runCwd, args.emailLayoutKey);
+        const targetDirPath = resourceDirCtx ? resourceDirCtx.abspath : _nodepath.resolve(layoutsIndexDirCtx.abspath, args.emailLayoutKey);
         const layoutDirCtx = {
             type: "email_layout",
             key: args.emailLayoutKey,

package/dist/lib/marshal/email-layout/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+_export_star(require("./generator"), exports);
 _export_star(require("./helpers"), exports);
 _export_star(require("./processor.isomorphic"), exports);
 _export_star(require("./reader"), exports);

package/dist/lib/marshal/email-layout/writer.js

@@ -12,6 +12,9 @@ _export(exports, {
     get pruneLayoutsIndexDir () {
         return pruneLayoutsIndexDir;
     },
+    get writeEmailLayoutDirFromBundle () {
+        return writeEmailLayoutDirFromBundle;
+    },
     get writeEmailLayoutDirFromData () {
         return writeEmailLayoutDirFromData;
     },
@@ -82,18 +85,27 @@ const writeEmailLayoutDirFromData = async (emailLayoutDirCtx, remoteEmailLayout,
         withExtractedFiles: true
     }) : [];
     const bundle = (0, _processorisomorphic.buildEmailLayoutDirBundle)(remoteEmailLayout, localEmailLayout, withSchema ? EMAIL_LAYOUT_SCHEMA : undefined);
+    return writeEmailLayoutDirFromBundle(emailLayoutDirCtx, bundle);
+};
+/*
+ * A lower level write function that takes a constructed email layout dir bundle
+ * and writes it into a layout directory on a local file system.
+ *
+ * It does not make any assumptions about how the email layout directory bundle was
+ * built; for example, it can be from parsing the layout data fetched from
+ * the Knock API, or built manually for scaffolding purposes.
+ */ const writeEmailLayoutDirFromBundle = async (emailLayoutDirCtx, emailLayoutDirBundle)=>{
     const backupDirPath = _nodepath.default.resolve(_const.sandboxDir, (0, _lodash.uniqueId)("backup"));
     try {
-        // We store a backup in case there's an error.
         if (emailLayoutDirCtx.exists) {
             await _fsextra.copy(emailLayoutDirCtx.abspath, backupDirPath);
             await _fsextra.emptyDir(emailLayoutDirCtx.abspath);
         }
-        const promises = Object.entries(bundle).map(([relpath, fileContent])=>{
+        const promises = Object.entries(emailLayoutDirBundle).map(([relpath, fileContent])=>{
             const filePath = _nodepath.default.resolve(emailLayoutDirCtx.abspath, relpath);
             return relpath === _processorisomorphic.LAYOUT_JSON ? _fsextra.outputJson(filePath, fileContent, {
                 spaces: _json.DOUBLE_SPACES
-            }) : _fsextra.outputFile(filePath, fileContent);
+            }) : _fsextra.outputFile(filePath, fileContent !== null && fileContent !== void 0 ? fileContent : "");
         });
         await Promise.all(promises);
     } catch (error) {

package/dist/lib/marshal/guide/generator.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get generateGuideDir () {
+        return generateGuideDir;
+    },
+    get generateGuideFromTemplate () {
+        return generateGuideFromTemplate;
+    },
+    get scaffoldGuideDirBundle () {
+        return scaffoldGuideDirBundle;
+    },
+    get scaffoldValuesFromSchema () {
+        return scaffoldValuesFromSchema;
+    },
+    get validateGuideKey () {
+        return validateGuideKey;
+    }
+});
+const _string = require("../../helpers/string");
+const _templates = /*#__PURE__*/ _interop_require_wildcard(require("../../templates"));
+const _processorisomorphic = require("./processor.isomorphic");
+const _reader = require("./reader");
+const _writer = require("./writer");
+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;
+}
+const validateGuideKey = (input)=>{
+    if (!(0, _string.checkSlugifiedFormat)(input, {
+        onlyLowerCase: true
+    })) {
+        return "must include only lowercase alphanumeric, dash, or underscore characters";
+    }
+    return undefined;
+};
+const scaffoldValuesFromSchema = (fields)=>{
+    const values = {};
+    for (const field of fields){
+        switch(field.type){
+            case "text":
+            case "textarea":
+            case "markdown":
+                values[field.key] = "";
+                break;
+            case "boolean":
+                values[field.key] = false;
+                break;
+            case "select":
+            case "multi_select":
+                values[field.key] = null;
+                break;
+            case "button":
+                values[field.key] = {
+                    text: "",
+                    action: ""
+                };
+                break;
+        }
+    }
+    return values;
+};
+const scaffoldGuideDirBundle = (attrs)=>{
+    const { name, messageType, variantKey = "default" } = attrs;
+    // Find the selected variant or default to the first one
+    const variant = messageType.variants.find((v)=>v.key === variantKey) || messageType.variants[0];
+    if (!variant) {
+        throw new Error(`Message type ${messageType.key} has no variants available`);
+    }
+    // Scaffold values from the variant's field schema
+    const values = scaffoldValuesFromSchema(variant.fields);
+    const guideJson = {
+        name,
+        steps: [
+            {
+                ref: "step_1",
+                schema_key: messageType.key,
+                schema_variant_key: variant.key,
+                values
+            }
+        ]
+    };
+    return {
+        [_processorisomorphic.GUIDE_JSON]: guideJson
+    };
+};
+const generateGuideDir = async (guideDirCtx, attrs)=>{
+    const bundle = scaffoldGuideDirBundle(attrs);
+    return (0, _writer.writeGuideDirFromBundle)(guideDirCtx, bundle);
+};
+const generateGuideFromTemplate = async (guideDirCtx, templateString, attrs)=>{
+    let tempDir;
+    try {
+        // Download the template directory into a temp directory
+        tempDir = await _templates.downloadTemplate(templateString);
+        // Create a guide directory context for the temp directory
+        const tempGuideDirCtx = {
+            type: "guide",
+            key: "temp",
+            abspath: tempDir,
+            exists: true
+        };
+        // Read the guide.json from the temp directory we downloaded
+        const [guide, errors] = await (0, _reader.readGuideDir)(tempGuideDirCtx, {
+            withExtractedFiles: true
+        });
+        if (errors.length > 0 || !guide) {
+            throw new Error(`Invalid guide template: ${errors.join(", ")}`);
+        }
+        // Modify the guide data with the new attributes
+        guide.name = attrs.name;
+        // Finally, we write the guide into the target guide directory
+        (0, _writer.writeGuideDirFromData)(guideDirCtx, guide);
+        return;
+    } finally{
+        await _templates.cleanupTempDir(tempDir);
+    }
+};

package/dist/lib/marshal/guide/helpers.js

@@ -42,6 +42,7 @@ const _core = require("@oclif/core");
 const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
 const _lodash = require("lodash");
 const _quicktypecore = require("quicktype-core");
+const _projectconfig = require("../../helpers/project-config");
 const _processorisomorphic = require("./processor.isomorphic");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
@@ -107,7 +108,7 @@ const lsGuideJson = async (dirPath)=>{
     return exists ? guideJsonPath : undefined;
 };
 const isGuideDir = async (dirPath)=>Boolean(await lsGuideJson(dirPath));
-const ensureValidCommandTarget = async (props, runContext)=>{
+const ensureValidCommandTarget = async (props, runContext, projectConfig)=>{
     const { args, flags } = props;
     const { commandId, resourceDir: resourceDirCtx, cwd: runCwd } = runContext;
     // If the target resource is a different type than the current resource dir
@@ -119,6 +120,8 @@ const ensureValidCommandTarget = async (props, runContext)=>{
     if (flags.all && args.guideKey) {
         return _core.ux.error(`guideKey arg \`${args.guideKey}\` cannot also be provided when using --all`);
     }
+    // Default to knock project config first if present, otherwise cwd.
+    const guidesIndexDirCtx = await (0, _projectconfig.resolveResourceDir)(projectConfig, "guide", runCwd);
     // --all flag is given, which means no guide key arg.
     if (flags.all) {
         // If --all flag used inside a guide directory, then require a guides
@@ -126,16 +129,9 @@ const ensureValidCommandTarget = async (props, runContext)=>{
         if (resourceDirCtx && !flags["guides-dir"]) {
             return _core.ux.error("Missing required flag guides-dir");
         }
-        // Targeting all guide dirs in the guides index dir.
-        // TODO: Default to the knock project config first if present before cwd.
-        const defaultToCwd = {
-            abspath: runCwd,
-            exists: true
-        };
-        const indexDirCtx = flags["guides-dir"] || defaultToCwd;
         return {
             type: "guidesIndexDir",
-            context: indexDirCtx
+            context: flags["guides-dir"] || guidesIndexDirCtx
         };
     }
     // Guide key arg is given, which means no --all flag.
@@ -143,7 +139,7 @@ const ensureValidCommandTarget = async (props, runContext)=>{
         if (resourceDirCtx && resourceDirCtx.key !== args.guideKey) {
             return _core.ux.error(`Cannot run ${commandId} \`${args.guideKey}\` inside another guide directory:\n${resourceDirCtx.key}`);
         }
-        const targetDirPath = resourceDirCtx ? resourceDirCtx.abspath : _nodepath.resolve(runCwd, args.guideKey);
+        const targetDirPath = resourceDirCtx ? resourceDirCtx.abspath : _nodepath.resolve(guidesIndexDirCtx.abspath, args.guideKey);
         const guideDirCtx = {
             type: "guide",
             key: args.guideKey,

package/dist/lib/marshal/guide/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+_export_star(require("./generator"), exports);
 _export_star(require("./helpers"), exports);
 _export_star(require("./processor.isomorphic"), exports);
 _export_star(require("./reader"), exports);