@suitegeezus/suitecloud-stacker 25.2.127

package/commands/accountManageauth.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateList = exports.promptForAccountChoice = exports.betterList = exports.fetchAccountList = exports.saveList = void 0;
+const pathHelpers = require("../lib/pathHelpers");
+const promptHelpers_1 = require("../lib/promptHelpers");
+const projectJsonHelpers = require("../lib/projectJsonHelpers");
+const onErrorHelper = require("../lib/onErrorHelper");
+const spawnSuitecloud = require("../lib/spawnSuitecloudChild");
+const tempFileHelper = require("../lib/tempFileHelper");
+const spawnSuitecloudChild_1 = require("../lib/spawnSuitecloudChild");
+/**
+ * @description - save the list of account details as json
+ */
+const saveList = () => {
+    const origin = 'saveList';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            return options;
+        },
+        onCompleted: async (options) => {
+            if (spawnSuitecloud.isChildProcess())
+                await tempFileHelper.makeTempFile(tempFileHelper.FileNames.accountManagementList, JSON.stringify(options));
+            return options;
+        }
+    };
+};
+exports.saveList = saveList;
+/** @internal */
+const makeList = (data) => {
+    return Object.entries(data).map(([key, value]) => ({
+        authid: key,
+        domain: value.hostInfo?.hostName || value?.domain || null,
+        accountInfo: {
+            companyId: value.accountInfo?.companyId,
+            companyName: value.accountInfo?.companyName,
+            roleName: value.accountInfo?.roleName,
+            entityId: value.accountInfo?.entityId,
+        },
+        auth: {
+            certificateId: value.certificateInfo?.certificateId,
+            // only available in 2.0
+            privatekeyPath: value.certificateInfo?.privateKeyPath || 'no longer available >2.0',
+            expiration: value.token?.expirationDate,
+            partialPrivateKey: value.certificateInfo?.privateKey
+                ? value.certificateInfo.privateKey.substring(0, 30) + '...'
+                : 'not available'
+        }
+    }));
+};
+/**
+ *  @description - Filters an account list for those relevant to the given account
+ *  @example ```js
+ *  authid: "ACMEINC-DEV",
+ *     domain: "654321-sb1.app.netsuite.com",
+ *     accountInfo: {
+ *         companyId:"654321_SB1",
+ *         companyName:"Acme, Inc (SB2)",
+ *         roleName: "Administrator",
+ *         entityId: "1324546",
+ *     };
+ *     auth: {
+ *         certificateId: "aEB5fUYumwJbnvP09kR",
+ *         privatekeyPath: "/Users/geraldgillespie/.keys/sdfgg.pem",
+ *         expiration: "2025-03-05T14:29.3961Z",
+ *     }
+ *  ```
+ * @returns {Promise<ReturnType<makeList>>}
+ */
+const fetchAccountList = async () => {
+    // prompt for account
+    const exitCode = await spawnSuitecloud.createAsync({
+        command: 'account:manageauth',
+        args: ['--list'],
+        interact: true,
+    });
+    // now read the list from the temp file
+    const listJson = await tempFileHelper.consumeTempFile(tempFileHelper.FileNames.accountManagementList);
+    const { _data: data, _actionExecuted } = JSON.parse(listJson);
+    if (_actionExecuted === 'list')
+        return makeList(data);
+    return [];
+};
+exports.fetchAccountList = fetchAccountList;
+const betterList = () => {
+    const origin = 'betterList';
+    return {
+        _origin: origin,
+        isStackable: true,
+        onCompleted: async (options) => {
+            if (!(0, spawnSuitecloudChild_1.isChildProcess)() && ['list', 'info'].includes(options._actionExecuted)) {
+                const list = options._data.authId
+                    ? makeList(
+                    // @ts-expect-error yes it does
+                    { [options._data.authId]: options._data }) : // @ts-expect-error yes it does
+                    makeList(options._data);
+                process.stdout.write((0, promptHelpers_1.goColor)('HIGHLIGHT', '\n', JSON.stringify(list, null, 2)));
+            }
+            return options;
+        }
+    };
+};
+exports.betterList = betterList;
+/**
+ * @description - Prompts for account choice. This provides both verification and literal choice. If the choice does not match the current
+ * context then an error is forced -- this is because SDF does not recognize a change in the account after launching.
+ * @returns {*}
+ */
+const promptForAccountChoice = () => {
+    const origin = 'promptForAccountChoice';
+    return {
+        _origin: origin,
+        beforeExecuting: async (options) => {
+            if (options?.arguments?.runhooks === 'quiet')
+                return options;
+            process.stdout.write((0, promptHelpers_1.goColor)('HIGHLIGHT', '\n', options));
+            if (!Reflect.has({ ...options?.arguments }, 'authid')) {
+                throw onErrorHelper.makeError(origin, new Error(`${options.command} is missing authid. Perhaps you should not stack ${origin} here`));
+            }
+            if (options?.arguments?.calledfromcomparefiles && /\btemp\b.\bFileCabinet\b/.test(options.projectPath))
+                return options;
+            if (spawnSuitecloud.isChildProcess())
+                return options;
+            // "native" prompt
+            if (options?.arguments?.authid === 'prompt')
+                return options;
+            const isNewVersion = Boolean(options?.arguments?.authid && options?.executionPath);
+            if (isNewVersion)
+                return options;
+            try {
+                const unfilteredList = await (0, exports.fetchAccountList)();
+                const accountFromFolder = pathHelpers.getRootOfAccount(process.cwd(), true);
+                process.stdout.write((0, promptHelpers_1.goColor)('SUBTLE', '\n', JSON.stringify({ accountFromFolder }, null, 2)));
+                const filteredList = unfilteredList.filter((entry) => {
+                    return entry.accountInfo.companyId.toLowerCase().startsWith(accountFromFolder.toLowerCase());
+                });
+                // process.stdout.write(goColor('SUBTLE', '\n', {filteredListForAccount}));
+                if (filteredList.length === 0) {
+                    throw onErrorHelper.makeError(origin, new Error('No current authids match the given authid ' + options.arguments.authid));
+                }
+                const choices = {};
+                const displayChoices = {};
+                filteredList.forEach((d) => {
+                    const [, two] = d.domain.split(/[-.]/);
+                    const key = two === 'app' ? 'prod' : two;
+                    displayChoices[key] = [(0, promptHelpers_1.goColor)('INFO', d.authid), (0, promptHelpers_1.goColor)('SUBTLE', `(${d.domain})`)].join(' ');
+                    choices[key] = d.authid;
+                });
+                const defaultAuthId = Object.values(choices).find((c) => {
+                    // console.log('accountFromFolder', choices,displayChoices,{c}, options);
+                    return options.arguments.authid.toLowerCase() === c.toLowerCase();
+                }) || 'QUIT';
+                const chosenId = await (0, promptHelpers_1.promptChoices)({
+                    choices,
+                    displayChoices,
+                    default: defaultAuthId,
+                    // premessage
+                    question: `Which Account to use? ${(0, promptHelpers_1.goColor)('SUBTLE', `default account is: ${defaultAuthId}`)}`,
+                }).catch((error) => {
+                    process.stdout.write((0, promptHelpers_1.goColor)('BAD', '\n', error));
+                    throw onErrorHelper.makeError(origin, new Error('Error in choices'));
+                });
+                if (chosenId &&
+                    filteredList.flatMap((id) => {
+                        if (!id?.domain)
+                            return [];
+                        return !id?.domain.includes('-') ? [id.authid] : [];
+                    }).length > 0) {
+                    // @ts-expect-error the type needs this
+                    options._isProd = filteredList.some((x) => (x.authid === chosenId && /\d{5}\.app\./.test(x.domain)));
+                }
+                process.stdout.write((0, promptHelpers_1.goColor)('SUBTLE', '\nYou chose ', JSON.stringify(chosenId, null, 2)));
+                if (chosenId && chosenId === options?.arguments?.authid)
+                    return options;
+                if (Reflect.has({ ...options.arguments }, 'authid') && chosenId) {
+                    // update the current project.json
+                    await projectJsonHelpers.updateProjectJson({ defaultAuthId: chosenId }, [process.cwd()]);
+                    process.stdout.write((0, promptHelpers_1.goColor)('GOOD', '\n', `Account has been switched (in project.json) to \`${chosenId}\`. Please start the task again ✅`));
+                    process.exit(0); // kill(process.pid);
+                }
+                if (!chosenId)
+                    throw onErrorHelper.makeError(origin, new Error('Could not find an account to match ' + options?.arguments?.authid || 'unknown'));
+            }
+            catch (e) {
+                // console.error(e);
+                throw onErrorHelper.makeError(origin, e);
+            }
+        },
+        onError: async (error) => {
+            console.log(error);
+            await (0, promptHelpers_1.promptUser)({ message: 'pause oc' });
+            return onErrorHelper.detectOriginAndReturn(origin, error, (error) => {
+                if (`${error}`?.includes('This error is a necessary evil')) {
+                    process.stdout.write((0, promptHelpers_1.goColor)('GOOD', '\n', error, '\n'));
+                }
+                else if (`${error}`.includes('No account has been set up for this project') ||
+                    error.includes('No current authids')) {
+                    //TODO
+                    const rootFolderName = pathHelpers.getRootOfAccount(process.cwd(), true);
+                    const pad = [10, '*'];
+                    process.stdout.write((0, promptHelpers_1.goColor)('NONE', (0, promptHelpers_1.goColor)('BAD', '\n', ' '.padStart(...pad), error), (0, promptHelpers_1.goColor)('WARN', '\n', ' '.padStart(...pad), rootFolderName), (0, promptHelpers_1.goColor)('GOOD', '\n', ' '.padStart(...pad), 'Run '), (0, promptHelpers_1.goColor)('HIGHLIGHT', 'suitecloud account:setup:ci'), (0, promptHelpers_1.goColor)('GOOD', ' to re-use your tokens'), '\n'));
+                }
+                else {
+                    process.stdout.write((0, promptHelpers_1.goColor)('BAD', '\n', error, '\n'));
+                }
+                return '';
+            });
+        },
+        isStackable: true
+    };
+};
+exports.promptForAccountChoice = promptForAccountChoice;
+/**
+ * @description -
+ * @param options
+ */
+const validateList = (options) => {
+    return {
+        _origin: 'validateList',
+        onCompleted: (options) => {
+            // TODO
+        },
+        isStackable: true,
+    };
+};
+exports.validateList = validateList;
+//# sourceMappingURL=accountManageauth.js.map

package/commands/accountSetup.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/commands/accountSetup
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+import { SdfCommand } from "#root/index";
+type AccountSetupBeforeExecutingOptions<C = 'account:setup:ci' | 'account:setup'> = {
+    projectPath: string;
+    command: C;
+    arguments: {
+        authid: string;
+    } & (C extends 'account:setup:ci' ? {
+        account?: string;
+        privatekeypath?: string;
+        certificateid?: string;
+        domain?: string;
+    } : {
+        account?: undefined;
+        privatekeypath?: undefined;
+        certificateid?: undefined;
+        domain?: undefined;
+    });
+};
+/**
+ * @description - domain is not always required normally but here it is -- it make switching account easier
+ */
+export declare const getDefaults: () => {
+    _origin: string;
+    beforeExecuting: (options: AccountSetupBeforeExecutingOptions) => AccountSetupBeforeExecutingOptions<"account:setup:ci" | "account:setup">;
+    isStackable: boolean;
+};
+/**
+ * @description - Forces that accounts have a certain naming convention
+ *
+ */
+export declare const forceAccountInName: () => {
+    _origin: string;
+    beforeExecuting: <C extends "account:setup:ci" | "account:setup">(options: AccountSetupBeforeExecutingOptions<C>) => AccountSetupBeforeExecutingOptions<C>;
+    onCompleted: (options: any) => any;
+    onError: (err: any) => Promise<any>;
+    isStackable: boolean;
+};
+/**
+ * @description - prompt to choose from currently used auth
+ */
+export declare const chooseExistingCertificate: () => SdfCommand;
+export declare const promptForAccount: () => SdfCommand;
+/**
+ * @description - account (not folder)
+ */
+export declare const promptForAuthId: () => SdfCommand;
+/**
+ * @description - Authid must be unique
+ * - Accountid technically does not need to be unique
+ */
+export declare const askToReplace: () => SdfCommand;
+export {};

package/commands/accountSetup.js

@@ -0,0 +1,218 @@
+"use strict";
+/**
+ * @file /Users/geraldgillespie/code/nsaccounts/sdf/commands/accountSetup
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askToReplace = exports.promptForAuthId = exports.promptForAccount = exports.chooseExistingCertificate = exports.forceAccountInName = exports.getDefaults = void 0;
+const promptHelpers_1 = require("../lib/promptHelpers");
+const pathHelpers_1 = require("../lib/pathHelpers");
+const nodePath = require("node:path");
+const spawnSuitecloud = require("../lib/spawnSuitecloudChild");
+const accountManageauth_1 = require("../commands/accountManageauth");
+const safeCommands_1 = require("../safeCommands");
+const onErrorHelper = require("../lib/onErrorHelper");
+const validators_1 = require("../lib/validators");
+const handleRootProjectJson = require('../lib/handleRootProjectJson');
+/**
+ * @description - domain is not always required normally but here it is -- it make switching account easier
+ */
+const getDefaults = () => {
+    return {
+        _origin: 'getDefaults',
+        beforeExecuting: (options) => {
+            Object.assign(options.arguments, handleRootProjectJson.readDefaultsFromJson(['privatekeypath', 'certificateid']));
+            // domain if missing
+            if (!options.arguments?.domain)
+                throw new Error('getDefaults:You must provide the domain argument always. Even for production. e.g. 1352643.app.netsuite.com');
+            return options;
+        },
+        isStackable: true,
+    };
+};
+exports.getDefaults = getDefaults;
+/**
+ * @description - Forces that accounts have a certain naming convention
+ *
+ */
+const forceAccountInName = () => {
+    const origin = 'forceAccountInName';
+    return {
+        _origin: origin,
+        beforeExecuting: (options) => {
+            const { authid, account } = options.arguments;
+            const [firstAuthIdBit] = authid.split(/\W/);
+            const [firstAcctBit] = account.split('_');
+            //TODO instead of process.cwd()  should this be options.projectPath + defaultProjectFolder (from project.json)
+            const rootOfAccount = nodePath.basename((0, pathHelpers_1.getRootOfAccount)(process.cwd())).toLowerCase();
+            if (rootOfAccount !== firstAuthIdBit.toLowerCase())
+                throw onErrorHelper.makeError(origin, new Error('The new authid MUST begin with ' + rootOfAccount));
+            if (rootOfAccount !== firstAcctBit.toLowerCase())
+                throw onErrorHelper.makeError(origin, new Error('the new account MUST match ' + rootOfAccount));
+            return options;
+        },
+        onCompleted: (options) => {
+            return options;
+        },
+        onError: (err) => onErrorHelper.detectOriginAndReturn(origin, err, (error) => {
+            process.stdout.write((0, promptHelpers_1.goColor)('INFO', '\nTry From the account folder or root folder'));
+            return error;
+        }),
+        isStackable: true,
+    };
+};
+exports.forceAccountInName = forceAccountInName;
+/**
+ * @description - prompt to choose from currently used auth
+ */
+const chooseExistingCertificate = () => {
+    const origin = 'chooseExistingCertificate';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            // skip
+            if (options?.arguments?.certificateid)
+                return options;
+            // @ts-expect-error is fine
+            if (options?.arguments?.runhooks === 'quiet')
+                return options;
+            // generate and read the account list
+            const accountList = await (0, accountManageauth_1.fetchAccountList)();
+            const choices = [...new Set(accountList.map(({ auth }) => {
+                    const { certificateId, privatekeyPath } = auth;
+                    return JSON.stringify({
+                        certificateId,
+                        privatekeyPath
+                    });
+                }))];
+            // present the data
+            const displayChoices = choices.map((c, i) => {
+                const d = JSON.parse(c);
+                return [
+                    (0, promptHelpers_1.goColor)('INFO', d.certificateId),
+                    (0, promptHelpers_1.goColor)('SUBTLE', d.privatekeyPath),
+                ].join(' ');
+            });
+            // choice of private key pairs
+            let answer = await safeCommands_1.promptHelpers.promptChoices({
+                choices: choices,
+                displayChoices,
+                default: null,
+                question: `Which existing certificate would you like to use?`
+            });
+            // options.arguments.
+            const { certificateId, privatekeyPath } = JSON.parse(answer);
+            options.arguments.certificateid = certificateId;
+            options.arguments.privatekeypath = privatekeyPath;
+            return options;
+        }
+    };
+};
+exports.chooseExistingCertificate = chooseExistingCertificate;
+const promptForAccount = () => {
+    const origin = 'promptForAccount';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            // @ts-expect-error is fine
+            if (options?.arguments?.runhooks === 'quiet')
+                return options;
+            let answer = '';
+            const nag = async () => {
+                answer = await safeCommands_1.promptHelpers.promptUser({
+                    message: 'What is the new account id? (e.g. TD765432 or 24635_RP)'
+                });
+            };
+            while (!(0, validators_1.isValidAccountName)(answer)) {
+                await nag();
+            }
+            options.arguments.account = answer.toUpperCase();
+            options.arguments.domain = answer.toLowerCase().replace('_', '-') + '.app.netsuite.com';
+            return options;
+        }
+    };
+};
+exports.promptForAccount = promptForAccount;
+/**
+ * @description - account (not folder)
+ */
+const promptForAuthId = () => {
+    const origin = 'promptForAuthId';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            // @ts-expect-error fine
+            if (options.arguments?.runhooks === 'quiet')
+                return options;
+            let answer = '';
+            const nag = async () => {
+                answer = await safeCommands_1.promptHelpers.promptUser({
+                    message: 'What authId? (e.g. ACME-DEV)'
+                });
+            };
+            while (!(0, validators_1.isValidAuthId)(answer)) {
+                await nag();
+            }
+            options.arguments.authid = answer;
+            return options;
+        }
+    };
+};
+exports.promptForAuthId = promptForAuthId;
+/**
+ * @description - Authid must be unique
+ * - Accountid technically does not need to be unique
+ */
+const askToReplace = () => {
+    const origin = 'promptForAuthId';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            // @ts-expect-error ok
+            if (options?.arguments?.runhooks === 'quiet')
+                return options;
+            process.stdout.write(safeCommands_1.promptHelpers.goColor('INFO', '\nChecking for conflicts...'));
+            // check if authid is already in use
+            // generate and read the account list
+            const removeAccount = async (type, value, forced) => {
+                const accountList = await (0, accountManageauth_1.fetchAccountList)();
+                const conflict = accountList.find((d) => {
+                    if (type === 'authid')
+                        return d.authid === value;
+                    if (type === 'companyId')
+                        return d.accountInfo.companyId === value;
+                    return false;
+                });
+                if (conflict) {
+                    process.stdout.write(safeCommands_1.promptHelpers.goColor('SUBTLE', '\nConflict found ', JSON.stringify(conflict, null, 2)));
+                    const choices = ['Replace'];
+                    if (!forced)
+                        choices.push('Continue');
+                    let answer = await safeCommands_1.promptHelpers.promptChoices({
+                        choices,
+                        displayChoices: choices,
+                        question: `Would you like to replace the existing account? ${conflict.authid}`,
+                        default: 'Quit',
+                    });
+                    if (answer === choices[0]) {
+                        await spawnSuitecloud.createAsync({
+                            command: 'account:manageauth',
+                            args: ['--remove', options.arguments.authid],
+                            interact: true,
+                        });
+                    }
+                }
+            };
+            await removeAccount('authid', options.arguments.authid, true);
+            if (options.arguments.account)
+                await removeAccount('companyId', options.arguments.account);
+            return options;
+        }
+    };
+};
+exports.askToReplace = askToReplace;
+//# sourceMappingURL=accountSetup.js.map

package/commands/customhook/compiless.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file commands/acspass/compiless.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+import { SdfCommand } from "../../index";
+/**
+ * @description
+ * ./suitecloud.config.js watch -e ts --ignore module.d.ts
+ */
+export declare const compileSuiteScript: (ignore: string[]) => SdfCommand;

package/commands/customhook/compiless.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * @file commands/acspass/compiless.ts
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileSuiteScript = void 0;
+const onErrorHelper = require("../../lib/onErrorHelper");
+const compileHelper = require("../../lib/compileHelper");
+const assert = require("node:assert");
+const nodePath = require("node:path");
+const safeCommands_1 = require("../../safeCommands");
+const updateModule = require("../../lib/updateModule");
+const TsConfigName = 'tsconfig.json';
+const passthroughCommand = 'custom:hook';
+/**
+ * @description
+ * ./suitecloud.config.js watch -e ts --ignore module.d.ts
+ */
+const compileSuiteScript = (ignore) => {
+    const origin = 'compileSuiteScript';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            assert(options.command === passthroughCommand);
+            if (options.arguments.option1 !== 'compiless')
+                return options;
+            await compileHelper.compileTsConfig(options.arguments.option2 || nodePath.join(process.cwd(), TsConfigName));
+            await updateModule.updateModuleTypeDef();
+            return options;
+        },
+        onError: async (error) => onErrorHelper.detectOriginAndReturn(origin, error, async (error) => {
+            await safeCommands_1.promptHelpers.promptUser({
+                message: `
+${passthroughCommand} Usage for "compiless" 
+    --option1 compiless                   - begin watching ts
+    -option2 <path>                      - alternate tsconfig file
+`
+            });
+            return error;
+        })
+    };
+};
+exports.compileSuiteScript = compileSuiteScript;
+//# sourceMappingURL=compiless.js.map

package/commands/customhook/watchss.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @file commands/customhook/watchss.ts
+ * Using nodemon to
+ * - watch TSC for a typical accounts project
+ * - spawns a child process
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+import { SdfCommand } from "../../index";
+/**
+ * @description
+ * @example sdf custom:hook --option1 watchss --option2 ignore --multi2 module.d.ts foo.d.ts
+ * ./suitecloud.config.js watch -e ts --ignore module.d.ts
+ */
+export declare const watchSuiteScript: (sdfFileName: string, ignore: string[]) => SdfCommand;

package/commands/customhook/watchss.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * @file commands/customhook/watchss.ts
+ * Using nodemon to
+ * - watch TSC for a typical accounts project
+ * - spawns a child process
+ * @author Gerald Gillespie <gerald.gillespie@fullscript.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchSuiteScript = void 0;
+const onErrorHelper = require("../../lib/onErrorHelper");
+const safeCommands_1 = require("../../safeCommands");
+const cp = require("node:child_process");
+const assert = require("node:assert");
+const passthroughCommand = 'custom:hook';
+const sdfExec = process.env['SUITECLOUD_EXE'] || 'sdf';
+const SdfCompileCommand = `${sdfExec} ${passthroughCommand} --option1 compiless`;
+/**
+ * @description
+ * @example sdf custom:hook --option1 watchss --option2 ignore --multi2 module.d.ts foo.d.ts
+ * ./suitecloud.config.js watch -e ts --ignore module.d.ts
+ */
+const watchSuiteScript = (sdfFileName, ignore) => {
+    const origin = 'watchSuiteScript';
+    return {
+        _origin: origin,
+        isStackable: true,
+        beforeExecuting: async (options) => {
+            assert(options.command === passthroughCommand);
+            if (options.arguments.option1 !== 'watchss')
+                return options;
+            //
+            const combinedIgnore = [...ignore];
+            const doIgnore = Boolean(options.arguments.option2);
+            if (doIgnore) {
+                // array must accompany the ignore
+                assert(Array.isArray(options.arguments.multi1));
+                combinedIgnore.push(...[options.arguments.multi1].flat());
+            }
+            const extraArgs = [];
+            if (combinedIgnore.length > 0)
+                extraArgs.push('--ignore', ...combinedIgnore);
+            process.stdout.write(safeCommands_1.promptHelpers.goColor('INFO', '\nlaunching compile via sdf', ...extraArgs));
+            const unAttachedNodemon = cp.spawn('nodemon', [
+                `--exec "${SdfCompileCommand}"`,
+                '-e',
+                'ts',
+            ].concat(extraArgs).filter(Boolean), {
+                cwd: process.cwd(),
+                stdio: 'inherit',
+                shell: true
+            });
+            await new Promise((ok, no) => {
+                unAttachedNodemon.on('close', (e) => {
+                    if (!e)
+                        ok(0);
+                });
+                unAttachedNodemon.on('error', no);
+            });
+            return options;
+        },
+        onError: async (error) => onErrorHelper.detectOriginAndReturn(origin, error, async (error) => {
+            console.error({ error });
+            await safeCommands_1.promptHelpers.promptUser({
+                message: `
+${passthroughCommand} Usage for "watchss" 
+    --option1 watchss                   - begin watching ts
+    --flag2                             - presence means to obey ignore list
+    --multi2 <files>                    - list of what to ignore if accompanied by the flag
+`
+            });
+            return error;
+        })
+    };
+};
+exports.watchSuiteScript = watchSuiteScript;
+//# sourceMappingURL=watchss.js.map