1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
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
|
