@suitegeezus/suitecloud-stacker 25.2.127

package/commands/fileImport.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @file sdf/commands/fileImport.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+import { FileImportCommand, SdfCommand } from "index";
+/**
+ * @description - will spawn a separate `file:import` job that has a different folder reference
+ * - to put the file in a temp folder
+ * - in a way this is calling itself because it is the same task. related handlers use child detection
+ * - if the `customoptions` is used then a second authid can be used for third compare source (e.g. `altauth:123_SBX2`)
+ */
+export declare const downloadForDiff: () => SdfCommand;
+/**
+ * @description - very similar tothe fixFileUploadPaths except we need to compare against netsuite
+ * Also we don't filter out any files
+ */
+export declare const fixFileImportPaths: () => SdfCommand;
+/**
+ * @description -
+ * @deprecated - there are better combos now -- no need to prompt for globs as every path is technically a glob
+ * @param {{excludeproperties: boolean}} forceOptions
+ * @returns {_origin: 'importRegex';}
+ */
+export declare const importFileOrPattern: (forceOptions: {
+    excludeproperties: boolean;
+}) => SdfCommand;
+/**
+ * @description - file:import requires a manifest file when not doing the diff option
+ */
+export declare const detectManifest: () => SdfCommand;
+export declare const beforeExecuting: FileImportCommand['beforeExecuting'];

package/commands/fileImport.js

@@ -0,0 +1,503 @@
+"use strict";
+/**
+ * @file sdf/commands/fileImport.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.beforeExecuting = exports.detectManifest = exports.importFileOrPattern = exports.fixFileImportPaths = exports.downloadForDiff = void 0;
+const console = require("node:console");
+const cp = require("node:child_process");
+const nodePath = require("node:path");
+const promptHelpers_1 = require("../lib/promptHelpers");
+const tempFileHelper = require("../lib/tempFileHelper");
+const pathHelpers_1 = require("../lib/pathHelpers");
+const onErrorHelper = require("../lib/onErrorHelper");
+const minimatch_1 = require("minimatch");
+const spawnSuitecloud = require("../lib/spawnSuitecloudChild");
+const tempFileHelper_1 = require("../lib/tempFileHelper");
+const makeManifest = require("../lib/makeManifestXml");
+const getListRoot = (proposedFolder) => {
+    switch (true) {
+        case /\bTemplates\b/.test(proposedFolder):
+            return '/Templates';
+        case /\bWeb Site Hosting Files\b/.test(proposedFolder):
+            return 'Web Site Hosting Files';
+        case /\bSuiteScripts\b/.test(proposedFolder):
+        default:
+            return '/SuiteScripts';
+    }
+};
+/**
+ * @description - will spawn a separate `file:import` job that has a different folder reference
+ * - to put the file in a temp folder
+ * - in a way this is calling itself because it is the same task. related handlers use child detection
+ * - if the `customoptions` is used then a second authid can be used for third compare source (e.g. `altauth:123_SBX2`)
+ */
+const downloadForDiff = () => {
+    const origin = 'downloadForDiff';
+    const tempFile = 'downloadForDiff.json';
+    const optionsObserved = {};
+    return {
+        _origin: origin, isStackable: true,
+        beforeExecuting: async (options) => {
+            try {
+                Object.assign(optionsObserved, options);
+                if (!options.arguments.calledfromcomparefiles)
+                    return options;
+                const isQuiet = options.arguments.runhooks === 'quiet';
+                const [secondAuth] = (options.arguments.customoptions || []).flatMap((cust) => {
+                    if (!/^altauth:/.test(cust))
+                        return [];
+                    return [cust.split(':').pop()];
+                });
+                // the child import should not loop an import
+                if (spawnSuitecloud.isChildProcess())
+                    return options;
+                // guard
+                if (!Array.isArray(options.arguments.paths))
+                    throw onErrorHelper.makeError(origin, new Error('Diff compare needs an array.'));
+                // single length array
+                if (options.arguments.paths.length === 0)
+                    throw onErrorHelper.makeError(origin, new Error('Diff compare supports exactly 1 file at a time currently.'));
+                // use the first file
+                const [file] = options.arguments.paths;
+                // normalize to file system
+                // e.g. /User/geraldgillespie/project/src/FileCabinet/SuiteScripts/blah.js
+                let fixed = (0, pathHelpers_1.getAbsolutePath)({
+                    projectPath: options.projectPath,
+                    executionPath: options.executionPath,
+                    filePath: file,
+                });
+                //  await promptUser({message: 'pause'});
+                // check if you have it locally
+                if (!await (0, pathHelpers_1.hasFile)(fixed) && !/\btemp\b.FileCabinet/.test(fixed)) {
+                    throw onErrorHelper.makeError(origin, new Error('You do not have this file locally ' + fixed));
+                }
+                // finish the fix for SDF
+                // e.g. /SuiteScripts/blah.js
+                fixed = fixed.replace(/^.*(.\bSuiteScripts.*)$/, '$1');
+                {
+                    // child process will save to temp
+                    // mktemp for the file
+                    // reset this array
+                    options.arguments.paths = [];
+                    // copy suitecloud there
+                    const tempLocation = await (0, pathHelpers_1.makeTempDirForSdf)(options.projectPath);
+                    const tempProjectFolder = (0, pathHelpers_1.getRelativeOf)(process.cwd(), tempLocation);
+                    const [newFile, secondFile] = await Promise.all([
+                        options.authId, secondAuth
+                    ]
+                        .filter(Boolean)
+                        .map(async (auth) => {
+                        const childArgs = [
+                            '--paths', fixed,
+                            '--calledfromcomparefiles',
+                            '--excludeproperties',
+                            '--project', tempProjectFolder,
+                            '--noconfig',
+                        ];
+                        if (auth)
+                            childArgs.push('--authid', auth);
+                        ['config'].forEach((keep) => {
+                            if (Reflect.has(options.arguments, keep))
+                                childArgs.push(`--${keep}`, Reflect.get(options.arguments, keep));
+                        });
+                        // trigger the import for it in the temp folder
+                        const errorCode = await spawnSuitecloud.createAsync({
+                            command: 'file:import',
+                            args: childArgs,
+                            interact: true,
+                            // spawns in a separate location but is still a child process
+                        });
+                        if (errorCode !== 0)
+                            process.exit(errorCode);
+                        const dataJson = await (0, tempFileHelper_1.consumeTempFile)(tempFile);
+                        const parsedData = JSON.parse(dataJson);
+                        return parsedData.fullPath;
+                    }));
+                    let diffTool = process.env.SUITECLOUD_DIFF_TOOL;
+                    // console.log(process.env);
+                    const nag = async () => {
+                        process.stdout.write((0, promptHelpers_1.goColor)('INFO', `\nSet your environment variable ${(0, promptHelpers_1.goColor)('HIGHLIGHT', 'SUITECLOUD_DIFF_TOOL')}${(0, promptHelpers_1.goColor)('INFO', ' to avoid this prompt in the future')}`));
+                        diffTool = await (0, promptHelpers_1.promptUser)({ message: 'What is your difftool?' });
+                        return diffTool;
+                    };
+                    while (!diffTool && !isQuiet) {
+                        await nag();
+                    }
+                    const currentFile = (0, pathHelpers_1.joinPaths)(options.projectPath, 'FileCabinet', fixed);
+                    // const thirdFile =
+                    // launch diff tool
+                    // Spawn a new process (e.g., launching another Node script)
+                    console.log([diffTool, ['diff', currentFile, newFile, secondFile]]);
+                    const fileArgs = [newFile, currentFile, secondFile].filter(Boolean).map((f) => `"${f}"`);
+                    const diffChildProc = cp.spawn(diffTool, ['diff', ...fileArgs], {
+                        detached: true, // Allows the child to run independently
+                        stdio: 'inherit',
+                        shell: true // Optional: ignore parent's stdio (or use 'inherit' to share)
+                    });
+                    console.log(diffChildProc.pid);
+                    // Unreference the child so that the parent process doesn't wait for it to exit
+                    const diffPromise = new Promise((ok, no) => {
+                        diffChildProc.on('spawn', () => {
+                            // spawn plus 2 seconds
+                            setTimeout(() => {
+                                ok(0);
+                            }, 2000);
+                        });
+                        // diffChildProc
+                    });
+                    // Exit the current process
+                    await diffPromise;
+                    diffChildProc.unref();
+                    // do not prompt when in quiet mode
+                    const choices = { 'Y': 'Yes', 'N': 'No' };
+                    let answer = choices['N'];
+                    options.arguments.paths = [];
+                    if (!isQuiet) {
+                        answer = await (0, promptHelpers_1.promptChoices)({
+                            choices,
+                            displayChoices: choices,
+                            // premessage:,
+                            question: 'Would you like to continue with the import?',
+                            default: choices['N'],
+                        });
+                        if (answer === choices['Y'])
+                            options.arguments.paths = [fixed];
+                    }
+                }
+            }
+            catch (e) {
+                console.error(e);
+                throw e;
+            }
+            return options;
+        },
+        onCompleted: async (options) => {
+            if (!spawnSuitecloud.isChildProcess()) {
+                if (options?._status !== 'SUCCESS')
+                    return options;
+                // clean up any temp files
+                await (0, pathHelpers_1.removeTempDirForSdf)(options.projectPath).catch(() => {
+                });
+                return options;
+            }
+            const [firstResult] = options?._data.results || [];
+            // make a temp file
+            if (firstResult && firstResult?.path)
+                await (0, tempFileHelper_1.makeTempFile)(tempFile, JSON.stringify({
+                    path: firstResult?.path,
+                    project: options?.commandParameters.project,
+                    fullPath: (0, pathHelpers_1.joinPaths)(options?.commandParameters.project, 'FileCabinet', firstResult?.path)
+                }));
+            return options;
+        },
+        onError: async (error) => {
+            if (!spawnSuitecloud.isChildProcess()) {
+                // clean up any temp files
+                await (0, pathHelpers_1.removeTempDirForSdf)(optionsObserved.projectPath).catch(() => {
+                });
+            }
+            return onErrorHelper.detectOriginAndReturn(origin, error, (error) => {
+                return error;
+            });
+        }
+    };
+};
+exports.downloadForDiff = downloadForDiff;
+/**
+ * @description - very similar tothe fixFileUploadPaths except we need to compare against netsuite
+ * Also we don't filter out any files
+ */
+const fixFileImportPaths = () => {
+    const origin = 'fixFileImportPaths';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            if (!Array.isArray(options?.arguments?.paths))
+                options.arguments.paths = [];
+            const isQuiet = options?.arguments?.runhooks === 'quiet';
+            // it is expected that parents will fix any paths before calling
+            if (spawnSuitecloud.isChildProcess() && options.arguments.calledfromcomparefiles)
+                return options;
+            const { projectPath } = options;
+            const executionPath = options.executionPath || process.cwd();
+            await (0, promptHelpers_1.promptUser)({
+                message: JSON.stringify({
+                    executionPath, ...options, ischild: spawnSuitecloud.isChildProcess()
+                })
+            });
+            // deal with relative paths, etc 1️⃣
+            const shortenedPathOrGlobs = options.arguments.paths.map((path) => {
+                if (/^\.+[\\\/]/.test(path) && !/\bSuiteScripts\b/.test(path))
+                    return nodePath.join(executionPath, 
+                    // could be . or a ..
+                    ...path.split(/[\\\/]/))
+                        .replace(/^.*(\bSuiteScripts\b.*)/, '/$1');
+                // anything longer
+                const fixed = [/^.*(\bSuiteScripts\b.*)$/].reduce((p, rgx) => {
+                    if (p)
+                        return p;
+                    if (!rgx.test(path))
+                        return p;
+                    // already good
+                    return path.replace(rgx, '/$1');
+                }, '');
+                if (fixed)
+                    return fixed;
+                // TODO: any other patterns?
+            }).filter(Boolean);
+            const childArgs = ['config'].reduce((sofar, keep) => {
+                // most vars will be taken care of by environment variables
+                if (Reflect.has(options.arguments, keep))
+                    sofar.push(`--${keep}`, Reflect.get(options.arguments, keep));
+                return sofar;
+            }, ['--folder', '/SuiteScripts']);
+            if (options.authId)
+                childArgs.push('--authid', options.authId);
+            if (!isQuiet)
+                await (0, promptHelpers_1.promptUser)({ message: 'pause' });
+            // globbing has to be done here before we clean 2️⃣
+            const exitCode = await spawnSuitecloud.createAsync({
+                command: 'file:list',
+                args: childArgs,
+                interact: false,
+            });
+            if (exitCode !== 0)
+                throw onErrorHelper.makeError(origin, new Error('List failed to generate'));
+            const jsonList = await tempFileHelper.consumeTempFile(tempFileHelper.FileNames.fileList);
+            const tests = shortenedPathOrGlobs.map((p) => (entry) => (0, minimatch_1.minimatch)(entry, p));
+            const listOfFiles = JSON.parse(jsonList)['_data'];
+            const filteredList = new Set();
+            await Promise.allSettled(listOfFiles.map(async (file) => {
+                const pass = await tests
+                    .reduce(async (answer, test) => {
+                    const currentAnswer = await answer;
+                    return currentAnswer ? answer : test(file);
+                }, Promise.resolve(false));
+                if (pass)
+                    filteredList.add(file);
+            }));
+            options.arguments.paths = [...filteredList];
+            // 3️⃣ -- no filtering out here
+            return options;
+        },
+        onError: async (error) => onErrorHelper.detectOriginAndReturn(origin, error, (e) => {
+            console.log(origin, e);
+            return e;
+        }),
+    };
+};
+exports.fixFileImportPaths = fixFileImportPaths;
+/**
+ * @description -
+ * @deprecated - there are better combos now -- no need to prompt for globs as every path is technically a glob
+ * @param {{excludeproperties: boolean}} forceOptions
+ * @returns {_origin: 'importRegex';}
+ */
+const importFileOrPattern = (forceOptions) => {
+    const origin = 'importFileOrPattern';
+    const toReturn = {
+        _origin: origin,
+        /**
+         * @param {FileImportBeforeExecutingOptions} options
+         * @returns {FileImportBeforeExecutingOptions}
+         */
+        beforeExecuting: async (options) => {
+            if (options.arguments.calledfromcomparefiles)
+                return options;
+            if (options?.arguments?.runhooks === 'quiet')
+                return options;
+            try {
+                // force this on
+                if (typeof forceOptions === 'object' &&
+                    Reflect.has(forceOptions, 'excludeproperties'))
+                    options.arguments.excludeproperties = forceOptions.excludeproperties;
+                // filter the list
+                if (!Array.isArray(options?.arguments?.paths))
+                    options.arguments.paths = [];
+                const promptForFiles = options.arguments.paths.length === 0;
+                if (promptForFiles) {
+                    let answer;
+                    let pass = false;
+                    const nagForPath = async () => {
+                        answer = await (0, promptHelpers_1.promptUser)({
+                            message: `Enter the path. \nIt can be a local relative path or a SuiteScripts path\n. e.g. /SuiteScripts/myfolder/**/*.js`
+                        });
+                    };
+                    while (!pass) {
+                        await nagForPath();
+                        if (!/^\/(SuiteScripts|Templates|Web Site Hosting Files)/.test(answer))
+                            pass = Boolean(await (0, pathHelpers_1.hasFile)(nodePath.resolve(answer)));
+                        else
+                            pass = true;
+                    }
+                    options.arguments.paths.push(answer);
+                }
+                // TODO: this should be a combo with options.projectPath and json
+                const suiteScriptsOfCurrent = process.cwd().replace(/^.*(.\bSuiteScripts\b.*)$/, '$1');
+                const nature = /^\/(SuiteScripts|Templates|Web Site Hosting Files)/.test(String(options?.arguments?.paths?.[0]))
+                    ? 'glob'
+                    : 'path';
+                // run a list
+                const uniqueAndFiltered = new Set();
+                await Promise.all(options.arguments.paths.map(async (pathOrPattern) => {
+                    if (nature === 'path') {
+                        // resolve path first
+                        const resolvedPath = nodePath.resolve(pathOrPattern).replace(/^.*(.\b(SuiteScripts|Templates|Web Site Hosting Files).*)$/, '$1');
+                        uniqueAndFiltered.add(resolvedPath);
+                        return;
+                    }
+                    uniqueAndFiltered.add(pathOrPattern);
+                }));
+                options.arguments.paths = [...uniqueAndFiltered];
+                // confirm2:
+                {
+                    let importAnswer = '';
+                    const importChoices = [
+                        'Import This list',
+                        'Save Filtered List To File (',
+                        'Save Original List To File',
+                        'Enter A Different Path / Glob',
+                        'Do Not Import'
+                    ];
+                    const nag = async () => {
+                        process.stdout.write((0, promptHelpers_1.goColor)('GOOD', '\nfilteredList:\n', JSON.stringify(options.arguments.paths, null, 2)));
+                        importAnswer = await (0, promptHelpers_1.promptChoices)({
+                            choices: importChoices,
+                            displayChoices: importChoices,
+                            question: 'Are you good to import this list?',
+                            default: importChoices[0],
+                        });
+                    };
+                    while (![importChoices[0], importChoices[4]].includes(importAnswer)) {
+                        await nag();
+                        if (importAnswer === importChoices[3]) {
+                            options.arguments.paths = [];
+                            return toReturn.beforeExecuting(options);
+                        }
+                        if (importAnswer === importChoices[1]) {
+                            // save to file
+                            // not supported yet
+                        }
+                        if (importAnswer === importChoices[2]) {
+                            // save to file
+                            // not supported yet
+                        }
+                    }
+                    if (importAnswer === importChoices[4])
+                        options.arguments.paths = [];
+                }
+                // safety net
+                if (options.arguments.paths.find((path) => !path.includes(suiteScriptsOfCurrent))) {
+                    const choices = { 'Y': 'Yes', 'N': 'No' };
+                    // prompt for file choice between this folder and entire project
+                    const answer = await (0, promptHelpers_1.promptChoices)({
+                        choices,
+                        displayChoices: choices,
+                        question: `Current: ${(0, promptHelpers_1.goColor)("INFO", suiteScriptsOfCurrent)}\nAre you sure you want to import files outside of this directory (Y/N)?`,
+                        default: choices['Y'],
+                    });
+                    if (answer === 'N')
+                        options.arguments.paths = [];
+                }
+                if (options.arguments.paths.length === 0 && !spawnSuitecloud.isChildProcess()) {
+                    // nothing to do
+                    process.exit(0);
+                }
+                return options;
+            }
+            catch (e) {
+                throw onErrorHelper.makeError(origin, e);
+            }
+        },
+        onCompleted: async (options) => {
+            return options;
+        },
+        onError: async (error) => {
+            return onErrorHelper.detectOriginAndReturn(origin, error, (error) => {
+                process.stdout.write((0, promptHelpers_1.goColor)('BAD', 'oops ❌'));
+                return error;
+            });
+        },
+        isStackable: true,
+    };
+    return toReturn;
+};
+exports.importFileOrPattern = importFileOrPattern;
+/**
+ * @description - file:import requires a manifest file when not doing the diff option
+ */
+const detectManifest = () => {
+    const origin = 'detectManifest';
+    let deleteManifest = false;
+    let manifestPath = '';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            // not needed when...
+            if (options.arguments?.paths?.length === 0)
+                return options;
+            if (options.arguments.calledfromcomparefiles)
+                return options;
+            const isQuiet = options?.arguments?.runhooks === 'quiet';
+            // check if manifest exists
+            const hasManifest = await (0, pathHelpers_1.hasFile)([options.projectPath, 'manifest.xml']);
+            const choices = { 'Y': 'Yes' };
+            let answer = choices['Y'];
+            if (!hasManifest) {
+                if (!isQuiet) {
+                    // prompt to create one
+                    answer = await (0, promptHelpers_1.promptChoices)({
+                        choices,
+                        displayChoices: choices,
+                        // premessage:,
+                        question: 'No Manifest detected. Should a temporary one be created?',
+                        default: choices['Y'],
+                    });
+                }
+                if (answer === choices['Y']) {
+                    deleteManifest = true;
+                    await makeManifest(options.projectPath, 'Temporary', 'manifest.xml');
+                    manifestPath = await (0, pathHelpers_1.hasFile)([options.projectPath, 'manifest.xml']) || '';
+                }
+            }
+            else {
+                manifestPath = hasManifest;
+            }
+            return options;
+        },
+        onCompleted: async (options) => {
+            // console.log({ deleteManifest, manifestPath},options?._commandParameters?.project);
+            if (deleteManifest && options?._commandParameters?.project) {
+                const unquotedProject = await Promise.resolve(options?._commandParameters?.project)
+                    .then((p) => JSON.parse(p))
+                    .catch(() => { });
+                if (unquotedProject) {
+                    process.stdout.write((0, promptHelpers_1.goColor)('INFO', '\n', 'Deleting temporary manifest in ', unquotedProject));
+                    await (0, pathHelpers_1.removeFile)([unquotedProject, 'manifest.xml']);
+                }
+                else {
+                    process.stdout.write((0, promptHelpers_1.goColor)('BAD', '\n', 'Could not find manifest.xml in ', options?._commandParameters?.project));
+                }
+            }
+            return options;
+        },
+        onError: async (error) => {
+            if (deleteManifest && manifestPath) {
+                await (0, pathHelpers_1.removeFile)([manifestPath]);
+            }
+            return error;
+        }
+    };
+};
+exports.detectManifest = detectManifest;
+const beforeExecuting = (options) => {
+    console.log(options);
+    throw new Error('wut');
+    return options;
+};
+exports.beforeExecuting = beforeExecuting;
+//# sourceMappingURL=fileImport.js.map

package/commands/fileList.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/commands/fileList
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+import { SdfCommand } from "#root/index";
+/**
+ * @description - Get a file list
+ * @deprecated
+ * @param options
+ * @param {Array<*>} tests - in this case, if any test passes then it is good
+ * @returns {Promise<string[]>} - the filtered list
+ */
+export declare const runFileListFromFolder: (options: {
+    folder: string;
+}, tests: Array<(entry: string) => boolean | Promise<boolean>>) => Promise<string[]>;
+/**
+ * @description
+ */
+export declare const saveFileListToTemp: () => SdfCommand;

package/commands/fileList.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/commands/fileList
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveFileListToTemp = exports.runFileListFromFolder = void 0;
+const promptHelpers_1 = require("../lib/promptHelpers");
+const tempFileHelper = require("../lib/tempFileHelper");
+/**
+ * @description - Get a file list
+ * @deprecated
+ * @param options
+ * @param {Array<*>} tests - in this case, if any test passes then it is good
+ * @returns {Promise<string[]>} - the filtered list
+ */
+const runFileListFromFolder = async (options, tests) => {
+    throw new Error('obsolete');
+};
+exports.runFileListFromFolder = runFileListFromFolder;
+/**
+ * @description
+ */
+const saveFileListToTemp = () => {
+    const origin = 'saveFileListToTemp';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            return options;
+        },
+        onCompleted: async (options) => {
+            process.stdout.write((0, promptHelpers_1.goColor)('SUBTLE', '\n', origin, ': ', tempFileHelper.FileNames.fileList));
+            await tempFileHelper.makeTempFile(tempFileHelper.FileNames.fileList, JSON.stringify(options, null, 2));
+            return options;
+        }
+    };
+};
+exports.saveFileListToTemp = saveFileListToTemp;
+//# sourceMappingURL=fileList.js.map

package/commands/fileUpload.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/commands/fileUpload
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+import { SdfCommand } from "#root/index";
+/**
+ * @description - only prompt if not paths given
+ * @param {string} opts.message
+ */
+export declare const promptForPath: (opts?: {
+    message?: string;
+}) => SdfCommand;
+/**
+ * @description - deploy.xml files are filtered out of an upload allowed in the upload, buuut...
+ * - If you provide one as the only file to upload then it will load the files listed in it
+ *
+ * - they are allowed in an import BUT that is rare so if an import see this path then it will not import
+ * it but treat it like an import instructions
+ *
+ */
+export declare const getFilesFromDeployXml: () => SdfCommand;
+/**
+ * @description -
+ */
+export declare const confirmFileList: () => SdfCommand;
+/**
+ * @description - fix paths in a way that file:upload needs them fixed.
+ * - 0️⃣ paths that begin with SuiteScripts or SuiteBundles or SuiteApps are left as-is.
+ * - 1️⃣ relative paths -- these SHOULD begin with `.` or `..` or they will be treated as relative to cwd.
+ * - 2️⃣ globbing -- all paths are essentially viewed as a glob. globs that are
+ * - 3️⃣ clean and prevent bad files. e.g. typescript should be swapped for js (This should occur AFTER resolving any globs).
+ * - 4️⃣ check if the file exists and remove it
+ * - 5️⃣ finally trim to valid SDK path such as /SuiteScripts
+ *
+ * #Globbing:
+ * - every path here is SuiteScripts so ...
+ *
+ * - ignore certain files
+ */
+export declare const fixFileUploadPaths: () => SdfCommand;
+/**
+ * @description - Guesses at what files might be TS and then generates
+ * @deprecated - not sure the benefit of this is worth the trouble
+ * @todo -
+ * @returns {SdfCommand}
+ */
+export declare const compileFilesPrompt: () => SdfCommand;
+/**
+ * @description - calls jest for the files involved
+ * ⚠️ - make sure paths are fixed first
+ */
+export declare const testFilesPrompt: () => SdfCommand;