@suitegeezus/suitecloud-stacker 25.2.127

package/lib/promptHelpers.js

@@ -0,0 +1,195 @@
+"use strict";
+/**
+ * @file sdf/lib/promptHelpers.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptChoices = exports.promptUserSync = exports.promptUser = exports.detectPrompt = exports.appendToPrevious = exports.goColor = void 0;
+const readline = require('node:readline');
+const SpawnSuitecloud = require("./spawnSuitecloudChild");
+const Colors = {
+    WARN: "\u001B[38;5;214m" /* COLORS.ORANGE */,
+    BAD: "\u001B[31m" /* COLORS.RED */,
+    INFO: "\u001B[36m" /* COLORS.CYAN */,
+    HIGHLIGHT: "\u001B[33m" /* COLORS.YELLOW */,
+    GOOD: "\u001B[32m" /* COLORS.GREEN */, // '\x1b[32m', // green
+    NONE: "\u001B[0m" /* COLORS.RESET_ALL */, // '\x1b[0m', // reset
+    BOLD: "\u001B[1m" /* COLORS.BOLD */, // '\x1b[1m',
+    SUBTLE: "\u001B[90m" /* COLORS.BRIGHT_BLACK */, // `\x1b[90m` // grey
+};
+/**
+ * @description
+ * @param {Array<string|keyof typeof Colors>} colors
+ * @param {string[]} messages
+ * @param {boolean} skipReset
+ * @returns {string}
+ */
+exports.goColor = ((colors, ...messages) => {
+    let skip = typeof messages[messages.length - 1] === 'boolean' ? messages.pop() : false;
+    const msgStrings = messages.map((m) => {
+        switch (true) {
+            case m === null:
+                return null;
+            case typeof m === 'object':
+                return JSON.stringify(m);
+            default:
+                return String(m);
+        }
+    });
+    // @ts-expect-error is good
+    return `${skip ? '' : Colors.NONE}${[colors].flat().map((c) => Colors?.[c]).join('')}${msgStrings.join('')}${skip ? '' : Colors.NONE}`;
+});
+const QuestionPrompt = (0, exports.goColor)('SUBTLE', 'ANSWER: ');
+/**
+ * @description
+ * @param {string} previousMessage
+ * @param {string} toAppend
+ * @returns {string}
+ */
+const appendToPrevious = (previousMessage, toAppend) => {
+    readline.moveCursor(process.stdout, 0, -1);
+    // Position the cursor at the end of the previous line by using its length
+    readline.cursorTo(process.stdout, previousMessage.length);
+    process.stdout.write(toAppend);
+};
+exports.appendToPrevious = appendToPrevious;
+/**
+ * @description -
+ * @param line
+ * @returns {boolean}
+ */
+const detectPrompt = (line) => {
+    // console.log(line === QuestionPrompt? 'ischild': '');
+    return line === (0, exports.goColor)('SUBTLE', 'ANSWER: ');
+};
+exports.detectPrompt = detectPrompt;
+/**
+ * @param {{message: string; timeout?: number;}} options
+ * @param {(string)=>any} [callback]
+ * @returns {Promise<string|null>}
+ */
+const promptUser = async ({ message, timeout }, callback) => {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: QuestionPrompt
+    });
+    console.log(`\n${(0, exports.goColor)('BOLD', message || 'Hit Enter to continue')}`);
+    // Display the prompt
+    rl.prompt();
+    return new Promise((resolve, reject) => {
+        rl.once('line', (line) => {
+            console.log((0, exports.goColor)('SUBTLE', 'You pressed:', line, false));
+            resolve(line);
+        });
+        if (typeof timeout === 'number') {
+            setTimeout(() => {
+                resolve(null);
+            }, timeout);
+        }
+        rl.once('close', (e) => {
+            console.log((0, exports.goColor)('SUBTLE', 'Exiting'));
+            if (e)
+                reject(e);
+        });
+    }).then((answer) => {
+        rl.close();
+        return (typeof callback === 'function' ? callback(answer) : answer);
+    }).catch((err) => {
+        if (typeof callback === 'function')
+            return callback(err);
+        else
+            throw (err);
+    });
+};
+exports.promptUser = promptUser;
+const promptUserSync = ({ message, timeout }, callback) => {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: (0, exports.goColor)('SUBTLE', '> ')
+    });
+    console.log(`\n${(0, exports.goColor)('BOLD', message || 'Hit Enter to continue')}`);
+    // Display the prompt
+    rl.prompt();
+    rl.once('line', (line) => {
+        console.log((0, exports.goColor)('SUBTLE', 'You pressed:', line, false));
+        rl.close();
+    });
+    if (typeof timeout === 'number') {
+        setTimeout(() => {
+            rl.close();
+        }, timeout);
+    }
+    rl.once('close', (e) => {
+        console.log((0, exports.goColor)('SUBTLE', 'Exiting'));
+        if (e)
+            throw e;
+    });
+};
+exports.promptUserSync = promptUserSync;
+/**
+ * @description - pass in a array of strings to be presented with a numbered choice list
+ * 0 is always "QUIT" (even if not presented) and the program will exit with code 0 (coincidence on the number)
+ * "-1" is always the default -- this helps with automation
+ *
+ * @param {{choices: string[]}} options
+ * @returns {Promise<string>}
+ */
+const promptChoices = async (options) => {
+    const { choices, question, displayChoices, childDefault } = options;
+    if (typeof childDefault !== 'undefined' && SpawnSuitecloud.isChildProcess())
+        return options.childDefault;
+    if (displayChoices.length !== choices.length)
+        throw new Error(`displayChoices must match choices`);
+    let answer;
+    if ((Array.isArray(choices) !== Array.isArray(displayChoices))
+        || choices?.length !== displayChoices?.length) {
+        throw new Error(`displayChoices must be of same structure and length as choices`);
+    }
+    // const choices: Array<typeof nature> = ['path','regex'];
+    if (Reflect.get(choices, 'Q'))
+        throw new Error('choices cannot contain index of "Q"');
+    let maxKeyLength = 0;
+    const reIndexChoices = Array.isArray(choices) ? [undefined, ...choices] : choices;
+    const printChoices = (Array.isArray(displayChoices)
+        ? ['QUIT', ...displayChoices].map((c, i) => [(i === 0 ? 'Q' : String(i)), c])
+        : Object.entries({ ...{ 'Q': 'FORCE QUIT' + (0, exports.goColor)('SUBTLE', ' skips cleanup -- not recommend') }, ...displayChoices }))
+        .sort(([a, y], [b, z]) => {
+        maxKeyLength = Math.max(maxKeyLength, a.length);
+        return (a === 'Q' ? -1 : 0);
+    })
+        .map(([i, c]) => `${(0, exports.goColor)('HIGHLIGHT', i.padEnd(maxKeyLength, ' '))}: ${(0, exports.goColor)('INFO', c)}`);
+    const nag = async (msg) => {
+        if (typeof msg === 'string')
+            process.stdout.write((0, exports.goColor)('SUBTLE', '\nYou entered:', msg));
+        if (options.premessage)
+            process.stdout.write((0, exports.goColor)('SUBTLE', '\n', options.premessage));
+        answer = await (0, exports.promptUser)({
+            message: `${question}  \n${printChoices.join('\n')}`,
+        });
+    };
+    while (
+    // @ts-expect-error that's ok
+    !reIndexChoices[answer] &&
+        !['Q', '-1', '0'].includes(String(answer))) {
+        // console.log({reIndexChoices, answer});
+        await nag(String(answer));
+    }
+    if (
+    // intentional quit
+    ['Q', '0'].includes(String(answer))
+        // implied quit
+        || (String(answer) === '-1' && ['Q', 'QUIT'].includes(String(options?.default || 0)))) {
+        process.stdout.write((0, exports.goColor)('WARN', '\nYou chose to Quit ✅\n'));
+        process.exit(1);
+    }
+    return (String(answer) === '-1' && options.default
+        ? options.default
+        : Array.isArray(choices)
+            ? reIndexChoices[Number.parseInt(String(answer), 10)]
+            : choices[answer]);
+    throw new Error('misconfigured question');
+};
+exports.promptChoices = promptChoices;
+//# sourceMappingURL=promptHelpers.js.map

package/lib/removeFiles.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @file sdf/lib/removeFiles.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+type FilesList = 'manifest.xml' | 'deploy.xml' | 'project.json' | 'tsconfig.json' | 'jest.config.js' | '.project.json';
+/**
+ * @description - Deletes files from the list
+ * - optional backup with .bak extension
+ * @param options
+ * @param {boolean|string} [options.doBackup] - A non-empty short string can be used as the extension. Default is .bak
+ * @param {string} options.root
+ * @param {string[]} options.fileNames
+ * @returns {string[]} - State of the deletes
+ */
+declare const removeFiles: (options: {
+    fileNames: (FilesList | string)[];
+    root: string;
+    doBackup?: boolean | string;
+}) => (string | null)[];
+export = removeFiles;

package/lib/removeFiles.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * @file sdf/lib/removeFiles.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+const fs = require("node:fs");
+const nodePath = require("node:path");
+const promptHelpers = require("./promptHelpers");
+const promptHelpers_1 = require("./promptHelpers");
+const filesList = ['manifest.xml', 'deploy.xml', 'project.json', '.project.json', 'tsconfig.json', 'jest.config.js'];
+/**
+ * @description - Deletes files from the list
+ * - optional backup with .bak extension
+ * @param options
+ * @param {boolean|string} [options.doBackup] - A non-empty short string can be used as the extension. Default is .bak
+ * @param {string} options.root
+ * @param {string[]} options.fileNames
+ * @returns {string[]} - State of the deletes
+ */
+const removeFiles = (options) => {
+    const { fileNames, root, doBackup } = options;
+    return fileNames.map((name) => {
+        const path = nodePath.join(root, name);
+        if (![...filesList].includes(name))
+            return null;
+        const extension = typeof doBackup === 'string' && /^\w{2,4}$/.test(doBackup)
+            ? `.${doBackup}`
+            : doBackup ? '.bak' : '';
+        try {
+            if (doBackup)
+                fs.cpSync(path, path + extension);
+            process.stdout.write(promptHelpers.goColor('INFO', '\nremoving ', (0, promptHelpers_1.goColor)('SUBTLE', ' ', path, ' ')));
+            fs.rmSync(path);
+            return path;
+        }
+        catch (error) {
+            const { message } = error;
+            if (/no such file/.test(message))
+                return path;
+            process.stdout.write(promptHelpers.goColor('INFO', '\nfailed to remove ', path, '\n', promptHelpers.goColor('BAD', message)));
+            return null;
+        }
+    });
+};
+module.exports = removeFiles;
+//# sourceMappingURL=removeFiles.js.map

package/lib/sdf.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @file sdf/lib/sdf.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+/**
+ * @description - Extract arguments and create a native command and execute it.
+ * - Note that native SDF supports having a colon and that is not recommended here.
+ * @param {string[]} commandLineArguments
+ * @returns {void}
+ */
+export declare const executeCommand: (commandLineArguments: string[]) => void;

package/lib/sdf.js

@@ -0,0 +1,158 @@
+"use strict";
+/**
+ * @file sdf/lib/sdf.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeCommand = void 0;
+const makeProjectJson = require("./makeProjectJson");
+const spawnNativeSdf = require("./callCli");
+const removeFiles = require("./removeFiles");
+const sdfAcsAuthMap = require("../commands/sdfAcs_authmap");
+const nodePath = require("node:path");
+const commandsThatNativelyNeedAuthId = ['account:setup', 'account:setup:ci'];
+const commandsThatWithGrace = ['account:manageauth', '-h', '--help', '--version'];
+const passThroughCommands = ['--version', '-h', '--help', '-i'];
+const printSdfAcsHelp = () => {
+    console.log('\n');
+    [
+        ['sdfAcs:clean', 'removes native manifest, deploy and project.json files'],
+    ].forEach(([a, b]) => console.log([a.padEnd(30), b].join('')));
+    console.log('\n');
+};
+/**
+ * @description - Extract the command arguments that are not-native to suitecloud-cli
+ * - Passthrough the rest.
+ * @param {string[]} commandLineArguments - From the original call
+ * @returns {Record<string,string|true>}
+ */
+const handleCommandLine = (commandLineArguments) => {
+    return commandLineArguments.reduce((accumulator, argument, index, original) => {
+        // commands
+        if (/:/.test(argument) && index === 0)
+            return {
+                ...accumulator,
+                [argument]: null,
+            };
+        // skip values
+        if (!argument.startsWith("-"))
+            return accumulator;
+        let property = argument;
+        // arguments with no value means the next argument is a property and the implied value is true
+        let [nextArgument] = [original[index + 1]].filter((n) => !n || !n.startsWith('-'));
+        // after filtering if we have a nextArgument the value must be true
+        let value = typeof nextArgument === 'undefined' ? true : nextArgument;
+        return {
+            ...accumulator,
+            [property]: value,
+        };
+    }, {});
+};
+/**
+ * @description - Extract arguments and create a native command and execute it.
+ * - Note that native SDF supports having a colon and that is not recommended here.
+ * @param {string[]} commandLineArguments
+ * @returns {void}
+ */
+const executeCommand = (commandLineArguments) => {
+    // quick backup straight up
+    const filesToRemove = ['manifest.xml', 'deploy.xml', 'project.json'];
+    const removed = removeFiles({
+        fileNames: ['manifest.xml', 'deploy.xml', 'project.json'],
+        root: process.cwd(),
+        doBackup: true
+    });
+    const { '--authid': authidFolder, '--debug': debug, ...remaining } = handleCommandLine(commandLineArguments);
+    if (debug)
+        console.log({ commandLineArguments });
+    // handle a ':' being used in the real authid
+    const splitAuthIdFolder = typeof authidFolder === 'string' ? authidFolder.split(':') : [];
+    const folder = splitAuthIdFolder.pop();
+    const authid = splitAuthIdFolder.join(':') || folder;
+    if (debug)
+        console.log({ remaining, authid, folder });
+    const [command, ...nativeArguments] = Object.entries(remaining).flat().filter((a) => (typeof a === 'string'));
+    switch (true) {
+        case command === '-h':
+        case command === '--help':
+            printSdfAcsHelp();
+            break;
+        case command === 'sdfAcs:authmap':
+            // use 'dist' here because it does not matter and that should always exist
+            makeProjectJson(nodePath.join(process.cwd(), '.project.json'), 'foo', 'dist', Boolean(debug));
+            makeProjectJson(nodePath.join(process.cwd(), 'project.json'), 'foo', 'dist', Boolean(debug));
+            sdfAcsAuthMap({ authid, folder }).then((result) => {
+                const message = typeof result === 'boolean' ? `That Mapping Is${result ? '' : ' NOT'} Supported!!` : `${result}`;
+                console.log(message);
+                removeFiles({
+                    fileNames: ['project.json', '.project.json', 'deploy.xml', 'manifest.xml'],
+                    root: nodePath.join(process.cwd(), 'dist'),
+                    doBackup: false
+                });
+            });
+            return;
+        case command === 'sdfAcs:clean':
+            if (folder)
+                removed.push(...removeFiles({
+                    fileNames: ['manifest.xml', 'deploy.xml', 'project.json'],
+                    root: nodePath.join(process.cwd(), folder),
+                    doBackup: true
+                }));
+            console.log('Removed', removed.filter(Boolean));
+            return;
+    }
+    const hasHelpOrVersion = !passThroughCommands.includes(command) &&
+        nativeArguments.some((n) => passThroughCommands.includes(n));
+    const filteredArguments = nativeArguments.filter((n) => passThroughCommands.includes(n));
+    let sdfProcess;
+    if (hasHelpOrVersion && !authid && !folder) {
+        if (debug)
+            console.log('skipping project json', 'passing', { filteredArguments });
+        spawnNativeSdf([command, ...filteredArguments]);
+        return;
+    }
+    // most commands need an authid and a folder
+    if (!commandsThatWithGrace.includes(command) && (!authid || !folder))
+        throw new Error('Missing required argument');
+    // restore this property for authid
+    if (commandsThatNativelyNeedAuthId.includes(command))
+        nativeArguments.push('--authid', authid);
+    // before calling native, store the authid and the folder in a temporary project.json
+    if (debug)
+        console.log('making project jsons', folder);
+    makeProjectJson(nodePath.join(process.cwd(), '.project.json'), authid, folder, Boolean(debug));
+    makeProjectJson(nodePath.join(process.cwd(), 'project.json'), authid, folder, Boolean(debug));
+    sdfProcess = hasHelpOrVersion
+        ? spawnNativeSdf([command, ...nativeArguments])
+        : spawnNativeSdf([command, ...nativeArguments]);
+    sdfProcess.on('close', (err) => {
+        console.log('\nSDFENDSDFENDSDFENDSDFENDSDFENDSDFENDSDFENDSDFENDSDFENDSDFENDSDFENDSDFEND');
+        if (debug)
+            console.log(err);
+        const removed = [];
+        // can do deletes here
+        if (folder)
+            removed.push(...removeFiles({
+                fileNames: ['manifest.xml', 'deploy.xml', 'project.json', '.project.json'],
+                root: nodePath.join(process.cwd(), folder),
+                doBackup: false
+            }));
+        else
+            removed.push(...removeFiles({
+                fileNames: ['manifest.xml', 'deploy.xml'],
+                root: nodePath.join(process.cwd()),
+                doBackup: false
+            }));
+        removed.push(...removeFiles({
+            fileNames: ['project.json', '.project.json'],
+            root: nodePath.join(process.cwd()),
+            doBackup: false
+        }));
+        if (debug)
+            console.log('removing files', removed);
+        else
+            console.log('cleaning up', removed.length);
+    });
+};
+exports.executeCommand = executeCommand;
+//# sourceMappingURL=sdf.js.map

package/lib/spawnSuitecloudChild.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/lib/spawnSuitecloudChild
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+export declare const getChildEnv: () => string;
+/**
+ * @description - whether the process is a child process or not
+ * @returns {boolean}
+ */
+export declare const isChildProcess: () => boolean;
+/**
+ * @description - a suitecloud child process run in the current-working directory
+ * will re-evaluate the same suitecloud.config.js that the outer process evaluated.
+ * You must design for this. Such as being re-prompted for the same questions, etc.
+ * - if you are piping stdout then you will need to interact with these choices programmatically.
+ * - if you inherit stdout then the user will be prompted (but it may be repetitive)
+ *
+ * @param {{onPrompt: Function}} options - a handler where you will get a handle to stdin to interact with the prompt.
+ * @returns {Promise<number>}
+ */
+export declare const createAsync: (options: {
+    command: string;
+    args: string[];
+    interact: boolean;
+    ultraQuiet?: boolean;
+    cwd?: string;
+    onData?: (lines: string[]) => void;
+    onPrompt?: (lines: string[], stdin: any) => void;
+    onMessage?: (lines: string) => void;
+}) => Promise<number>;

package/lib/spawnSuitecloudChild.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/lib/spawnSuitecloudChild
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAsync = exports.isChildProcess = exports.getChildEnv = void 0;
+const cp = require("node:child_process");
+const promptHelpers = require("./promptHelpers");
+const sdfExec = process.env['SUITECLOUD_EXE'] || 'sdf';
+const CONSTANTS = {
+    get ENV_IS_CHILD_TO_SDF() {
+        return 'IS_CHILD_TO_SDF';
+    },
+};
+const getChildEnv = () => CONSTANTS.ENV_IS_CHILD_TO_SDF;
+exports.getChildEnv = getChildEnv;
+/**
+ * @description - whether the process is a child process or not
+ * @returns {boolean}
+ */
+const isChildProcess = () => Boolean(process.env[(0, exports.getChildEnv)()]);
+exports.isChildProcess = isChildProcess;
+/**
+ * @description - a suitecloud child process run in the current-working directory
+ * will re-evaluate the same suitecloud.config.js that the outer process evaluated.
+ * You must design for this. Such as being re-prompted for the same questions, etc.
+ * - if you are piping stdout then you will need to interact with these choices programmatically.
+ * - if you inherit stdout then the user will be prompted (but it may be repetitive)
+ *
+ * @param {{onPrompt: Function}} options - a handler where you will get a handle to stdin to interact with the prompt.
+ * @returns {Promise<number>}
+ */
+const createAsync = async (options) => new Promise((ok, no) => {
+    process.stdout.write(promptHelpers.goColor('WARN', `\ninvoking suitecloud w/ \`${options.command}\``));
+    const innerProcess = cp.spawn(sdfExec, [
+        options.command, // 'file:list',
+        // authId, etc should already be in the args list
+        ...options.args // ['--folder',options.folder]
+    ], {
+        stdio: [
+            'inherit',
+            options.interact ? 'inherit' : 'pipe',
+            'inherit',
+        ],
+        cwd: options.cwd || process.cwd(),
+        env: { ...process.env, [(0, exports.getChildEnv)()]: String(process.pid) }
+    });
+    // process.stdout.write(['\n','processes', process.pid, process.ppid, innerProcess.pid].join(' '));
+    let lines = 0;
+    if (!options.interact) {
+        innerProcess.stdout.on('data', data => {
+            const dStrings = data.toString().split(/\r?\n/);
+            lines += dStrings.length;
+            if (!options.ultraQuiet) {
+                process.stdout.write(promptHelpers.goColor('INFO', '...', lines || ''));
+            }
+            if (typeof options.onMessage === 'function') {
+                options.onMessage(promptHelpers.goColor('INFO', '...', lines || ''));
+            }
+            //console.log({dStrings});
+            // detect prompt
+            const isPrompt = dStrings.find((l) => promptHelpers.detectPrompt(l));
+            if (typeof options.onPrompt === 'function')
+                options.onPrompt(dStrings, innerProcess.stdin);
+            if (typeof options.onData === 'function')
+                options.onData(dStrings);
+        });
+    }
+    innerProcess.on('error', (e) => {
+        if (!options.ultraQuiet)
+            process.stdout.write(promptHelpers.goColor('BAD', '\n', e));
+        if (typeof options.onMessage === 'function') {
+            options.onMessage(promptHelpers.goColor('BAD', '\n', e));
+        }
+        no(e);
+    });
+    innerProcess.on('close', (e) => {
+        if (e)
+            no(e);
+        ok(0);
+    });
+}).catch(err => {
+    process.stdout.write(promptHelpers.goColor('BAD', 'error', err));
+    throw err;
+});
+exports.createAsync = createAsync;
+//# sourceMappingURL=spawnSuitecloudChild.js.map

package/lib/switchAuth.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @file sdf/lib/switchAuth.ts
+ * - detect an authid property and extract it.
+ * ## authid implies:
+ * - a switch to a different directory based on the account tied to that auth
+ * - a switch to that auth
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+/**
+ * @description - Extracts and acts on an authid property
+ * @param options
+ * @returns {typeof options} - Similar object but without the authid
+ */
+declare const processAuthId: (options: object & {
+    authid: string;
+}) => {};
+export = processAuthId;

package/lib/switchAuth.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * @file sdf/lib/switchAuth.ts
+ * - detect an authid property and extract it.
+ * ## authid implies:
+ * - a switch to a different directory based on the account tied to that auth
+ * - a switch to that auth
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+const switchAuth = (options) => {
+    // handle project.json file
+};
+/**
+ * @description - Extracts and acts on an authid property
+ * @param options
+ * @returns {typeof options} - Similar object but without the authid
+ */
+const processAuthId = (options) => {
+    const { authid, ...remaining } = options;
+    return remaining;
+};
+module.exports = processAuthId;
+//# sourceMappingURL=switchAuth.js.map

package/lib/tempFileHelper.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/lib/tempFileHelper
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+export declare const FileNames: {
+    accountManagementList: string;
+    objectList: string;
+    fileList: string;
+};
+/**
+ * @description - usually a temp file is:
+ * - created by an 'onCompleted' handler on a child process
+ * - consumed by a 'beforeExecuting' handler of a parent process
+ * - therefore watch out for file cleanup activities
+ * @param {string} fileName
+ * @param {string} data - serialized data
+ * @returns {Promise<string>} - the new file and path
+ */
+export declare const makeTempFile: (fileName: string, data: string) => Promise<string>;
+/**
+ * @description - read and delete the temp file
+ * @param {string} fileName
+ * @returns {Promise<string>}
+ */
+export declare const consumeTempFile: (fileName: string) => Promise<string>;
+/**
+ * @description - removes temp files
+ */
+export declare const removeTempFiles: (prefix?: string) => Promise<void>;