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
|
// 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.
if (module !== require.main) {
throw new Error('spawn-wrap: cli wrapper invoked as non-main script')
}
// require('fs').createWriteStream('/dev/tty').write('WRAP ' + process.argv.slice(2).join(' ') + '\n')
var Module = require('module')
var assert = require('assert')
var path = require('path')
var node = process.execPath
var settings = require('./settings.json')
var foregroundChild = require(settings.deps.foregroundChild)
var argv = settings.argv
var nargs = argv.length
var env = settings.env
for (var key in env) {
process.env[key] = env[key]
}
var 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 () {
process.argv.splice(1, nargs)
process.argv[1] = path.resolve(process.argv[1])
Module.runMain()
}
// 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
var hasMain = false
for (var a = 2; !hasMain && a < process.argv.length; a++) {
switch (process.argv[a]) {
case '-i':
case '--interactive':
case '--eval':
case '-e':
case '-pe':
hasMain = false
a = process.argv.length
continue
case '-r':
case '--require':
a += 1
continue
default:
if (process.argv[a].match(/^-/)) {
continue
} else {
hasMain = a
a = process.argv.length
break
}
}
}
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.
var 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.
var args = process.execArgv.concat(needExecArgv, process.argv.slice(2))
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) {
var pexec = process.execArgv
if (JSON.stringify(pexec) !== JSON.stringify(needExecArgv)) {
var spawn = require('child_process').spawn
var 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.
var 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
var isWindows = (
process.platform === 'win32' ||
process.env.OSTYPE === 'cygwin' ||
process.env.OSTYPE === 'msys'
)
if (isWindows) {
for (var i in process.env) {
if (i.match(/^path$/i)) {
process.env[i] = process.env[i].replace(__dirname + ';', '')
}
}
} else {
process.env.PATH = process.env.PATH.replace(__dirname + ':', '')
}
var spawnWrap = require(settings.module)
if (nargs) {
spawnWrap.runMain = runMain
}
spawnWrap(argv, env, __dirname)
Module.runMain()
|
