@knocklabs/cli 0.1.0-rc.0

package/dist/commands/workflow/list.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>WorkflowList
+});
+const _core = require("@oclif/core");
+const _baseCommand = /*#__PURE__*/ _interopRequireDefault(require("../../lib/base-command"));
+const _date = require("../../lib/helpers/date");
+const _object = require("../../lib/helpers/object");
+const _page = require("../../lib/helpers/page");
+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 WorkflowList extends _baseCommand.default {
+    async run() {
+        const resp = await this.request();
+        const { flags  } = this.props;
+        if (flags.json) return resp.data;
+        this.render(resp.data);
+    }
+    async request(pageParams = {}) {
+        const props = (0, _object.merge)(this.props, {
+            flags: {
+                ...pageParams
+            }
+        });
+        return (0, _request.withSpinner)(()=>this.apiV1.listWorkflows(props));
+    }
+    async render(data) {
+        const { entries  } = data;
+        const { environment: env , "hide-uncommitted-changes": commitedOnly  } = this.props.flags;
+        const qualifier = env === "development" && !commitedOnly ? "(including uncommitted)" : "";
+        this.log(`‣ Showing ${entries.length} workflows in \`${env}\` environment ${qualifier}\n`);
+        /*
+     * Workflows list table
+     */ _core.CliUx.ux.table(entries, {
+            key: {
+                header: "Key"
+            },
+            name: {
+                header: "Name"
+            },
+            status: {
+                header: "Status",
+                get: (entry)=>entry.active ? "active" : "inactive"
+            },
+            categories: {
+                header: "Categories",
+                get: (entry)=>_workflow.formatCategories(entry, {
+                        truncateAfter: 3
+                    })
+            },
+            steps: {
+                header: "Steps",
+                get: (entry)=>entry.steps.length > 0 ? entry.steps.length : "-"
+            },
+            updated_at: {
+                header: "Updated at",
+                get: (entry)=>(0, _date.formatDate)(entry.updated_at)
+            }
+        });
+        return this.prompt(data);
+    }
+    async prompt(data) {
+        const { page_info  } = data;
+        const pageAction = await (0, _page.maybePromptPageAction)(page_info);
+        const pageParams = pageAction && (0, _page.paramsForPageAction)(pageAction, page_info);
+        if (pageParams) {
+            this.log("\n");
+            const resp = await this.request(pageParams);
+            return this.render(resp.data);
+        }
+    }
+}
+WorkflowList.flags = {
+    environment: _core.Flags.string({
+        default: "development"
+    }),
+    "hide-uncommitted-changes": _core.Flags.boolean(),
+    ..._page.pageFlags
+};
+WorkflowList.enableJsonFlag = true;

package/dist/commands/workflow/pull.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>WorkflowPull
+});
+const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
+const _core = require("@oclif/core");
+const _enquirer = /*#__PURE__*/ _interopRequireDefault(require("enquirer"));
+const _baseCommand = /*#__PURE__*/ _interopRequireDefault(require("../../lib/base-command"));
+const _dirContext = require("../../lib/helpers/dir-context");
+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;
+}
+const promptToConfirm = async ({ key  })=>{
+    try {
+        const { input  } = await _enquirer.default.prompt({
+            type: "confirm",
+            name: "input",
+            message: `Create a new workflow directory \`${_nodePath.join(key, "/")}\`?`
+        });
+        return input;
+    } catch (error) {
+        console.log(error);
+    }
+};
+class WorkflowPull extends _baseCommand.default {
+    async run() {
+        // 1. Retrieve or build a new workflow directory context.
+        const dirContext = await this.getWorkflowDirContext();
+        if (dirContext.exists) {
+            this.log(`‣ Found \`${dirContext.key}\` at ${dirContext.abspath}`);
+        } else {
+            const input = await promptToConfirm(dirContext);
+            if (!input) return;
+        }
+        // 2. Fetch the workflow with annotations.
+        const resp = await (0, _request.withSpinner)(()=>{
+            const props = (0, _object.merge)(this.props, {
+                args: {
+                    workflowKey: dirContext.key
+                },
+                flags: {
+                    annotate: true
+                }
+            });
+            return this.apiV1.getWorkflow(props);
+        });
+        // 3. Write the workflow with the workflow directory context.
+        await _workflow.writeWorkflowDir(resp.data, dirContext);
+        const action = dirContext.exists ? "updated" : "created";
+        this.log(`‣ Successfully ${action} \`${dirContext.key}\` at ${dirContext.abspath}`);
+    }
+    async getWorkflowDirContext() {
+        const { workflowKey  } = this.props.args;
+        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, _dirContext.ensureResourceDirForTarget)(resourceDir, target);
+        }
+        // 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(runCwd, 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");
+    }
+}
+WorkflowPull.flags = {
+    environment: _core.Flags.string({
+        default: "development"
+    }),
+    "hide-uncommitted-changes": _core.Flags.boolean()
+};
+WorkflowPull.args = [
+    {
+        name: "workflowKey",
+        required: false
+    }
+];

package/dist/commands/workflow/push.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>WorkflowPush
+});
+const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
+const _core = require("@oclif/core");
+const _baseCommand = /*#__PURE__*/ _interopRequireDefault(require("../../lib/base-command"));
+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 WorkflowPush 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. Push up the compiled workflow data.
+        const resp = await (0, _request.withSpinner)(()=>{
+            const props = (0, _object.merge)(this.props, {
+                args: {
+                    workflowKey: dirContext.key
+                },
+                flags: {
+                    annotate: true
+                }
+            });
+            return this.apiV1.upsertWorkflow(props, workflow);
+        });
+        // 4. Update the workflow directory with the successfully pushed workflow
+        // payload from the server.
+        await _workflow.writeWorkflowDir(resp.data.workflow, dirContext);
+        this.log(`‣ Successfully pushed \`${dirContext.key}\`, and updated ${dirContext.abspath}`);
+    }
+    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");
+    }
+}
+WorkflowPush.flags = {
+    // TODO: Maybe make environments into an enum.
+    environment: _core.Flags.string({
+        default: "development",
+        options: [
+            "development"
+        ]
+    })
+};
+WorkflowPush.args = [
+    {
+        name: "workflowKey",
+        required: false
+    }
+];

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "run", {
+    enumerable: true,
+    get: ()=>_core.run
+});
+const _core = require("@oclif/core");

package/dist/lib/api-v1.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>ApiV1
+});
+const _axios = /*#__PURE__*/ _interopRequireDefault(require("axios"));
+const _object = require("./helpers/object");
+const _page = require("./helpers/page");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const DEFAULT_ORIGIN = "https://control.knock.app";
+const API_VERSION = "v1";
+class ApiV1 {
+    // By resources:
+    async ping() {
+        return this.get("/ping");
+    }
+    async listWorkflows({ flags  }) {
+        const params = (0, _object.prune)({
+            environment: flags.environment,
+            annotate: flags.annotate,
+            hide_uncommitted_changes: flags["hide-uncommitted-changes"],
+            ...(0, _page.toPageParams)(flags)
+        });
+        return this.get("/workflows", {
+            params
+        });
+    }
+    async getWorkflow({ args , flags  }) {
+        const params = (0, _object.prune)({
+            environment: flags.environment,
+            annotate: flags.annotate,
+            hide_uncommitted_changes: flags["hide-uncommitted-changes"]
+        });
+        return this.get(`/workflows/${args.workflowKey}`, {
+            params
+        });
+    }
+    async upsertWorkflow({ args , flags  }, workflow) {
+        const params = (0, _object.prune)({
+            environment: flags.environment,
+            annotate: flags.annotate
+        });
+        const data = {
+            workflow
+        };
+        return this.put(`/workflows/${args.workflowKey}`, data, {
+            params
+        });
+    }
+    // By methods:
+    async get(subpath, config) {
+        return this.client.get(`/${API_VERSION}` + subpath, config);
+    }
+    async put(subpath, data, config) {
+        return this.client.put(`/${API_VERSION}` + subpath, data, config);
+    }
+    constructor(flags, config){
+        const baseURL = flags["api-origin"] || DEFAULT_ORIGIN;
+        this.client = _axios.default.create({
+            baseURL,
+            headers: {
+                Authorization: `Bearer ${flags["service-token"]}`,
+                "User-Agent": `${config.userAgent}`
+            },
+            // Don't reject the promise based on a response status code.
+            validateStatus: null
+        });
+    }
+}

package/dist/lib/base-command.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>_default
+});
+const _core = require("@oclif/core");
+const _apiV1 = /*#__PURE__*/ _interopRequireDefault(require("./api-v1"));
+const _runContext = /*#__PURE__*/ _interopRequireWildcard(require("./run-context"));
+const _userConfig = /*#__PURE__*/ _interopRequireDefault(require("./user-config"));
+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 BaseCommand extends _core.Command {
+    async init() {
+        await super.init();
+        // 1. Load user's config from the config dir, as available.
+        await _userConfig.default.load(this.config.configDir);
+        // 2. Parse flags and args, must come after the user config load.
+        this.props = await this.parse(this.constructor);
+        // 3. Instantiate a knock api client.
+        this.apiV1 = new _apiV1.default(this.props.flags, this.config);
+        // 4. Load the run context of the invoked command.
+        this.runContext = await _runContext.load();
+    }
+}
+// Global flags are inherited by any command that extends BaseCommand.
+BaseCommand.globalFlags = {
+    // Evaluated in the following precedence:
+    // - service token flag passed into the command
+    // - if not provided, fall back to env variable
+    // - if not available, fall back to user config
+    "service-token": _core.Flags.string({
+        summary: "service token to authenticate with",
+        required: true,
+        multiple: false,
+        env: "KNOCK_SERVICE_TOKEN",
+        default: async ()=>_userConfig.default.get().serviceToken
+    }),
+    // Hidden flag to use a different api base url for development purposes.
+    "api-origin": _core.Flags.string({
+        hidden: true,
+        required: false,
+        multiple: false,
+        default: async ()=>_userConfig.default.get().apiOrigin
+    })
+};
+const _default = BaseCommand;

package/dist/lib/helpers/date.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    formatDate: ()=>formatDate,
+    formatDateTime: ()=>formatDateTime
+});
+const _dateFns = require("date-fns");
+function formatDate(input) {
+    return (0, _dateFns.format)((0, _dateFns.parseISO)(input), "MMM d, yyyy");
+}
+function formatDateTime(input) {
+    return (0, _dateFns.format)((0, _dateFns.parseISO)(input), "MMM d, yyyy HH:mm:ss");
+}

package/dist/lib/helpers/dir-context.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ensureResourceDirForTarget", {
+    enumerable: true,
+    get: ()=>ensureResourceDirForTarget
+});
+const _core = require("@oclif/core");
+const ensureResourceDirForTarget = (resourceDirCtx, target)=>{
+    switch(target.commandId){
+        case "workflow:pull":
+            break;
+        default:
+            throw new Error(`Unhandled commandId: ${target.commandId}`);
+    }
+    // If the target resource is a different type than the current resource dir
+    // type, error out.
+    if (resourceDirCtx.type !== target.type) {
+        return _core.CliUx.ux.error(`Cannot run ${target.commandId} inside a ${resourceDirCtx.type} directory`);
+    }
+    // If the resource key was not procided with the command, then infer from the
+    // current resource directory context.
+    if (!target.key) {
+        return resourceDirCtx;
+    }
+    // If the resource key was provided and matches the current workflow dir
+    // context, then use the current resource directory context; otherwise, error.
+    if (target.key === resourceDirCtx.key) {
+        return resourceDirCtx;
+    }
+    return _core.CliUx.ux.error(`Cannot run ${target.commandId} \`${target.key}\` inside another ${resourceDirCtx.type} directory:\n${resourceDirCtx.key}`);
+};

package/dist/lib/helpers/env.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isTestEnv: ()=>isTestEnv,
+    sandboxDir: ()=>sandboxDir
+});
+const _nodeOs = /*#__PURE__*/ _interopRequireDefault(require("node:os"));
+const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
+const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
+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;
+}
+const isTestEnv = process.env.NODE_ENV === "test";
+const sandboxDir = _nodePath.resolve(_fsExtra.realpathSync(_nodeOs.default.tmpdir()), ".knock");