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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
const os = require('os')
const log = require('./log-shim.js')
const errorMessage = require('./error-message.js')
const replaceInfo = require('./replace-info.js')
const messageText = msg => msg.map(line => line.slice(1).join(' ')).join('\n')
let npm = null // set by the cli
let exitHandlerCalled = false
let showLogFileMessage = false
process.on('exit', code => {
log.disableProgress()
// process.emit is synchronous, so the timeEnd handler will run before the
// unfinished timer check below
process.emit('timeEnd', 'npm')
const hasNpm = !!npm
const hasLoadedNpm = hasNpm && npm.config.loaded
// Unfinished timers can be read before config load
if (hasNpm) {
for (const [name, timer] of npm.unfinishedTimers) {
log.verbose('unfinished npm timer', name, timer)
}
}
if (!code) {
log.info('ok')
} else {
log.verbose('code', code)
}
if (!exitHandlerCalled) {
process.exitCode = code || 1
log.error('', 'Exit handler never called!')
console.error('')
log.error('', 'This is an error with npm itself. Please report this error at:')
log.error('', ' <https://github.com/npm/cli/issues>')
showLogFileMessage = true
}
// In timing mode we always show the log file message
if (hasLoadedNpm && npm.config.get('timing')) {
showLogFileMessage = true
}
// npm must be loaded to know where the log file was written
if (showLogFileMessage && hasLoadedNpm) {
// just a line break
if (log.levels[log.level] <= log.levels.error) {
console.error('')
}
log.error(
'',
[
'A complete log of this run can be found in:',
...npm.logFiles.map(f => ' ' + f),
].join('\n')
)
}
// This removes any listeners npm setup and writes files if necessary
// This is mostly used for tests to avoid max listener warnings
if (hasLoadedNpm) {
npm.unload()
}
// these are needed for the tests to have a clean slate in each test case
exitHandlerCalled = false
showLogFileMessage = false
})
const exitHandler = err => {
exitHandlerCalled = true
log.disableProgress()
const hasNpm = !!npm
const hasLoadedNpm = hasNpm && npm.config.loaded
if (!hasNpm) {
err = err || new Error('Exit prior to setting npm in exit handler')
console.error(err.stack || err.message)
return process.exit(1)
}
if (!hasLoadedNpm) {
err = err || new Error('Exit prior to config file resolving.')
console.error(err.stack || err.message)
}
// only show the notification if it finished.
if (typeof npm.updateNotification === 'string') {
const { level } = log
log.level = 'notice'
log.notice('', npm.updateNotification)
log.level = level
}
let exitCode
let noLogMessage
if (err) {
exitCode = 1
// if we got a command that just shells out to something else, then it
// will presumably print its own errors and exit with a proper status
// code if there's a problem. If we got an error with a code=0, then...
// something else went wrong along the way, so maybe an npm problem?
const isShellout = npm.shelloutCommands.includes(npm.command)
const quietShellout = isShellout && typeof err.code === 'number' && err.code
if (quietShellout) {
exitCode = err.code
noLogMessage = true
} else if (typeof err === 'string') {
log.error('', err)
noLogMessage = true
} else if (!(err instanceof Error)) {
log.error('weird error', err)
noLogMessage = true
} else {
if (!err.code) {
const matchErrorCode = err.message.match(/^(?:Error: )?(E[A-Z]+)/)
err.code = matchErrorCode && matchErrorCode[1]
}
for (const k of ['type', 'stack', 'statusCode', 'pkgid']) {
const v = err[k]
if (v) {
log.verbose(k, replaceInfo(v))
}
}
const args = replaceInfo(process.argv)
log.verbose('cwd', process.cwd())
log.verbose('', os.type() + ' ' + os.release())
log.verbose('argv', args.map(JSON.stringify).join(' '))
log.verbose('node', process.version)
log.verbose('npm ', 'v' + npm.version)
for (const k of ['code', 'syscall', 'file', 'path', 'dest', 'errno']) {
const v = err[k]
if (v) {
log.error(k, v)
}
}
const msg = errorMessage(err, npm)
for (const errline of [...msg.summary, ...msg.detail]) {
log.error(...errline)
}
if (hasLoadedNpm && npm.config.get('json')) {
const error = {
error: {
code: err.code,
summary: messageText(msg.summary),
detail: messageText(msg.detail),
},
}
console.error(JSON.stringify(error, null, 2))
}
if (typeof err.errno === 'number') {
exitCode = err.errno
} else if (typeof err.code === 'number') {
exitCode = err.code
}
}
}
log.verbose('exit', exitCode || 0)
showLogFileMessage = log.level === 'silent' || noLogMessage
? false
: !!exitCode
// explicitly call process.exit now so we don't hang on things like the
// update notifier, also flush stdout beforehand because process.exit doesn't
// wait for that to happen.
process.stdout.write('', () => process.exit(exitCode))
}
module.exports = exitHandler
module.exports.setNpm = n => {
npm = n
}
|
