@suitegeezus/suitecloud-stacker 25.2.127

package/safeCommands.js

@@ -0,0 +1,959 @@
+"use strict";
+/**
+ * @file sdf/safeCommands.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSafeExports = exports.caseCommands = exports.defaultCommands = exports.stack = exports.makeSuiteCloudConfig = exports.genericCommandProxy = exports.makeFunctionProxy = exports.accountManageAuthCommand = exports.accountSetupCommand = exports.fileUploadCommand = exports.objectImportCommand = exports.objectListCommand = exports.projectValidateCommand = exports.projectDeployCommand = exports.projectCreateCommand = exports.fileImportCommand = exports.promptHelpers = void 0;
+const makeManifest = require("./lib/makeManifestXml");
+const makeDeploy = require("./lib/makeDeployXml");
+const removeFiles = require("./lib/removeFiles");
+const process = require("node:process");
+const fs = require("node:fs");
+const nodePath = require("node:path");
+const promptHelper = require("./lib/promptHelpers");
+const pathHelpers = require("./lib/pathHelpers");
+const projectJsonHelpers = require("./lib/projectJsonHelpers");
+const accountManageAuth = require("./commands/accountManageauth");
+const accountSetup = require("./commands/accountSetup");
+const onErrorHelper = require("./lib/onErrorHelper");
+const spawnSuitecloudChild = require("./lib/spawnSuitecloudChild");
+const tempFileHelper = require("./lib/tempFileHelper");
+const fileList = require("./commands/fileList");
+const fileImports = require("./commands/fileImport");
+const projectCreates = require("./commands/projectCreate");
+const projectDeploys = require("./commands/projectDeploy");
+const fileUpload = require("./commands/fileUpload");
+const projectValidates = require("./commands/projectValidate");
+const objectLists = require("./commands/objectList");
+const objectImports = require("./commands/objectImport");
+const projectPackages = require("./commands/projectPackage");
+const onErrorHelper_1 = require("./lib/onErrorHelper");
+const watchss_1 = require("./commands/customhook/watchss");
+const compiless_1 = require("./commands/customhook/compiless");
+const promptHelpers_1 = require("./lib/promptHelpers");
+exports.promptHelpers = promptHelper;
+exports.fileImportCommand = fileImports;
+exports.projectCreateCommand = projectCreates;
+exports.projectDeployCommand = projectDeploys;
+exports.projectValidateCommand = projectValidates;
+exports.objectListCommand = objectLists;
+exports.objectImportCommand = objectImports;
+exports.fileUploadCommand = fileUpload;
+exports.accountSetupCommand = accountSetup;
+exports.accountManageAuthCommand = accountManageAuth;
+const SHARED = {
+    DEBUG: false,
+};
+/**
+ * @internal
+ * @description - clean up some files
+ * @param fileNames
+ * @param root
+ */
+const cleanup = (fileNames, root) => {
+    removeFiles({
+        fileNames,
+        doBackup: false,
+        root
+    });
+};
+/**
+ * @description - if blocked then an error is thrown (useful for temporarily neutering a capability)
+ * - the original candidate can satisfy the handler then it will
+ * - otherwise the replacement will
+ * @param {function} candidate - the root object
+ * @param {boolean} doBlock - whether to block access to the true candidate or not -- useful in debugging
+ * @param {boolean} debug - Whether to print useful values such as the property, value, arguments
+ */
+const makeFunctionProxy = (candidate, doBlock, debug) => {
+    if (candidate === null || (!['function', 'object'].includes(typeof candidate))) {
+        if (debug)
+            console.log(exports.promptHelpers.goColor('SUBTLE', 'skipping proxy for', typeof candidate, JSON.stringify({
+                doBlock,
+                debug
+            }, null, 2), false));
+        if (doBlock)
+            throw Error('blocked');
+        return candidate;
+    }
+    // console.log(promptHelpers.goColor('SUBTLE', 'making proxy', false));
+    if (debug)
+        console.log(exports.promptHelpers.goColor('SUBTLE', 'for', typeof candidate, JSON.stringify({
+            doBlock,
+            debug
+        }, null, 2), false));
+    return new Proxy(candidate, {
+        get(target, key, receiver) {
+            if (debug)
+                console.log(exports.promptHelpers.goColor('SUBTLE', 'accessing proxied object', JSON.stringify({
+                    key,
+                    doBlock,
+                    debug
+                }, null, 2), false));
+            if (doBlock === true)
+                throw Error('blocked');
+            if (Array.isArray(doBlock) && doBlock.includes(key))
+                throw Error('blocked');
+            const toReturn = Reflect.get(target, key, receiver);
+            return (0, exports.makeFunctionProxy)(toReturn, doBlock, debug);
+        },
+        set(target, key, value, receiver) {
+            if (debug)
+                console.log(exports.promptHelpers.goColor('SUBTLE', 'accessing proxied object', JSON.stringify({
+                    key,
+                    value,
+                    doBlock,
+                    debug
+                }, null, 2), false));
+            if (doBlock === true)
+                throw Error('blocked');
+            if (Array.isArray(doBlock) && doBlock.includes(key))
+                throw Error('blocked');
+            return Reflect.set(target, key, value, receiver);
+        },
+        apply(target, thisArg, argArray) {
+            if (debug)
+                console.log(exports.promptHelpers.goColor('SUBTLE', 'running function', JSON.stringify({ argArray }, null, 2), false));
+            if (doBlock === true)
+                throw Error('blocked');
+            if (typeof target === 'function')
+                return Reflect.apply(target, thisArg, argArray);
+            throw new Error('not a function');
+        },
+        has(target, key) {
+            if (debug)
+                console.log(exports.promptHelpers.goColor('SUBTLE', 'accessing proxied function', JSON.stringify({ key }), false));
+            if (doBlock === true)
+                throw Error('blocked');
+            return Reflect.has(target, key);
+        },
+        isExtensible( /* target */) {
+            return false;
+        }
+    });
+};
+exports.makeFunctionProxy = makeFunctionProxy;
+/**
+ * @description - converts an "existing" command object into a proxy for both the existing and missing pieces so you can track the inputs and outputs
+ * @param {object} existing
+ * @param {boolean} doBlock
+ * @param {boolean} debug
+ */
+const genericCommandProxy = (existing, doBlock, debug) => {
+    try {
+        const noop = (options) => options;
+        return new Proxy(existing, {
+            get(target, key, receiver) {
+                try {
+                    if (Reflect.has(target, key)) {
+                        return (0, exports.makeFunctionProxy)(Reflect.get(target, key, receiver), doBlock, debug);
+                    }
+                    if (typeof key === 'string' && /:/.test(key)) {
+                        return (0, exports.makeFunctionProxy)({
+                            projectFolder: null,
+                            beforeExecuting: noop,
+                            onCompleted: noop,
+                            onError: noop,
+                        }, doBlock, debug);
+                    }
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            }
+        });
+    }
+    catch (err) {
+        console.error(err);
+        throw err;
+    }
+};
+exports.genericCommandProxy = genericCommandProxy;
+/**
+ * @deprecated
+ * @description - Take commands and export safe commands.
+ * - Proxies the function of each command
+ * - Anytime the `authid` option is seen it will strip it out as this is coming from native.
+ * - Will replace the `authid` option with a value that is taken from a transient .project.json file. Note that the
+ * transient file will only exist if it was called properly.
+ * @param options
+ */
+const makeSuiteCloudConfig = (options, authFolderMap, extras) => {
+    cleanup(['manifest.xml', 'deploy.xml'], process.cwd());
+    let authid = null;
+    let projectFolder = null;
+    let debugInJson = null;
+    let { debug } = { debug: false, ...extras };
+    try {
+        // make manifest
+        // temp
+        const projectJson = fs.readFileSync(nodePath.join(process.cwd(), '.project.json'), { encoding: 'utf8' });
+        ({ defaultAuthId: authid, defaultProjectFolder: projectFolder, debug: debugInJson } = {
+            defaultAuthId: null,
+            defaultProjectFolder: null,
+            debug: null,
+            ...JSON.parse(projectJson || "null")
+        });
+        if (projectFolder === null && authid !== null)
+            projectFolder = authid;
+        // debug in .project.json means it was requested on the command line so it is an override
+        if (debugInJson === true)
+            debug = true;
+        if (debugInJson === false)
+            debug = false;
+        if (authFolderMap && typeof authFolderMap === 'object') {
+            for (const [authMapKey, folders] of Object.entries(authFolderMap)) {
+                if (authMapKey !== authid)
+                    continue;
+                if (!folders.includes(projectFolder))
+                    throw new Error(`${authMapKey} is not allowed to work with folder ${projectFolder}. Check your suitecloud.config.js`);
+            }
+        }
+        const deferredJobs = [];
+        // delete the project.json files
+        if (projectFolder !== null) {
+            deferredJobs.push(() => cleanup(['manifest.xml', 'deploy.xml'], nodePath.join(process.cwd(), projectFolder)), () => makeManifest(nodePath.join(process.cwd(), projectFolder, 'manifest.xml'), projectFolder), () => makeDeploy(nodePath.join(process.cwd(), projectFolder, 'deploy.xml')));
+        }
+        else {
+            deferredJobs.push(() => makeManifest(nodePath.join(process.cwd(), 'manifest.xml'), 'unknown'), () => makeDeploy(nodePath.join(process.cwd(), 'deploy.xml')));
+            console.log('No project folder found ***************');
+        }
+        // for now execute them here as everything is synchronous so far
+        deferredJobs.forEach((job) => job());
+        if (debug)
+            console.log({ cwd: process.cwd() });
+        return new Proxy(options, {
+            get(outer, key, receiver) {
+                if (debug)
+                    console.log('accessing outer', { key });
+                // in case this file is imported by another in order to read the commands
+                if (['then', 'catch', 'finally'].includes(key))
+                    return Reflect.get(outer, key, receiver);
+                if (key === 'default')
+                    return { ...options, authFolderMap, };
+                if (['projectFolder', 'defaultProjectFolder'].includes(key)) {
+                    // temporary
+                    return projectFolder;
+                }
+                if (key === 'commands')
+                    return new Proxy(options?.commands || {}, {
+                        get(target, command, receiver) {
+                            if (debug)
+                                console.log('accessing inner', { command });
+                            let commandSpecificObject = Reflect.has(target, command)
+                                ? Reflect.get(target, command, receiver)
+                                : {};
+                            return new Proxy(commandSpecificObject, {
+                                get(target, property, receiver) {
+                                    if (debug)
+                                        console.log('accessing command', { property });
+                                    if (['projectFolder', 'defaultProjectFolder'].includes(command)) {
+                                        // temporary
+                                        return projectFolder + '2';
+                                    }
+                                    const value = Reflect.get(target, property, receiver);
+                                    if (typeof value === 'function')
+                                        return (0, exports.makeFunctionProxy)(value, false, debug);
+                                    // assume any other property is a function until we know more
+                                    return (0, exports.makeFunctionProxy)((options) => options, false, debug);
+                                }
+                            });
+                        }
+                    });
+                const value = Reflect.get(outer, key, receiver);
+                if (debug)
+                    console.log({ key, value });
+                return value;
+            }
+        });
+    }
+    catch (error) {
+        if (debug)
+            console.error(error);
+        cleanup(['manifest.xml', 'deploy.xml', 'project.json', '.project.json'], nodePath.join(process.cwd()));
+        if (projectFolder !== null)
+            cleanup(['manifest.xml', 'deploy.xml', 'project.json', '.project.json'], nodePath.join(process.cwd(), projectFolder));
+        throw error;
+    }
+    cleanup(['manifest.xml', 'deploy.xml', 'project.json', '.project.json'], nodePath.join(process.cwd()));
+    if (projectFolder !== null)
+        cleanup(['manifest.xml', 'deploy.xml', 'project.json', '.project.json'], nodePath.join(process.cwd(), projectFolder));
+};
+exports.makeSuiteCloudConfig = makeSuiteCloudConfig;
+/** @internal
+ * @example
+ * stacks['file:import'].beforeExecuting = []
+ * */
+const stacks = {};
+/**
+ * @description - curried
+ * @param {string} command - e.g. 'file:import'
+ * @param {string} [origin] - e.g. a property of the handling library that was used
+ * @param {string} [projectFolder]
+ */
+const done = (command, origin, projectFolder) => {
+    /** @ internal
+     * @description - async because any one of the internal stacks might contain async methods
+     */
+    return (options) => {
+        if (stacks[command].onError.length === 0)
+            stacks[command].onError.push(
+            // add a default error handler that will help error forensics
+            (error) => onErrorHelper.detectOriginAndReturn(command, error));
+        if (stacks[command].onCompleted.length === 0)
+            stacks[command].onCompleted.push(
+            // add a default error handler that will help error forensics
+            (options) => options);
+        const starter = { stacked: true };
+        if (projectFolder)
+            starter[projectFolder] = projectFolder;
+        //
+        return Object.entries(stacks[command]).reduce((accumulator, [methodName, methods], i) => {
+            // iterate over them calling each method
+            accumulator[methodName] = async (originalOptions) => {
+                if (SHARED.DEBUG)
+                    await exports.promptHelpers.promptUser({
+                        message: `pause from \`done\` prior to calling ${methodName}[${i}]`,
+                    });
+                // validation
+                if (['beforeExecuting'].includes(methodName) && !originalOptions?.command) {
+                    process.stdout.write(exports.promptHelpers.goColor('SUBTLE', '\n', 'options passed in ', originalOptions));
+                    throw new Error(`This must be called from a valid command`);
+                }
+                const { command } = originalOptions;
+                // validation
+                if (methods.length === 0)
+                    throw new Error(`The stack for ${origin}:${command}:${methodName} cannot be empty`);
+                // DRY validation
+                const optionsTest = (opts, index, method) => {
+                    if (typeof opts === null || !['object', 'string'].includes(typeof opts))
+                        throw new Error(`handler[${index}] for ${origin}:${command}:${methodName} must return the options to be stackable`);
+                    process.stdout.write(exports.promptHelpers.goColor('SUBTLE', '\n', 'pop off ', [method?.origin ?? origin, methodName].join(':')));
+                    // call with', JSON.stringify(opts, null, 2), '\n'));
+                };
+                // console.log({methods}, methods.map((m) => [Reflect.get(m, 'origin'), Reflect.get(m, 'command')]));
+                const newOptions = await methods.reduce(async (toPass, method, i) => {
+                    // // @ts-expect-error is optional
+                    // process.stdout.write(promptHelpers.goColor('SUBTLE', '\n', method?.origin, '[',i,']'));
+                    const awaitedOptions = await toPass;
+                    // validate
+                    optionsTest(awaitedOptions, i, method);
+                    // only some methods technically need to return the options but we return them always
+                    return method(awaitedOptions);
+                }, Promise.resolve(originalOptions))
+                    .catch((err) => {
+                    process.stdout.write(exports.promptHelpers.goColor('INFO', '\n', 'error from ', origin, ': '));
+                    // // @ts-expect-error yes it does
+                    process.stdout.write(exports.promptHelpers.goColor('WARN', err?.message, '\n'));
+                    // console.error(err);
+                    throw err;
+                });
+                // validate
+                optionsTest(newOptions, methods.length - 1);
+                // always force this cleaning of projectJson
+                if (['onCompleted', 'onError'].includes(methodName)) {
+                    //  projectJsonHelpers.updateProjectJson(process.cwd(), Boolean(options?.allowLoops), 0);
+                }
+                return newOptions;
+            };
+            return accumulator;
+        }, starter);
+    };
+};
+/**
+ * @description -
+ * - Be careful about what you return. Each function in the stack should return options BUT some of the properties in a function are effectively `readonly` --
+ * i.e. they are not frozen and do not behave readonly until the very last handler.
+ * e.g. if you modify the property `options.arguments.authid` in `beforeExecuting` then you will be able to
+ * but the final SDF internal handler will not read the updated value.
+ * - Further some functions do not need to export options, BUT this process will pass them on to the next.  This is an
+ * opportunity to modify those options, but it is a rare cases so be careful
+ * @param {string} command - e.g. 'file:import'
+ * @returns {Function}
+ */
+const stack = (command) => {
+    //    if (!Reflect.has(stacks, command))
+    //        process.stdout.write(promptHelpers.goColor('SUBTLE', 'overwriting stack for ', command, '|'));
+    //    else
+    //        process.stdout.write(promptHelpers.goColor('SUBTLE', 'creating stack for ', command, '|'));
+    //    // process.stdout.write(goColor('SUBTLE', '\n', 'creating stack for ', methodName));
+    //
+    let origin = '';
+    // always re-initiate for a command
+    Reflect.set(stacks, command, {
+        beforeExecuting: [],
+        onCompleted: [],
+        onError: [],
+    });
+    /**
+     * @description
+     *  @param {*} firstToStack
+     * @param {*[]} restToStack
+     * @returns {{stack: typeof stack; done: typeof done}}
+     */
+    const innerStack = (firstToStack, ...restToStack) => {
+        // for easier troubleshooting
+        const noop = () => {
+            throw new Error(`You forgot to call \`done\` for ${command} stack`);
+        };
+        noop.stack = innerStack;
+        noop.add = innerStack;
+        try {
+            if (Array.isArray(restToStack) && restToStack.length > 0) {
+                console.log(restToStack);
+                [firstToStack, ...restToStack].map((to) => innerStack(to));
+            }
+            else if (typeof firstToStack === 'function')
+                return innerStack(firstToStack());
+            //
+            else if (typeof firstToStack !== 'object')
+                throw new Error('You must provide a stackable object');
+            //
+            else {
+                origin = firstToStack._origin || origin;
+                if (!Reflect.has(firstToStack, 'onError')) {
+                    // a default error handler that stamps the command
+                    Reflect.set(firstToStack, 'onError', (error) => onErrorHelper.detectOriginAndReturn(command, error));
+                }
+                if (!Reflect.get(firstToStack, 'isStackable'))
+                    throw new Error(`The handler ${Reflect.get(firstToStack, 'name') || 'unnamed'} must have property \`isStackable\``);
+                Object.entries(firstToStack).forEach(
+                /**
+                 *
+                 * @param methodName e.g. 'beforeExecuting'
+                 * @param method
+                 * @param i
+                 */
+                ([methodName, method], i) => {
+                    if (typeof method !== 'function')
+                        return;
+                    // safety for unknown methods
+                    if (!Reflect.get(stacks[command], methodName))
+                        Reflect.set(stacks[command], methodName, []);
+                    // if (i === 0) process.stdout.write(goColor('SUBTLE', '\n', 'adding to stack for ', methodName));
+                    // else process.stdout.write(goColor('SUBTLE', '.'));
+                    if (Reflect.get(stacks, command)[methodName].includes(method)) {
+                        console.log({ methodName, command });
+                        throw new Error('thi sis already int he stack');
+                    }
+                    method.origin = origin;
+                    method.command = command;
+                    // process.stdout.write(promptHelpers.goColor('SUBTLE', '\nadding ', i, ':', command, ':', origin, '|', typeof method));
+                    Reflect.get(stacks, command)[methodName].push(method);
+                });
+            }
+            // finish
+            noop.done = done(command, origin);
+            return noop;
+        }
+        catch (e) {
+            console.error(e);
+            throw e;
+        }
+    };
+    const noop = () => {
+        throw new Error(`You forgot to "add" to the \`stack\` for the ${command} stack`);
+    };
+    noop.stack = innerStack;
+    noop.add = innerStack;
+    noop.done = () => {
+        throw new Error(`You must add a handler to the ${command} stack before calling done`);
+    };
+    return noop;
+};
+exports.stack = stack;
+const defaultStackable = () => ({
+    _origin: 'defaultStackable',
+    beforeExecuting: (options) => options,
+    onCompleted: (options) => options,
+    onError: (error) => onErrorHelper.detectOriginAndReturn('defaultStackable', error),
+    isStackable: true,
+});
+/** @internal */
+const printOptions = (opts) => {
+    const origin = 'printOptions';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            try {
+                process.stdout.write(exports.promptHelpers.goColor(opts.messageType, '\nargs:', process.argv));
+                process.stdout.write(exports.promptHelpers.goColor(opts.messageType, '\noptions:', JSON.stringify(options, null, 2)));
+                const SDFENV = Object.fromEntries(Object.entries(process.env).filter(([key]) => key.startsWith('SUITECLOUD')));
+                process.stdout.write(exports.promptHelpers.goColor(opts.messageType, '\nsdf:', JSON.stringify(SDFENV, null, 2)));
+                if (options.arguments.runhooks !== 'quiet' && opts.confirm === true && !spawnSuitecloudChild.isChildProcess()) {
+                    const choices = { 'Y': 'Yes' };
+                    await promptHelper.promptChoices({
+                        choices,
+                        displayChoices: choices,
+                        question: 'Continue? (Y)',
+                        default: choices['Y'],
+                    });
+                }
+            }
+            catch (e) {
+                console.error(e);
+                throw e;
+            }
+            return options;
+        },
+        onCompleted: async (options) => {
+            process.stdout.write(exports.promptHelpers.goColor(opts.messageType, '\n', JSON.stringify(options, null, 2)));
+            return options;
+        },
+        onError: async (error) => {
+            process.stdout.write(exports.promptHelpers.goColor(opts.messageType, '\n', error));
+            return error;
+        }
+    };
+};
+/** @internal */
+const fakeManifest = (features) => {
+    const origin = 'fakeManifest';
+    return {
+        _origin: origin,
+        isStackable: true,
+        /**
+         * @description - the only reliable way to get the manifest location is to know the project folder
+         * which does not come through options. You must get it from the project.JSON
+         * @param options
+         */
+        beforeExecuting: async (options) => {
+            const { defaultProjectFolder } = {
+                defaultProjectFolder: '',
+                ...await projectJsonHelpers.updateProjectJson({}, [options.projectPath])
+            };
+            if (!defaultProjectFolder)
+                throw (0, onErrorHelper_1.makeError)(origin, new Error('Failed to read project json at ' + options.projectPath));
+            const manifestPath = nodePath.join(options.projectPath, defaultProjectFolder, 'manifest.xml');
+            console.log({ manifestPath });
+            if (!fs.existsSync(manifestPath))
+                fs.writeFileSync(manifestPath, '');
+            return options;
+        }
+    };
+};
+/**
+ * @description - forces interactive mode
+ * @param options
+ */
+const onlyInteractive = () => {
+    const origin = 'onlyInteractive';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            if (options.interactive)
+                return options;
+            // only allow interactive mode
+            if (process.argv.includes('-i'))
+                return options;
+            throw onErrorHelper.makeError(origin, new Error(`${options?.command} is currently only allowing interactive mode (-i))`));
+        }
+    };
+};
+/**
+ * @internal
+ */
+const notSupported = () => {
+    const origin = 'notSupported';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            if (!/\bFileCabinet\b/.test(process.cwd()))
+                throw onErrorHelper.makeError(origin, new Error(`\n    ${options.command} not supported from ${process.cwd()} yet`));
+            return options;
+        },
+    };
+};
+/**
+ * @internal
+ * @description - Prompt for which folder to use -- only useful at the root level
+ */
+const verifyFolderFromRoot = () => {
+    const origin = 'verifyFolderFromRoot';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            // verify the current root from the project JSON
+            const { defaultProjectFolder } = await projectJsonHelpers.readProjectJson([]);
+            console.log(options);
+            if (process.cwd() === pathHelpers.getRootOfProject()) {
+                const potentials = await pathHelpers.findMatchingDirectories(process.cwd(), 
+                // length/depth of 3. first test must be to match account number (folder)
+                [/^(td)?\d+/, /^\w+$/, /^\w+$/, /^\w+$/]);
+                const filtered = potentials.filter((p) => /\bFileCabinet$/.test(p));
+                const displayChoices = filtered
+                    .map((f) => f.replace(/^.*nsaccounts\b.((td)?\d+.*)$/, '$1'))
+                    .map((x) => {
+                    const [...rest] = x.split(/[\\\/]/);
+                    const last = rest.pop();
+                    if (last === 'FileCabinet')
+                        return `${rest.join('/')}${(0, promptHelpers_1.goColor)('SUBTLE', '/', last)}`;
+                    return x;
+                });
+                const choices = filtered
+                    .map((f) => f.replace(/^.*nsaccounts\b.((td)?\d+.*?)(\W?\bFileCabinet.*)?$/, '$1'));
+                console.log({ choices });
+                const folderChoice = await promptHelper.promptChoices({
+                    choices,
+                    displayChoices,
+                    question: `Which folder to use? ${(0, promptHelpers_1.goColor)('SUBTLE', 'current: ', [options.projectPath, defaultProjectFolder].join('/'))}`,
+                    default: null
+                });
+                console.log({ folderChoice }, folderChoice !== defaultProjectFolder);
+                if (folderChoice !== defaultProjectFolder) {
+                    // force a restart
+                    await projectJsonHelpers.updateProjectJson({ defaultProjectFolder: folderChoice }, []);
+                    throw onErrorHelper.makeError(origin, new Error('Must restart due to folder change'));
+                }
+                return options;
+            }
+        }
+    };
+};
+// default
+/**
+ * @description - getters so that stack is not invoked until called and they are readonly
+ */
+exports.defaultCommands = {
+    get 'account:manageauth'() {
+        return (0, exports.stack)('account:manageauth')
+            .stack(defaultStackable)
+            // .stack(printOptions({messageType: 'SUBTLE'}))
+            .stack(accountManageAuth.saveList())
+            .stack(accountManageAuth.betterList())
+            .done();
+    },
+    get 'account:setup:ci'() {
+        return (0, exports.stack)('account:setup:ci')
+            .stack(defaultStackable)
+            .stack(printOptions({ messageType: 'SUBTLE' }))
+            .stack(fakeManifest({}))
+            .stack(accountSetup.chooseExistingCertificate())
+            .stack(accountSetup.promptForAccount())
+            .stack(accountSetup.promptForAuthId())
+            .stack(accountSetup.askToReplace())
+            .stack(printOptions({ messageType: 'INFO', confirm: true }))
+            // .stack(forceAccountInName()) // does not make sense for default
+            .done();
+    },
+    get 'account:setup'() {
+        return (0, exports.stack)('account:setup')
+            .stack(defaultStackable).done();
+    },
+    get 'object:import'() {
+        return (0, exports.stack)('object:import')
+            .stack(notSupported())
+            .stack(accountManageAuth.promptForAccountChoice())
+            .done();
+    },
+    get 'object:list'() {
+        return (0, exports.stack)('object:list')
+            .stack(notSupported())
+            .stack(accountManageAuth.promptForAccountChoice())
+            .done();
+    },
+    get 'file:create'() {
+        return (0, exports.stack)('file:create')
+            .stack(notSupported())
+            .stack(accountManageAuth.promptForAccountChoice())
+            .done();
+    },
+    get 'file:import'() {
+        return (0, exports.stack)('file:import')
+            .stack(notSupported())
+            /*.stack(
+                accountManageAuth.promptForAccountChoice()
+            )*/ .done();
+    },
+    get 'file:list'() {
+        return (0, exports.stack)('file:list')
+            .stack(notSupported())
+            .stack(accountManageAuth.promptForAccountChoice())
+            .done();
+    },
+    get 'file:upload'() {
+        return (0, exports.stack)('file:upload')
+            .stack(notSupported())
+            .stack(accountManageAuth.promptForAccountChoice()).done();
+    },
+    get 'object:update'() {
+        return (0, exports.stack)('object:update')
+            .stack(notSupported())
+            .stack(accountManageAuth.promptForAccountChoice()).done();
+    },
+    get 'project:adddependencies'() {
+        return (0, exports.stack)('project:adddependencies')
+            .stack(notSupported())
+            .done();
+    },
+    get 'project:create'() {
+        return (0, exports.stack)('project:create')
+            .stack(projectCreates.rootProjectChoices())
+            .done();
+    },
+    get 'project:deploy'() {
+        return (0, exports.stack)('project:deploy')
+            .stack(notSupported())
+            .stack(accountManageAuth.promptForAccountChoice())
+            .done();
+    },
+    get 'project:package'() {
+        return (0, exports.stack)('project:package')
+            .stack(notSupported())
+            .stack(accountManageAuth.promptForAccountChoice())
+            .done();
+    },
+    get 'project:validate'() {
+        return (0, exports.stack)('project:validate')
+            .stack(notSupported())
+            .stack(accountManageAuth.promptForAccountChoice())
+            .done();
+    },
+    get help() {
+        return (0, exports.stack)('help')
+            .stack(defaultStackable).done();
+    },
+};
+/**
+ * @description - getters
+ */
+exports.caseCommands = {
+    get 'custom:hook'() {
+        return (0, exports.stack)('custom:hook')
+            .stack((0, compiless_1.compileSuiteScript)([]))
+            .stack((0, watchss_1.watchSuiteScript)('sdf.config.js', ['module.d.ts']))
+            .done();
+    },
+    get 'account:manageauth'() {
+        return (0, exports.stack)('account:manageauth')
+            .stack(defaultStackable)
+            //.stack(printOptions({messageType: 'SUBTLE'})) // this is very noisy here on success
+            .stack(accountManageAuth.saveList())
+            .stack(accountManageAuth.betterList())
+            .done();
+    },
+    get 'account:setup:ci'() {
+        return (0, exports.stack)('account:setup:ci')
+            .stack(defaultStackable)
+            .stack(printOptions({ messageType: 'SUBTLE' }))
+            .stack(accountSetup.chooseExistingCertificate())
+            .stack(accountSetup.promptForAccount())
+            .stack(accountSetup.promptForAuthId())
+            .stack(accountSetup.forceAccountInName())
+            .stack(fileImports.detectManifest())
+            .stack(printOptions({ messageType: 'INFO' }))
+            .done();
+    },
+    get 'account:setup'() {
+        return (0, exports.stack)('account:setup')
+            .stack(defaultStackable)
+            .done();
+    },
+    get 'file:create'() {
+        return (0, exports.stack)('file:create')
+            .stack(notSupported())
+            .stack(accountManageAuth.promptForAccountChoice())
+            .done();
+    },
+    get 'file:import'() {
+        return (0, exports.stack)('file:import')
+            .stack(accountManageAuth.promptForAccountChoice())
+            // prompt if they didn't give us one
+            .stack(fileUpload.promptForPath({
+            message: 'Enter a file or Glob to import (e.g. ./**/*.js)'
+        }))
+            .stack(printOptions({ messageType: 'INFO', confirm: true }))
+            .stack(fileImports.downloadForDiff())
+            // could be an xml
+            .stack(fileUpload.getFilesFromDeployXml())
+            // or could be a glob or partial
+            .stack(fileImports.fixFileImportPaths())
+            .stack(fileUpload.confirmFileList())
+            .stack(fileImports.detectManifest())
+            // .stack(printOptions({messageType: 'SUBTLE'}))
+            .done();
+    },
+    get 'file:list'() {
+        return (0, exports.stack)('file:list')
+            .stack(printOptions({ messageType: 'INFO', confirm: true }))
+            .stack(accountManageAuth.promptForAccountChoice())
+            .stack(printOptions({ messageType: 'INFO', confirm: true }))
+            .stack(fileList.saveFileListToTemp())
+            .done();
+    },
+    get 'file:upload'() {
+        return (0, exports.stack)('file:upload')
+            .stack(printOptions({ messageType: 'INFO', confirm: true }))
+            .stack(accountManageAuth.promptForAccountChoice())
+            // prompt if they didn't give us one
+            .stack(fileUpload.promptForPath({
+            message: 'Enter a file or Glob to upload (e.g. ./**/*.js)'
+        }))
+            // could be an xml
+            .stack(fileUpload.getFilesFromDeployXml())
+            // or could be a glob or partial
+            .stack(fileUpload.fixFileUploadPaths())
+            .stack(fileUpload.confirmFileList())
+            //  .stack(fileUpload.compileFilesPrompt()) // use nodemon instead
+            .stack(fileUpload.testFilesPrompt())
+            .done();
+    },
+    get 'object:import'() {
+        return (0, exports.stack)('object:import')
+            // .stack(notSupported())
+            .stack(printOptions({ messageType: 'INFO', confirm: true }))
+            .stack(accountManageAuth.promptForAccountChoice())
+            .stack(objectImports.forceDestination())
+            .stack(printOptions({ messageType: 'INFO', confirm: true }))
+            .stack(objectImports.forceTypeAll())
+            .stack(fileUpload.promptForPath({
+            message: `Enter an object to upload. ${exports.promptHelpers.goColor('SUBTLE', '\n  Wildcard is * \n  \`type\` prefix is required but can be a wildcard (e.g. customrecord:custrecord_acs*)')}`
+        }))
+            .stack(fileUpload.getFilesFromDeployXml())
+            // .stack(printOptions({messageType: 'INFO', confirm: true}))
+            // or could be a glob or partial
+            .stack(objectImports.fixObjectImportPaths())
+            .stack(fileUpload.confirmFileList())
+            // .stack(objectImports.importGlobOrXml())
+            // organize into folders
+            .stack(objectImports.createObjectsDir())
+            .done();
+    },
+    get 'object:list'() {
+        return (0, exports.stack)('object:list')
+            .stack(printOptions({ messageType: 'INFO', confirm: true }))
+            .stack(accountManageAuth.promptForAccountChoice())
+            .stack(objectLists.saveObjectListToTemp())
+            .stack(objectLists.createFoldersForAllTypes())
+            .done();
+    },
+    get 'object:update'() {
+        return (0, exports.stack)('object:update')
+            .stack(notSupported())
+            .stack(accountManageAuth.promptForAccountChoice()).done();
+    },
+    get 'project:adddependencies'() {
+        return (0, exports.stack)('project:adddependencies')
+            .stack(notSupported())
+            .done();
+    },
+    get 'project:create'() {
+        return (0, exports.stack)('project:create')
+            .stack(notSupported())
+            .stack(accountManageAuth.promptForAccountChoice()).stack(projectCreates.projectJsonPromptAndEscape()).done();
+    },
+    get 'project:deploy'() {
+        return (0, exports.stack)('project:deploy')
+            .stack(projectDeploys.logErrors())
+            .stack(accountManageAuth.promptForAccountChoice()).stack(projectDeploys.forceLog())
+            .stack(projectDeploys.offerValidate())
+            .stack(projectDeploys.promptForDeployFile())
+            .stack(projectDeploys.askForDryrun())
+            .stack(projectDeploys.compileBeforeDeploy())
+            .stack(projectDeploys.runTestBeforeDeploy()
+        // projectDeploy.makeProjectDeployV1()
+        )
+            .done();
+    },
+    get 'project:package'() {
+        return (0, exports.stack)('project:package')
+            .stack(notSupported())
+            .stack(projectPackages.watchAndCompile())
+            .stack(printOptions({ messageType: "SUBTLE" }))
+            .stack(onlyInteractive())
+            .done();
+    },
+    get 'project:validate'() {
+        return (0, exports.stack)('project:validate')
+            .stack(notSupported())
+            .stack(projectValidates.forceLog())
+            .stack(projectValidates.promptServer())
+            // .stack(printOptions({messageType: 'SUBTLE'}))
+            .stack(projectValidates.runTests())
+            .stack(projectValidates.validateJest())
+            .stack(accountManageAuth.promptForAccountChoice()).done();
+    },
+    get help() {
+        return (0, exports.stack)('help')
+            .stack(defaultStackable).done();
+    }
+};
+/**
+ * @description - THIS MUST BE SYNCHRONOUS - you will get errors if the account is not setup.
+ * The  way around that is to prompt the user and then they can try again
+ * @param options
+ * @param {object} extra
+ * @param {string[]} [extra.clean] - Files to remove after running. Default is `deploy.xml` and `.project.json`. `sdftemp.*` files are always removed
+ * @param {function} [extra.onExit] - callback that run on Exit of the process. Whatever string[] are returned will be printed as lines to the console
+ * @param {module} module
+ */
+const makeSafeExports = (options, extra, module) => {
+    try {
+        // if launched by something like:
+        //  nodemon ./suitecloud.config.js watch -e ts --ignore module.d.ts
+        if (process.pid !== process.ppid && /^\d+$/.test(`${process.ppid}`) && process.argv.includes('watch')) {
+            // compile
+            return;
+        }
+        //Todo: if no local jest.config file exists then create one
+        // jobs when the process was spawned "normally from command line"
+        if (!spawnSuitecloudChild.isChildProcess()) {
+            // clean these up on start-up
+            tempFileHelper.removeTempFiles('sdftemp.');
+            // parent processes subscribe to clean-up
+            process.once('exit', async (e) => {
+                // console.log('close');
+                // do not delete 'tsconfig.json'
+                const toClean = Array.isArray(extra.clean) ? extra.clean : ['deploy.xml', '.project.json'];
+                process.stdout.write(exports.promptHelpers.goColor('SUBTLE', '\ncleaning up '));
+                cleanup(toClean, process.cwd());
+                if (!e)
+                    process.stdout.write('\n✅');
+                process.stdout.write('\n');
+                if (e > 0)
+                    tempFileHelper.removeTempFiles('sdftemp.');
+                if (typeof extra.onExit === 'function') {
+                    const result = await extra.onExit(process);
+                    if (Array.isArray(result))
+                        result
+                            .filter((r) => (typeof r === 'string'))
+                            .forEach((msg) => process.stdout.write(` ${msg}\n`));
+                }
+            });
+        }
+        Object.assign(options, projectJsonHelpers.readProjectJsonSync([]));
+        // projectJson defaults
+        if (extra.autoCreateProjectJson && !spawnSuitecloudChild.isChildProcess()) {
+            // note: do not need project json anymore
+            projectJsonHelpers.updateProjectJsonSync({
+                defaultAuthId: options.defaultAuthId || 'root',
+                defaultProjectFolder: options.defaultProjectFolder || 'demo'
+            }, [], 'project.json', false);
+        }
+        // look for loops
+        // SHARED.DEBUG = true; //  Boolean(extra?.debug);
+        //if (doConfig) {
+        Object.keys(exports.defaultCommands).forEach((command) => {
+            if (!Reflect.get(options.commands, command)) {
+                // use default
+                Reflect.set(options.commands, command, exports.defaultCommands[command]);
+            }
+            const fromOptions = options.commands[command];
+        });
+        // @ts-expect-error yes it does
+        options.commands = (0, exports.genericCommandProxy)(options.commands, Boolean(extra.block), Boolean(extra.debug));
+        module.exports = options;
+        return module.exports;
+    }
+    catch (e) {
+        console.error(e);
+        throw e;
+    }
+};
+exports.makeSafeExports = makeSafeExports;
+//# sourceMappingURL=safeCommands.js.map