@brillout/test-e2e 0.5.8 → 0.5.9

package/dist/setup.js

@@ -3,9 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getServerUrl = exports.sleep = exports.isMac = exports.isWindows = exports.isLinux = exports.isCI = exports.isMinNodeVersion = exports.skip = exports.run = exports.expectError = exports.fetch = exports.fetchHtml = exports.autoRetry = exports.partRegex = void 0;
-const child_process_1 = require("child_process");
-const path_1 = require("path");
+exports.runCommandThatTerminates = exports.getServerUrl = exports.sleep = exports.isMac = exports.isWindows = exports.isLinux = exports.isCI = exports.isMinNodeVersion = exports.skip = exports.run = exports.expectError = exports.fetch = exports.fetchHtml = exports.autoRetry = exports.partRegex = void 0;
+var part_regex_1 = require("@brillout/part-regex");
+Object.defineProperty(exports, "partRegex", { enumerable: true, get: function () { return part_regex_1.partRegex; } });
+var autoRetry_1 = require("./autoRetry");
+Object.defineProperty(exports, "autoRetry", { enumerable: true, get: function () { return autoRetry_1.autoRetry; } });
+var Logs_1 = require("./Logs");
+Object.defineProperty(exports, "expectError", { enumerable: true, get: function () { return Logs_1.expectError; } });
+var runCommandThatTerminates_1 = require("./runCommandThatTerminates");
+Object.defineProperty(exports, "runCommandThatTerminates", { enumerable: true, get: function () { return runCommandThatTerminates_1.runCommandThatTerminates; } });
 const utils_1 = require("./utils");
 Object.defineProperty(exports, "sleep", { enumerable: true, get: function () { return utils_1.sleep; } });
 Object.defineProperty(exports, "isWindows", { enumerable: true, get: function () { return utils_1.isWindows; } });
@@ -14,22 +20,11 @@ Object.defineProperty(exports, "isCI", { enumerable: true, get: function () { re
 Object.defineProperty(exports, "isMac", { enumerable: true, get: function () { return utils_1.isMac; } });
 const node_fetch_1 = __importDefault(require("node-fetch"));
 const utils_2 = require("./utils");
-const Logs_1 = require("./Logs");
-const strip_ansi_1 = __importDefault(require("strip-ansi"));
+const Logs_2 = require("./Logs");
 const editFile_1 = require("./editFile");
 const getCurrentTest_1 = require("./getCurrentTest");
 const page_1 = require("./page");
-const logTestStatus_1 = require("./logTestStatus");
-var part_regex_1 = require("@brillout/part-regex");
-Object.defineProperty(exports, "partRegex", { enumerable: true, get: function () { return part_regex_1.partRegex; } });
-var Logs_2 = require("./Logs");
-Object.defineProperty(exports, "expectError", { enumerable: true, get: function () { return Logs_2.expectError; } });
-const serverUrlDefault = 'http://localhost:3000';
-const TIMEOUT_NPM_SCRIPT = 2 * 60 * 1000 * (!(0, utils_1.isCI)() ? 1 : (0, utils_1.isWindows)() ? 2 : 1);
-const TIMEOUT_TEST_FUNCTION = 60 * 1000 * (!(0, utils_1.isCI)() ? 1 : (0, utils_1.isWindows)() ? 5 : 3);
-const TIMEOUT_PROCESS_TERMINATION = 10 * 1000 * (!(0, utils_1.isCI)() ? 1 : (0, utils_1.isWindows)() ? 3 : !(0, utils_1.isLinux)() ? 3 : 1);
-const TIMEOUT_AUTORETRY = TIMEOUT_TEST_FUNCTION / 2;
-const TIMEOUT_PLAYWRIGHT = TIMEOUT_TEST_FUNCTION / 2;
+const TIMEOUTS_1 = require("./TIMEOUTS");
 function skip(reason) {
     const testInfo = (0, getCurrentTest_1.getCurrentTest)();
     testInfo.skipped = { reason };
@@ -37,32 +32,33 @@ function skip(reason) {
 exports.skip = skip;
 function run(cmd, { 
 //baseUrl = '',
-additionalTimeout = 0, serverIsReadyMessage, serverIsReadyDelay = 1000, inspect = utils_1.cliConfig.inspect, cwd, doNotFailOnWarning = false, serverUrl = serverUrlDefault, isFlaky = false, } = {}) {
+additionalTimeout = 0, serverIsReadyMessage, serverIsReadyDelay = 1000, inspect = utils_1.cliConfig.inspect, cwd, doNotFailOnWarning, serverUrl, isFlaky, } = {}) {
+    (0, utils_2.assert)(cwd === undefined);
     additionalTimeout += serverIsReadyDelay;
-    const testInfo = (0, getCurrentTest_1.getCurrentTest)();
-    testInfo.runInfo = {
+    (0, getCurrentTest_1.setRunInfo)({
         cmd,
-        cwd: cwd || getCwd(),
+        serverUrl,
         additionalTimeout,
-        testFunctionTimeout: TIMEOUT_TEST_FUNCTION + additionalTimeout,
-        serverIsReadyMessage,
-        serverIsReadyDelay,
-        inspect,
         doNotFailOnWarning,
-        serverUrl,
         isFlaky,
-    };
+    });
     if (inspect) {
-        Logs_1.Logs.logEagerly = true;
+        Logs_2.Logs.logEagerly = true;
     }
+    const testInfo = (0, getCurrentTest_1.getCurrentTest)();
     let runProcess = null;
     testInfo.startServer = async () => {
-        runProcess = await start();
+        runProcess = await startProcess({
+            cmd,
+            additionalTimeout,
+            serverIsReadyMessage,
+            serverIsReadyDelay,
+        });
         page_1.page.on('console', onConsole);
         page_1.page.on('pageerror', onPageError);
         // This setting will change the default maximum time for all the methods accepting timeout option.
         // https://playwright.dev/docs/api/class-page#page-set-default-timeout
-        page_1.page.setDefaultTimeout(TIMEOUT_PLAYWRIGHT + additionalTimeout);
+        page_1.page.setDefaultTimeout(TIMEOUTS_1.TIMEOUT_PLAYWRIGHT + additionalTimeout);
         /*
         await bailOnTimeout(
           async () => {
@@ -81,13 +77,13 @@ additionalTimeout = 0, serverIsReadyMessage, serverIsReadyDelay = 1000, inspect
         }
     };
     testInfo.terminateServer = async () => {
-        Logs_1.Logs.add({
+        Logs_2.Logs.add({
             logSource: 'run()',
             logText: 'Terminate server.',
         });
         page_1.page.off('console', onConsole);
         page_1.page.off('pageerror', onPageError);
-        // `runProcess` is `undefined` if `start()` failed.
+        // runProcess is undefined if startProcess() failed
         if (runProcess) {
             await runProcess.terminate();
         }
@@ -96,7 +92,7 @@ additionalTimeout = 0, serverIsReadyMessage, serverIsReadyDelay = 1000, inspect
     // Also called when the page throws an error or a warning
     function onConsole(msg) {
         const type = msg.type();
-        Logs_1.Logs.add({
+        Logs_2.Logs.add({
             logSource: (() => {
                 if (type === 'error') {
                     return 'Browser Error';
@@ -116,7 +112,7 @@ additionalTimeout = 0, serverIsReadyMessage, serverIsReadyDelay = 1000, inspect
     }
     // For uncaught exceptions
     function onPageError(err) {
-        Logs_1.Logs.add({
+        Logs_2.Logs.add({
             logSource: 'Browser Error',
             logText: JSON.stringify({
                 text: err.message,
@@ -126,312 +122,85 @@ additionalTimeout = 0, serverIsReadyMessage, serverIsReadyDelay = 1000, inspect
     }
 }
 exports.run = run;
-function getRunInfo() {
-    const testInfo = (0, getCurrentTest_1.getCurrentTest)();
-    (0, utils_2.assert)(testInfo.runInfo);
-    return testInfo.runInfo;
-}
-async function start() {
-    const { cmd, additionalTimeout, serverIsReadyMessage, serverIsReadyDelay } = getRunInfo();
-    if (utils_1.isTTY) {
-        console.log();
-        (0, logTestStatus_1.logBoot)();
-    }
-    const done = (0, utils_1.logProgress)(`[run] ${cmd}`);
-    let hasSuccessfullyStarted = false;
-    let resolveServerStart;
-    let rejectServerStart;
-    const promise = new Promise((_resolve, _reject) => {
-        resolveServerStart = () => {
-            (0, utils_2.assert)(!processHasExited());
-            (0, utils_2.assert)(getRunInfo().cmd === cmd);
-            Logs_1.Logs.add({
-                logSource: 'run()',
-                logText: 'Server is ready.',
-            });
-            hasSuccessfullyStarted = true;
-            clearTimeout(serverStartTimeout);
-            const runProcess = { terminate };
-            _resolve(runProcess);
-        };
-        rejectServerStart = async (err) => {
-            (0, utils_2.assert)(processHasExited());
-            (0, utils_2.assert)(getRunInfo().cmd === cmd);
-            done(true);
-            clearTimeout(serverStartTimeout);
-            _reject(err);
-        };
-    });
-    const timeoutTotal = TIMEOUT_NPM_SCRIPT + additionalTimeout;
-    let hasTimedout = false;
-    const serverStartTimeout = setTimeout(async () => {
-        hasTimedout = true;
-        let errMsg = '';
-        errMsg += `Server still didn't start after ${(0, utils_1.humanizeTime)(timeoutTotal)} of running the npm script \`${cmd}\`.`;
-        if (serverIsReadyMessage) {
-            errMsg += ` (The stdout of the npm script did not include: "${serverIsReadyMessage}".)`;
-        }
-        Logs_1.Logs.add({
-            logSource: 'run() failure',
-            logText: errMsg,
-        });
-        await terminate(true);
-        rejectServerStart(new Error(errMsg));
-    }, timeoutTotal);
-    // Kill any process that listens to the server port
-    if (!process.env.CI && (0, utils_1.isLinux)()) {
-        const port = getPort();
-        (0, utils_2.assert)(/\d+/.test(port));
-        await (0, utils_1.runCommand)(`fuser -k ${port}/tcp`, { swallowError: true, timeout: 10 * 1000 });
-    }
-    const { terminate, processHasExited } = execRunScript({
-        async onFailure(err) {
-            (0, utils_2.assert)(processHasExited());
-            rejectServerStart(err);
-        },
-        onExit() {
-            (0, utils_2.assert)(processHasExited());
-            const exitIsPossible = hasSuccessfullyStarted === true || hasTimedout;
-            return exitIsPossible;
-        },
-        async onStdout(data) {
-            const log = (0, strip_ansi_1.default)(data);
-            const isServerReady = 
-            // Custom
-            (typeof serverIsReadyMessage === 'string' && log.includes(serverIsReadyMessage)) ||
-                ((0, utils_1.isCallable)(serverIsReadyMessage) && serverIsReadyMessage(log)) ||
-                // Express.js server
-                log.includes('Server running at') ||
+async function startProcess({ serverIsReadyMessage, serverIsReadyDelay, additionalTimeout, cmd, }) {
+    const cwd = (0, getCurrentTest_1.getCwd)();
+    if (!serverIsReadyMessage) {
+        serverIsReadyMessage = (log) => {
+            const serverIsReady = 
+            // Express.js server
+            log.includes('Server running at') ||
                 // npm package `serve`
                 log.includes('Accepting connections at') ||
                 // Vite
                 (log.includes('Local:') && log.includes('http://localhost:3000/'));
-            if (isServerReady) {
-                (0, utils_2.assert)(serverIsReadyDelay);
-                await (0, utils_1.sleep)(serverIsReadyDelay);
-                resolveServerStart();
-                done();
-            }
-        },
-    });
-    return promise;
-}
-function stopProcess({ proc, cwd, cmd, force, }) {
-    const prefix = `[Run Stop][${cwd}][${cmd}]`;
-    let resolve;
-    let reject;
-    const promise = new Promise((_resolve, _reject) => {
-        resolve = _resolve;
-        reject = _reject;
-    });
-    const onProcessClose = (code) => {
-        if (code === 0 || code === null || (code === 1 && (0, utils_1.isWindows)())) {
-            resolve();
-        }
-        else {
-            reject(new Error(`${prefix} Terminated with non-0 error code ${code}`));
-        }
-    };
-    proc.on('close', onProcessClose);
-    proc.on('exit', onProcessClose);
-    if ((0, utils_1.isWindows)()) {
-        // - https://github.com/nodejs/node/issues/3617#issuecomment-377731194
-        // - https://stackoverflow.com/questions/23706055/why-can-i-not-kill-my-child-process-in-nodejs-on-windows/28163919#28163919
-        // - taskkill seems to be buggy in many ways:
-        //   - taskkill seems to make the process exit with code `1`
-        //   - Because process exits with code `1`, Node.js/npm complains:
-        //     ```
-        //     [15:36:10.626][\examples\react][npm run preview][stderr] npm
-        //     [15:36:10.626][\examples\react][npm run preview][stderr]
-        //     [15:36:10.626][\examples\react][npm run preview][stderr] ERR!
-        //     [15:36:10.626][\examples\react][npm run preview][stderr]
-        //     [15:36:10.626][\examples\react][npm run preview][stderr] code
-        //     [15:36:10.626][\examples\react][npm run preview][stderr] ELIFECYCLE
-        //     ```
-        //     Because stderr isn't empty, runTests() believes that the termination failed.
-        //   - taskkill sometimes throws:
-        //     ```
-        //     ERROR: The process with PID 6052 (child process of PID 3184) could not be terminated.
-        //     Reason: There is no running instance of the task.
-        //     ```
-        //     ```
-        //     ERROR: The process "6564" not found.
-        //     ```
-        //     There doesn't seem to be an option to suppress these errors: https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/taskkill#parameters
-        (0, child_process_1.spawn)('taskkill', ['/pid', String(proc.pid), '/f', '/t'], {
-            stdio: [
-                'ignore',
-                // Ignore following log to avoid polluting non-error logs. (Setting 'inherit' instead of 'ignore' attaches stdout to the root process and not to `proc` which is why the stdout of taskkill isn't intercepted by `proc.stdout.on('data', () => /* ... */)`.)
-                // ```
-                // SUCCESS: The process with PID 6932 (child process of PID 2744) has been terminated.
-                // ```
-                'ignore',
-                // Ignoring stderr doesn't solve the problem that taskkill makes the process exit with code 1
-                'inherit', // stderr
-            ],
-        });
-    }
-    else {
-        (0, utils_2.assert)(proc.pid);
-        const processGroup = -1 * proc.pid;
-        const signal = force ? 'SIGKILL' : 'SIGTERM';
-        process.kill(processGroup, signal);
-        /*
-          try {
-            process.kill(-proc.pid, signal)
-          } catch (err: unknown) {
-            // ESRCH: No process or process group can be found corresponding to that specified by pid.
-            //  => probably means that the process was killed already.
-            if (typeof err === 'object' && err !== null && 'code' in err && err['code'] === 'ESRCH') {
-              printLog('stdout', '=============== swallowError')
-              return
-            } else {
-              printLog('stdout', '=============== no swallowError')
-              throw err
-            }
-          }
-          */
-    }
-    return promise;
-}
-function execRunScript({ onStdout, onFailure, onExit, }) {
-    const { cwd, cmd } = getRunInfo();
-    let [command, ...args] = cmd.split(' ');
-    let detached = true;
-    if ((0, utils_1.isWindows)()) {
-        detached = false;
-        if (command === 'npm' || command === 'pnpm') {
-            command = command + '.cmd';
-        }
+            return serverIsReady;
+        };
     }
-    Logs_1.Logs.add({
+    Logs_2.Logs.add({
         logSource: 'run()',
         logText: `Spawn command \`${cmd}\``,
     });
-    const proc = (0, child_process_1.spawn)(command, args, { cwd, detached });
-    let procExited = false;
-    const exitAndFail = async (err) => {
-        Logs_1.Logs.add({
-            logText: err.message,
-            logSource: 'run() failure',
-        });
-        await terminate(true);
-        onFailure(err);
-    };
-    proc.stdin.on('data', async (chunk) => {
-        const data = String(chunk);
-        await exitAndFail(new Error(`Command is \`${cmd}\` (${cwd}) is invoking \`stdin\`: ${data}.`));
-    });
-    proc.stdout.on('data', (chunk) => {
-        const data = String(chunk);
-        Logs_1.Logs.add({
-            logSource: 'stdout',
-            logText: data,
-            loggedAfterExit: procExited,
-        });
-        onStdout?.(data);
-    });
-    proc.stderr.on('data', async (chunk) => {
-        const data = String(chunk);
-        Logs_1.Logs.add({
-            logSource: 'stderr',
-            logText: data,
-            loggedAfterExit: procExited,
-        });
-        if (data.includes('EADDRINUSE')) {
-            await exitAndFail(new Error('Port conflict? Port already in use EADDRINUSE.'));
-        }
-    });
-    let exitPromiseResolve;
-    const exitPromise = new Promise((r) => (exitPromiseResolve = r));
-    proc.on('exit', (code) => {
-        procExited = true;
-        (0, utils_2.assert)(getRunInfo().cmd === cmd);
-        const exitIsPossible = onExit();
-        const isSuccessCode = [0, null].includes(code) || ((0, utils_1.isWindows)() && code === 1);
-        const isExpected = isSuccessCode && exitIsPossible;
-        if (!isExpected) {
-            const errMsg = `Unexpected premature process termination, exit code: ${code}`;
-            Logs_1.Logs.add({
-                logText: errMsg,
-                logSource: 'run() failure',
+    const done = (0, utils_1.logProgress)(`[run] ${cmd}`);
+    const { terminate, isReadyPromise } = (0, utils_1.runCommandLongRunning)({
+        cmd,
+        cwd,
+        isReadyLog: serverIsReadyMessage,
+        isReadyTimeout: TIMEOUTS_1.TIMEOUT_NPM_SCRIPT + additionalTimeout,
+        killPort: process.env.CI || !(0, utils_1.isLinux)() ? false : getServerPort(),
+        onStderr(data, { loggedAfterExit }) {
+            Logs_2.Logs.add({
+                logSource: 'stderr',
+                logText: data,
+                loggedAfterExit,
             });
-            onFailure(new Error(errMsg));
-        }
-        else {
-            Logs_1.Logs.add({
-                logText: `Process termination. (Nominal, exit code: ${code}.)`,
-                logSource: 'run()',
+        },
+        onStdout(data, { loggedAfterExit }) {
+            Logs_2.Logs.add({
+                logSource: 'stdout',
+                logText: data,
+                loggedAfterExit,
             });
-        }
-        exitPromiseResolve();
-    });
-    return { terminate, processHasExited };
-    function processHasExited() {
-        return procExited;
-    }
-    async function terminate(force) {
-        let resolve;
-        let reject;
-        const promise = new Promise((_resolve, _reject) => {
-            resolve = () => {
-                _resolve();
-            };
-            reject = () => {
-                _reject();
-            };
-        });
-        const timeout = setTimeout(() => {
-            const errMsg = 'Process termination timeout. Cmd: ' + cmd;
-            Logs_1.Logs.add({
+        },
+        onExit(errMsg) {
+            if (!errMsg) {
+                Logs_2.Logs.add({
+                    logSource: 'run()',
+                    logText: `Process termination (expected)`,
+                });
+            }
+            else {
+                Logs_2.Logs.add({
+                    logSource: 'run() failure',
+                    logText: errMsg,
+                });
+            }
+        },
+        onTerminationError(errMsg) {
+            Logs_2.Logs.add({
                 logSource: 'run() failure',
                 logText: errMsg,
             });
-            /* Don't interrupt the test runner, as the test runner may recover thanks to the process-killing-by-port
-            reject(new Error(errMsg))
-            */
-            resolve();
-        }, TIMEOUT_PROCESS_TERMINATION);
-        (0, utils_2.assert)(proc);
-        try {
-            await stopProcess({
-                proc,
-                cwd,
-                cmd,
-                force,
-            });
-        }
-        catch (err) {
-            Logs_1.Logs.add({
-                logSource: 'run() failure',
-                logText: String(err),
-            });
-        }
-        clearTimeout(timeout);
-        await exitPromise;
-        resolve();
-        return promise;
+        },
+        terminationTimeout: TIMEOUTS_1.TIMEOUT_PROCESS_TERMINATION,
+    });
+    let err;
+    try {
+        await isReadyPromise;
     }
-}
-async function autoRetry(test, { timeout = TIMEOUT_AUTORETRY } = {}) {
-    const period = 100;
-    const numberOfTries = timeout / period;
-    let i = 0;
-    while (true) {
-        try {
-            await test();
-            return;
-        }
-        catch (err) {
-            i = i + 1;
-            if (i > numberOfTries) {
-                throw err;
-            }
-        }
-        await (0, utils_1.sleep)(period);
+    catch (err_) {
+        err = err_;
+        (0, utils_2.assert)(err);
     }
+    done(!!err);
+    if (err)
+        throw err;
+    Logs_2.Logs.add({
+        logSource: 'run()',
+        logText: 'Server is ready.',
+    });
+    await (0, utils_1.sleep)(serverIsReadyDelay);
+    return { terminate };
 }
-exports.autoRetry = autoRetry;
 async function fetchHtml(pathname) {
     const response = await fetch(getServerUrl() + pathname);
     const html = await response.text();
@@ -443,7 +212,7 @@ async function fetch(...args) {
         return await (0, node_fetch_1.default)(...args);
     }
     catch (err) {
-        Logs_1.Logs.add({
+        Logs_2.Logs.add({
             logSource: 'Connection Error',
             logText: `Couldn't connect to \`${args[0]}\`. Args: \`${JSON.stringify(args.slice(1))}\`. Err: \`${
             // @ts-ignore
@@ -480,20 +249,16 @@ function isMinNodeVersion(minNodeVersion) {
     return major >= minNodeVersion;
 }
 exports.isMinNodeVersion = isMinNodeVersion;
-function getCwd() {
-    const { testFile } = (0, getCurrentTest_1.getCurrentTest)();
-    const cwd = (0, path_1.dirname)(testFile);
-    return cwd;
-}
 function getServerUrl() {
     const testInfo = (0, getCurrentTest_1.getCurrentTest)();
     const serverUrl = testInfo.runInfo?.serverUrl;
     return serverUrl;
 }
 exports.getServerUrl = getServerUrl;
-function getPort() {
+function getServerPort() {
     const serverUrl = getServerUrl();
-    const port = serverUrl.split(':').slice(-1)[0].split('/')[0];
-    (0, utils_2.assert)(/\d+/.test(port), { serverUrl });
+    const portStr = serverUrl.split(':').slice(-1)[0].split('/')[0];
+    (0, utils_2.assert)(/\d+/.test(portStr), { serverUrl });
+    const port = parseInt(portStr, 10);
     return port;
 }

package/dist/testScreenshotFixture.js

@@ -82,6 +82,6 @@ function getPngPaths() {
 function getTestFileDir() {
     const { testFile, runInfo } = (0, getCurrentTest_1.getCurrentTest)();
     const cwd = path_1.default.dirname(testFile);
-    (0, utils_1.assert)(runInfo.cwd === cwd);
+    (0, utils_1.assert)(cwd === (0, getCurrentTest_1.getCwd)());
     return cwd;
 }

package/dist/utils/findFiles.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findFilesParseCliArgs = exports.findFiles = void 0;
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const path_1 = __importDefault(require("path"));
-const runCommand_1 = require("./runCommand");
+const runCommandShortLived_1 = require("./runCommandShortLived");
 const cwd = process.cwd();
 let gitFiles;
 async function findFiles(pattern, findFilter) {
@@ -19,11 +19,11 @@ async function findFiles(pattern, findFilter) {
 exports.findFiles = findFiles;
 async function filterGitIgnoredFiles(files) {
     if (!gitFiles) {
-        const stdout1 = await (0, runCommand_1.runCommand)('git ls-files', { cwd });
+        const stdout1 = await (0, runCommandShortLived_1.runCommandShortLived)('git ls-files', { cwd });
         // Also include untracked files.
         //  - In other words, we remove git ignored files. (Staged files are tracked and listed by `$ git ls-files`.)
         //  - `git ls-files --others --exclude-standard` from https://stackoverflow.com/questions/3801321/git-list-only-untracked-files-also-custom-commands/3801554#3801554
-        const stdout2 = await (0, runCommand_1.runCommand)('git ls-files --others --exclude-standard', { cwd });
+        const stdout2 = await (0, runCommandShortLived_1.runCommandShortLived)('git ls-files --others --exclude-standard', { cwd });
         gitFiles = [...stdout1.split('\n'), ...stdout2.split('\n')].map((filePathRelative) => path_1.default.join(cwd, filePathRelative));
     }
     const filesFiltered = files.filter((file) => gitFiles.includes(file));

package/dist/utils/genPromise.d.ts

@@ -0,0 +1,5 @@
+export declare function genPromise<T = undefined>(): {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (value?: Error) => void;
+};

package/dist/utils/genPromise.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genPromise = void 0;
+function genPromise() {
+    let resolve;
+    let reject;
+    const promise = new Promise((resolve_, reject_) => {
+        resolve = resolve_;
+        reject = reject_;
+    });
+    return { promise, resolve, reject };
+}
+exports.genPromise = genPromise;

package/dist/utils/humanizeTime.d.ts

@@ -1,2 +1,2 @@
 export { humanizeTime };
-declare function humanizeTime(milliseconds: number): string;
+declare function humanizeTime(milliseconds: number): `${string} seconds` | `${string} minutes`;

package/dist/utils/index.d.ts

@@ -1,5 +1,7 @@
 export * from './sleep';
 export * from './runCommand';
+export * from './runCommandShortLived';
+export * from './runCommandLongRunning';
 export * from './assert';
 export * from './humanizeTime';
 export * from './isTTY';

package/dist/utils/index.js

@@ -16,6 +16,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./sleep"), exports);
 __exportStar(require("./runCommand"), exports);
+__exportStar(require("./runCommandShortLived"), exports);
+__exportStar(require("./runCommandLongRunning"), exports);
 __exportStar(require("./assert"), exports);
 __exportStar(require("./humanizeTime"), exports);
 __exportStar(require("./isTTY"), exports);

package/dist/utils/runCommand.d.ts

@@ -1,6 +1,5 @@
 export { runCommand };
-declare function runCommand(cmd: string, { swallowError, timeout, cwd, }?: {
-    swallowError?: boolean;
-    timeout?: number;
-    cwd?: string;
-}): Promise<string>;
+declare function runCommand(cmd: string, { timeout, cwd }: {
+    timeout: number;
+    cwd: string;
+}): Promise<void>;