-
-
Notifications
You must be signed in to change notification settings - Fork 18
/
shim.js
184 lines (159 loc) · 5.36 KB
/
shim.js
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
'use strict'
// This module should *only* be loaded as a main script
// by child processes wrapped by spawn-wrap. It sets up
// argv to include the injected argv (including the user's
// wrapper script) and any environment variables specified.
//
// If any argv were passed in (ie, if it's used to force
// a wrapper script, and not just ensure that an env is kept
// around through all the child procs), then we also set up
// a require('spawn-wrap').runMain() function that will strip
// off the injected arguments and run the main file.
// wrap in iife for babylon to handle module-level return
;(function () {
if (module !== require.main) {
throw new Error('spawn-wrap: cli wrapper invoked as non-main script')
}
let util
const doDebug = process.env.SPAWN_WRAP_DEBUG === '1'
let fs
function debug () {
if (!doDebug) {
return
}
if (!fs) {
fs = require('fs')
util = require('util')
}
let message = util.format.apply(util, arguments).trim()
const pref = 'SW ' + process.pid + ': '
message = pref + message.split('\n').join('\n' + pref)
fs.writeSync(2, message + '\n')
}
debug('shim', [process.argv[0]].concat(process.execArgv, process.argv.slice(1)))
const Module = require('module')
const path = require('path')
const settings = require('./settings.json')
const foregroundChild = require(settings.deps.foregroundChild)
const argv = settings.argv
const nargs = argv.length
const env = settings.env
const key = settings.key
const node = process.env['SW_ORIG_' + key] || process.execPath
for (const k in env) {
process.env[k] = env[k]
}
const needExecArgv = settings.execArgv || []
// If the user added their OWN wrapper pre-load script, then
// this will pop that off of the argv, and load the "real" main
function runMain () {
debug('runMain pre', process.argv)
process.argv.splice(1, nargs)
process.argv[1] = path.resolve(process.argv[1])
delete require.cache[process.argv[1]]
debug('runMain post', process.argv)
Module.runMain()
debug('runMain after')
}
// Argv coming in looks like:
// bin shim execArgv main argv
//
// Turn it into:
// bin settings.execArgv execArgv settings.argv main argv
//
// If we don't have a main script, then just run with the necessary
// execArgv
let hasMain = false
for (let a = 2; !hasMain && a < process.argv.length; a++) {
switch (process.argv[a]) {
case '-i':
case '--interactive':
case '--eval':
case '-e':
case '-p':
case '-pe':
hasMain = false
a = process.argv.length
continue
case '-r':
case '--require':
a += 1
continue
default:
// TODO: Double-check what's going on
if (process.argv[a].match(/^-/)) {
continue
} else {
hasMain = a
a = process.argv.length
break
}
}
}
debug('after argv parse hasMain=%j', hasMain)
if (hasMain > 2) {
// if the main file is above #2, then it means that there
// was a --exec_arg *before* it. This means that we need
// to slice everything from 2 to hasMain, and pass that
// directly to node. This also splices out the user-supplied
// execArgv from the argv.
const addExecArgv = process.argv.splice(2, hasMain - 2)
needExecArgv.push.apply(needExecArgv, addExecArgv)
}
if (!hasMain) {
// we got loaded by mistake for a `node -pe script` or something.
const args = process.execArgv.concat(needExecArgv, process.argv.slice(2))
debug('no main file!', args)
foregroundChild(node, args)
return
}
// If there are execArgv, and they're not the same as how this module
// was executed, then we need to inject those. This is for stuff like
// --harmony or --use_strict that needs to be *before* the main
// module.
if (needExecArgv.length) {
const pexec = process.execArgv
if (JSON.stringify(pexec) !== JSON.stringify(needExecArgv)) {
debug('need execArgv for this', pexec, '=>', needExecArgv)
const sargs = pexec.concat(needExecArgv).concat(process.argv.slice(1))
foregroundChild(node, sargs)
return
}
}
// At this point, we've verified that we got the correct execArgv,
// and that we have a main file, and that the main file is sitting at
// argv[2]. Splice this shim off the list so it looks like the main.
const spliceArgs = [1, 1].concat(argv)
process.argv.splice.apply(process.argv, spliceArgs)
// Unwrap the PATH environment var so that we're not mucking
// with the environment. It'll get re-added if they spawn anything
const isWindows = (
// TODO: Use `lib/is-windows`
process.platform === 'win32' ||
process.env.OSTYPE === 'cygwin' ||
process.env.OSTYPE === 'msys'
)
if (isWindows) {
for (const i in process.env) {
if (/^path$/i.test(i)) {
process.env[i] = process.env[i].replace(__dirname + ';', '')
}
}
} else {
process.env.PATH = process.env.PATH.replace(__dirname + ':', '')
}
const spawnWrap = require(settings.module)
if (nargs) {
spawnWrap.runMain = function (original) {
return function () {
spawnWrap.runMain = original
runMain()
}
}(spawnWrap.runMain)
}
spawnWrap(argv, env, __dirname)
debug('shim runMain', process.argv)
delete require.cache[process.argv[1]]
Module.runMain()
// end iife wrapper for babylon
})()