Updated the files.

my-app/node_modules/foreground-child/dist/mjs/all-signals.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export declare const allSignals: NodeJS.Signals[];
+//# sourceMappingURL=all-signals.d.ts.map

my-app/node_modules/foreground-child/dist/mjs/all-signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"all-signals.d.ts","sourceRoot":"","sources":["../../src/all-signals.ts"],"names":[],"mappings":";AACA,eAAO,MAAM,UAAU,kBASA,CAAA"}

my-app/node_modules/foreground-child/dist/mjs/all-signals.js

@@ -0,0 +1,52 @@
+import constants from 'node:constants';
+export const allSignals = 
+// this is the full list of signals that Node will let us do anything with
+Object.keys(constants).filter(k => k.startsWith('SIG') &&
+    // https://github.com/tapjs/signal-exit/issues/21
+    k !== 'SIGPROF' &&
+    // no sense trying to listen for SIGKILL, it's impossible
+    k !== 'SIGKILL');
+// These are some obscure signals that are reported by kill -l
+// on macOS, Linux, or Windows, but which don't have any mapping
+// in Node.js. No sense trying if they're just going to throw
+// every time on every platform.
+//
+// 'SIGEMT',
+// 'SIGLOST',
+// 'SIGPOLL',
+// 'SIGRTMAX',
+// 'SIGRTMAX-1',
+// 'SIGRTMAX-10',
+// 'SIGRTMAX-11',
+// 'SIGRTMAX-12',
+// 'SIGRTMAX-13',
+// 'SIGRTMAX-14',
+// 'SIGRTMAX-15',
+// 'SIGRTMAX-2',
+// 'SIGRTMAX-3',
+// 'SIGRTMAX-4',
+// 'SIGRTMAX-5',
+// 'SIGRTMAX-6',
+// 'SIGRTMAX-7',
+// 'SIGRTMAX-8',
+// 'SIGRTMAX-9',
+// 'SIGRTMIN',
+// 'SIGRTMIN+1',
+// 'SIGRTMIN+10',
+// 'SIGRTMIN+11',
+// 'SIGRTMIN+12',
+// 'SIGRTMIN+13',
+// 'SIGRTMIN+14',
+// 'SIGRTMIN+15',
+// 'SIGRTMIN+16',
+// 'SIGRTMIN+2',
+// 'SIGRTMIN+3',
+// 'SIGRTMIN+4',
+// 'SIGRTMIN+5',
+// 'SIGRTMIN+6',
+// 'SIGRTMIN+7',
+// 'SIGRTMIN+8',
+// 'SIGRTMIN+9',
+// 'SIGSTKFLT',
+// 'SIGUNUSED',
+//# sourceMappingURL=all-signals.js.map

my-app/node_modules/foreground-child/dist/mjs/all-signals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"all-signals.js","sourceRoot":"","sources":["../../src/all-signals.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,gBAAgB,CAAA;AACtC,MAAM,CAAC,MAAM,UAAU;AACrB,0EAA0E;AAC1E,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,CAC3B,CAAC,CAAC,EAAE,CACF,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC;IACnB,iDAAiD;IACjD,CAAC,KAAK,SAAS;IACf,yDAAyD;IACzD,CAAC,KAAK,SAAS,CACE,CAAA;AAEvB,8DAA8D;AAC9D,gEAAgE;AAChE,6DAA6D;AAC7D,gCAAgC;AAChC,EAAE;AACF,YAAY;AACZ,aAAa;AACb,aAAa;AACb,cAAc;AACd,gBAAgB;AAChB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,cAAc;AACd,gBAAgB;AAChB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,eAAe;AACf,eAAe","sourcesContent":["import constants from 'node:constants'\nexport const allSignals =\n  // this is the full list of signals that Node will let us do anything with\n  Object.keys(constants).filter(\n    k =>\n      k.startsWith('SIG') &&\n      // https://github.com/tapjs/signal-exit/issues/21\n      k !== 'SIGPROF' &&\n      // no sense trying to listen for SIGKILL, it's impossible\n      k !== 'SIGKILL'\n  ) as NodeJS.Signals[]\n\n// These are some obscure signals that are reported by kill -l\n// on macOS, Linux, or Windows, but which don't have any mapping\n// in Node.js. No sense trying if they're just going to throw\n// every time on every platform.\n//\n// 'SIGEMT',\n// 'SIGLOST',\n// 'SIGPOLL',\n// 'SIGRTMAX',\n// 'SIGRTMAX-1',\n// 'SIGRTMAX-10',\n// 'SIGRTMAX-11',\n// 'SIGRTMAX-12',\n// 'SIGRTMAX-13',\n// 'SIGRTMAX-14',\n// 'SIGRTMAX-15',\n// 'SIGRTMAX-2',\n// 'SIGRTMAX-3',\n// 'SIGRTMAX-4',\n// 'SIGRTMAX-5',\n// 'SIGRTMAX-6',\n// 'SIGRTMAX-7',\n// 'SIGRTMAX-8',\n// 'SIGRTMAX-9',\n// 'SIGRTMIN',\n// 'SIGRTMIN+1',\n// 'SIGRTMIN+10',\n// 'SIGRTMIN+11',\n// 'SIGRTMIN+12',\n// 'SIGRTMIN+13',\n// 'SIGRTMIN+14',\n// 'SIGRTMIN+15',\n// 'SIGRTMIN+16',\n// 'SIGRTMIN+2',\n// 'SIGRTMIN+3',\n// 'SIGRTMIN+4',\n// 'SIGRTMIN+5',\n// 'SIGRTMIN+6',\n// 'SIGRTMIN+7',\n// 'SIGRTMIN+8',\n// 'SIGRTMIN+9',\n// 'SIGSTKFLT',\n// 'SIGUNUSED',\n"]}

my-app/node_modules/foreground-child/dist/mjs/index.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ChildProcess, SpawnOptions } from 'child_process';
+/**
+ * The signature for the cleanup method.
+ *
+ * Arguments indicate the exit status of the child process.
+ *
+ * If a Promise is returned, then the process is not terminated
+ * until it resolves, and the resolution value is treated as the
+ * exit status (if a number) or signal exit (if a signal string).
+ *
+ * If `undefined` is returned, then no change is made, and the parent
+ * exits in the same way that the child exited.
+ *
+ * If boolean `false` is returned, then the parent's exit is canceled.
+ *
+ * If a number is returned, then the parent process exits with the number
+ * as its exitCode.
+ *
+ * If a signal string is returned, then the parent process is killed with
+ * the same signal that caused the child to exit.
+ */
+export type Cleanup = (code: number | null, signal: null | NodeJS.Signals) => void | undefined | number | NodeJS.Signals | false | Promise<void | undefined | number | NodeJS.Signals | false>;
+export type FgArgs = [program: string | string[], cleanup?: Cleanup] | [program: string[], opts?: SpawnOptions, cleanup?: Cleanup] | [program: string, cleanup?: Cleanup] | [program: string, opts?: SpawnOptions, cleanup?: Cleanup] | [program: string, args?: string[], cleanup?: Cleanup] | [
+    program: string,
+    args?: string[],
+    opts?: SpawnOptions,
+    cleanup?: Cleanup
+];
+/**
+ * Normalizes the arguments passed to `foregroundChild`.
+ *
+ * Exposed for testing.
+ *
+ * @internal
+ */
+export declare const normalizeFgArgs: (fgArgs: FgArgs) => [program: string, args: string[], spawnOpts: SpawnOptions, cleanup: Cleanup];
+/**
+ * Spawn the specified program as a "foreground" process, or at least as
+ * close as is possible given node's lack of exec-without-fork.
+ *
+ * Cleanup method may be used to modify or ignore the result of the child's
+ * exit code or signal. If cleanup returns undefined (or a Promise that
+ * resolves to undefined), then the parent will exit in the same way that
+ * the child did.
+ *
+ * Return boolean `false` to prevent the parent's exit entirely.
+ */
+export declare function foregroundChild(cmd: string | string[], cleanup?: Cleanup): ChildProcess;
+export declare function foregroundChild(program: string, args?: string[], cleanup?: Cleanup): ChildProcess;
+export declare function foregroundChild(program: string, spawnOpts?: SpawnOptions, cleanup?: Cleanup): ChildProcess;
+export declare function foregroundChild(program: string, args?: string[], spawnOpts?: SpawnOptions, cleanup?: Cleanup): ChildProcess;
+//# sourceMappingURL=index.d.ts.map

my-app/node_modules/foreground-child/dist/mjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;AAAA,OAAO,EACL,YAAY,EAIZ,YAAY,EACb,MAAM,eAAe,CAAA;AAUtB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,OAAO,GAAG,CACpB,IAAI,EAAE,MAAM,GAAG,IAAI,EACnB,MAAM,EAAE,IAAI,GAAG,MAAM,CAAC,OAAO,KAE3B,IAAI,GACJ,SAAS,GACT,MAAM,GACN,MAAM,CAAC,OAAO,GACd,KAAK,GACL,OAAO,CAAC,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC,OAAO,GAAG,KAAK,CAAC,CAAA;AAE/D,MAAM,MAAM,MAAM,GACd,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,GAC/C,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,GAC3D,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,GACpC,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,GACzD,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,GACrD;IACE,OAAO,EAAE,MAAM;IACf,IAAI,CAAC,EAAE,MAAM,EAAE;IACf,IAAI,CAAC,EAAE,YAAY;IACnB,OAAO,CAAC,EAAE,OAAO;CAClB,CAAA;AAEL;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,WAClB,MAAM,iFA0Bf,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,EACtB,OAAO,CAAC,EAAE,OAAO,GAChB,YAAY,CAAA;AACf,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM,EAAE,EACf,OAAO,CAAC,EAAE,OAAO,GAChB,YAAY,CAAA;AACf,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,YAAY,EACxB,OAAO,CAAC,EAAE,OAAO,GAChB,YAAY,CAAA;AACf,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM,EAAE,EACf,SAAS,CAAC,EAAE,YAAY,EACxB,OAAO,CAAC,EAAE,OAAO,GAChB,YAAY,CAAA"}

my-app/node_modules/foreground-child/dist/mjs/index.js

@@ -0,0 +1,146 @@
+import { spawn as nodeSpawn, } from 'child_process';
+import crossSpawn from 'cross-spawn';
+import { onExit } from 'signal-exit';
+import { allSignals } from './all-signals.js';
+import { watchdog } from './watchdog.js';
+/* c8 ignore start */
+const spawn = process?.platform === 'win32' ? crossSpawn : nodeSpawn;
+/**
+ * Normalizes the arguments passed to `foregroundChild`.
+ *
+ * Exposed for testing.
+ *
+ * @internal
+ */
+export const normalizeFgArgs = (fgArgs) => {
+    let [program, args = [], spawnOpts = {}, cleanup = () => { }] = fgArgs;
+    if (typeof args === 'function') {
+        cleanup = args;
+        spawnOpts = {};
+        args = [];
+    }
+    else if (!!args && typeof args === 'object' && !Array.isArray(args)) {
+        if (typeof spawnOpts === 'function')
+            cleanup = spawnOpts;
+        spawnOpts = args;
+        args = [];
+    }
+    else if (typeof spawnOpts === 'function') {
+        cleanup = spawnOpts;
+        spawnOpts = {};
+    }
+    if (Array.isArray(program)) {
+        const [pp, ...pa] = program;
+        program = pp;
+        args = pa;
+    }
+    return [program, args, { ...spawnOpts }, cleanup];
+};
+export function foregroundChild(...fgArgs) {
+    const [program, args, spawnOpts, cleanup] = normalizeFgArgs(fgArgs);
+    spawnOpts.stdio = [0, 1, 2];
+    if (process.send) {
+        spawnOpts.stdio.push('ipc');
+    }
+    const child = spawn(program, args, spawnOpts);
+    const unproxySignals = proxySignals(child);
+    const childHangup = () => {
+        try {
+            child.kill('SIGHUP');
+            /* c8 ignore start */
+        }
+        catch (_) {
+            // SIGHUP is weird on windows
+            child.kill('SIGTERM');
+        }
+        /* c8 ignore stop */
+    };
+    const removeOnExit = onExit(childHangup);
+    const dog = watchdog(child);
+    let done = false;
+    child.on('close', async (code, signal) => {
+        dog.kill('SIGKILL');
+        /* c8 ignore start */
+        if (done) {
+            return;
+        }
+        /* c8 ignore stop */
+        done = true;
+        const result = cleanup(code, signal);
+        const res = isPromise(result) ? await result : result;
+        removeOnExit();
+        unproxySignals();
+        if (res === false)
+            return;
+        else if (typeof res === 'string') {
+            signal = res;
+            code = null;
+        }
+        else if (typeof res === 'number') {
+            code = res;
+            signal = null;
+        }
+        if (signal) {
+            // If there is nothing else keeping the event loop alive,
+            // then there's a race between a graceful exit and getting
+            // the signal to this process.  Put this timeout here to
+            // make sure we're still alive to get the signal, and thus
+            // exit with the intended signal code.
+            /* istanbul ignore next */
+            setTimeout(() => { }, 2000);
+            try {
+                process.kill(process.pid, signal);
+                /* c8 ignore start */
+            }
+            catch (_) {
+                process.kill(process.pid, 'SIGTERM');
+            }
+            /* c8 ignore stop */
+        }
+        else {
+            process.exit(code || 0);
+        }
+    });
+    if (process.send) {
+        process.removeAllListeners('message');
+        child.on('message', (message, sendHandle) => {
+            process.send?.(message, sendHandle);
+        });
+        process.on('message', (message, sendHandle) => {
+            child.send(message, sendHandle);
+        });
+    }
+    return child;
+}
+/**
+ * Starts forwarding signals to `child` through `parent`.
+ */
+const proxySignals = (child) => {
+    const listeners = new Map();
+    for (const sig of allSignals) {
+        const listener = () => {
+            // some signals can only be received, not sent
+            try {
+                child.kill(sig);
+                /* c8 ignore start */
+            }
+            catch (_) { }
+            /* c8 ignore stop */
+        };
+        try {
+            // if it's a signal this system doesn't recognize, skip it
+            process.on(sig, listener);
+            listeners.set(sig, listener);
+            /* c8 ignore start */
+        }
+        catch (_) { }
+        /* c8 ignore stop */
+    }
+    return () => {
+        for (const [sig, listener] of listeners) {
+            process.removeListener(sig, listener);
+        }
+    };
+};
+const isPromise = (o) => !!o && typeof o === 'object' && typeof o.then === 'function';
+//# sourceMappingURL=index.js.map

my-app/node_modules/foreground-child/dist/mjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

my-app/node_modules/foreground-child/dist/mjs/watchdog.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { ChildProcess } from 'child_process';
+export declare const watchdog: (child: ChildProcess) => ChildProcess;
+//# sourceMappingURL=watchdog.d.ts.map

my-app/node_modules/foreground-child/dist/mjs/watchdog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchdog.d.ts","sourceRoot":"","sources":["../../src/watchdog.ts"],"names":[],"mappings":";AAIA,OAAO,EAAE,YAAY,EAAS,MAAM,eAAe,CAAA;AAyBnD,eAAO,MAAM,QAAQ,UAAW,YAAY,iBAc3C,CAAA"}

my-app/node_modules/foreground-child/dist/mjs/watchdog.js

@@ -0,0 +1,39 @@
+// this spawns a child process that listens for SIGHUP when the
+// parent process exits, and after 200ms, sends a SIGKILL to the
+// child, in case it did not terminate.
+import { spawn } from 'child_process';
+const watchdogCode = String.raw `
+const pid = parseInt(process.argv[1], 10)
+process.title = 'node (foreground-child watchdog pid=' + pid + ')'
+if (!isNaN(pid)) {
+  let barked = false
+  // keepalive
+  const interval = setInterval(() => {}, 60000)
+  const bark = () => {
+    clearInterval(interval)
+    if (barked) return
+    barked = true
+    process.removeListener('SIGHUP', bark)
+    setTimeout(() => {
+      try {
+        process.kill(pid, 'SIGKILL')
+        setTimeout(() => process.exit(), 200)
+      } catch (_) {}
+    }, 500)
+  })
+  process.on('SIGHUP', bark)
+}
+`;
+export const watchdog = (child) => {
+    let dogExited = false;
+    const dog = spawn(process.execPath, ['-e', watchdogCode, String(child.pid)], {
+        stdio: 'ignore',
+    });
+    dog.on('exit', () => (dogExited = true));
+    child.on('exit', () => {
+        if (!dogExited)
+            dog.kill('SIGTERM');
+    });
+    return dog;
+};
+//# sourceMappingURL=watchdog.js.map

my-app/node_modules/foreground-child/dist/mjs/watchdog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchdog.js","sourceRoot":"","sources":["../../src/watchdog.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,gEAAgE;AAChE,uCAAuC;AAEvC,OAAO,EAAgB,KAAK,EAAE,MAAM,eAAe,CAAA;AAEnD,MAAM,YAAY,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;CAqB9B,CAAA;AAED,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,KAAmB,EAAE,EAAE;IAC9C,IAAI,SAAS,GAAG,KAAK,CAAA;IACrB,MAAM,GAAG,GAAG,KAAK,CACf,OAAO,CAAC,QAAQ,EAChB,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EACvC;QACE,KAAK,EAAE,QAAQ;KAChB,CACF,CAAA;IACD,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,CAAA;IACxC,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE;QACpB,IAAI,CAAC,SAAS;YAAE,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;IACrC,CAAC,CAAC,CAAA;IACF,OAAO,GAAG,CAAA;AACZ,CAAC,CAAA","sourcesContent":["// this spawns a child process that listens for SIGHUP when the\n// parent process exits, and after 200ms, sends a SIGKILL to the\n// child, in case it did not terminate.\n\nimport { ChildProcess, spawn } from 'child_process'\n\nconst watchdogCode = String.raw`\nconst pid = parseInt(process.argv[1], 10)\nprocess.title = 'node (foreground-child watchdog pid=' + pid + ')'\nif (!isNaN(pid)) {\n  let barked = false\n  // keepalive\n  const interval = setInterval(() => {}, 60000)\n  const bark = () => {\n    clearInterval(interval)\n    if (barked) return\n    barked = true\n    process.removeListener('SIGHUP', bark)\n    setTimeout(() => {\n      try {\n        process.kill(pid, 'SIGKILL')\n        setTimeout(() => process.exit(), 200)\n      } catch (_) {}\n    }, 500)\n  })\n  process.on('SIGHUP', bark)\n}\n`\n\nexport const watchdog = (child: ChildProcess) => {\n  let dogExited = false\n  const dog = spawn(\n    process.execPath,\n    ['-e', watchdogCode, String(child.pid)],\n    {\n      stdio: 'ignore',\n    }\n  )\n  dog.on('exit', () => (dogExited = true))\n  child.on('exit', () => {\n    if (!dogExited) dog.kill('SIGTERM')\n  })\n  return dog\n}\n"]}