@novolobos/nodevm 3.10.5

package/lib/builtin.js

@@ -0,0 +1,147 @@
+
+const fs = require('fs');
+const nmod = require('module');
+const {EventEmitter} = require('events');
+const util = require('util');
+const {VMScript} = require('./script');
+const {VM} = require('./vm');
+
+const eventsModules = new WeakMap();
+
+function defaultBuiltinLoaderEvents(vm) {
+	return eventsModules.get(vm);
+}
+
+let cacheBufferScript;
+
+function defaultBuiltinLoaderBuffer(vm) {
+	if (!cacheBufferScript) {
+		cacheBufferScript = new VMScript('return buffer=>({Buffer: buffer});', {__proto__: null, filename: 'buffer.js'});
+	}
+	const makeBuffer = vm.run(cacheBufferScript, {__proto__: null, strict: true, wrapper: 'none'});
+	return makeBuffer(Buffer);
+}
+
+let cacheUtilScript;
+
+function defaultBuiltinLoaderUtil(vm) {
+	if (!cacheUtilScript) {
+		cacheUtilScript = new VMScript(`return function inherits(ctor, superCtor) {
+			ctor.super_ = superCtor;
+			Object.setPrototypeOf(ctor.prototype, superCtor.prototype);
+		}`, {__proto__: null, filename: 'util.js'});
+	}
+	const inherits = vm.run(cacheUtilScript, {__proto__: null, strict: true, wrapper: 'none'});
+	const copy = Object.assign({}, util);
+	copy.inherits = inherits;
+	return vm.readonly(copy);
+}
+
+const BUILTIN_MODULES = (nmod.builtinModules || Object.getOwnPropertyNames(process.binding('natives'))).filter(s=>!s.startsWith('internal/'));
+
+let EventEmitterReferencingAsyncResourceClass = null;
+if (EventEmitter.EventEmitterAsyncResource) {
+	// eslint-disable-next-line global-require
+	const {AsyncResource} = require('async_hooks');
+	const kEventEmitter = Symbol('kEventEmitter');
+	class EventEmitterReferencingAsyncResource extends AsyncResource {
+		constructor(ee, type, options) {
+			super(type, options);
+			this[kEventEmitter] = ee;
+		}
+		get eventEmitter() {
+			return this[kEventEmitter];
+		}
+	}
+	EventEmitterReferencingAsyncResourceClass = EventEmitterReferencingAsyncResource;
+}
+
+let cacheEventsScript;
+
+const SPECIAL_MODULES = {
+	events: {
+		init(vm) {
+			if (!cacheEventsScript) {
+				const eventsSource = fs.readFileSync(`${__dirname}/events.js`, 'utf8');
+				cacheEventsScript = new VMScript(`(function (fromhost) { const module = {}; module.exports={};{ ${eventsSource}
+	} return module.exports;})`, {filename: 'events.js'});
+			}
+			const closure = VM.prototype.run.call(vm, cacheEventsScript);
+			const eventsInstance = closure(vm.readonly({
+				kErrorMonitor: EventEmitter.errorMonitor,
+				once: EventEmitter.once,
+				on: EventEmitter.on,
+				getEventListeners: EventEmitter.getEventListeners,
+				EventEmitterReferencingAsyncResource: EventEmitterReferencingAsyncResourceClass
+			}));
+			eventsModules.set(vm, eventsInstance);
+			vm._addProtoMapping(EventEmitter.prototype, eventsInstance.EventEmitter.prototype);
+		},
+		load: defaultBuiltinLoaderEvents
+	},
+	buffer: defaultBuiltinLoaderBuffer,
+	util: defaultBuiltinLoaderUtil
+};
+
+function addDefaultBuiltin(builtins, key, hostRequire) {
+	if (builtins.has(key)) return;
+	const special = SPECIAL_MODULES[key];
+	builtins.set(key, special ? special : vm => vm.readonly(hostRequire(key)));
+}
+
+
+function makeBuiltinsFromLegacyOptions(builtins, hostRequire, mocks, overrides) {
+	const res = new Map();
+	if (mocks) {
+		const keys = Object.getOwnPropertyNames(mocks);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			res.set(key, (tvm) => tvm.readonly(mocks[key]));
+		}
+	}
+	if (overrides) {
+		const keys = Object.getOwnPropertyNames(overrides);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			res.set(key, overrides[key]);
+		}
+	}
+	if (Array.isArray(builtins)) {
+		const def = builtins.indexOf('*') >= 0;
+		if (def) {
+			for (let i = 0; i < BUILTIN_MODULES.length; i++) {
+				const name = BUILTIN_MODULES[i];
+				if (builtins.indexOf(`-${name}`) === -1) {
+					addDefaultBuiltin(res, name, hostRequire);
+				}
+			}
+		} else {
+			for (let i = 0; i < BUILTIN_MODULES.length; i++) {
+				const name = BUILTIN_MODULES[i];
+				if (builtins.indexOf(name) !== -1) {
+					addDefaultBuiltin(res, name, hostRequire);
+				}
+			}
+		}
+	} else if (builtins) {
+		for (let i = 0; i < BUILTIN_MODULES.length; i++) {
+			const name = BUILTIN_MODULES[i];
+			if (builtins[name]) {
+				addDefaultBuiltin(res, name, hostRequire);
+			}
+		}
+	}
+	return res;
+}
+
+function makeBuiltins(builtins, hostRequire) {
+	const res = new Map();
+	for (let i = 0; i < builtins.length; i++) {
+		const name = builtins[i];
+		addDefaultBuiltin(res, name, hostRequire);
+	}
+	return res;
+}
+
+exports.makeBuiltinsFromLegacyOptions = makeBuiltinsFromLegacyOptions;
+exports.makeBuiltins = makeBuiltins;

package/lib/cli.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const pa = require('path');
+
+const {NodeVM, VMError} = require('../');
+
+if (process.argv[2]) {
+	const path = pa.resolve(process.argv[2]);
+
+	console.log(`\x1B[90m[vm] creating VM for ${path}\x1B[39m`);
+	const started = Date.now();
+
+	try {
+		NodeVM.file(path, {
+			verbose: true,
+			require: {
+				external: true
+			}
+		});
+
+		console.log(`\x1B[90m[vm] VM completed in ${Date.now() - started}ms\x1B[39m`);
+	} catch (ex) {
+		if (ex instanceof VMError) {
+			console.error(`\x1B[31m[vm:error] ${ex.message}\x1B[39m`);
+		} else {
+			const {stack} = ex;
+
+			if (stack) {
+				console.error(`\x1B[31m[vm:error] ${stack}\x1B[39m`);
+			} else {
+				console.error(`\x1B[31m[vm:error] ${ex}\x1B[39m`);
+			}
+		}
+	}
+}

package/lib/compiler.js

@@ -0,0 +1,117 @@
+'use strict';
+
+const {
+	VMError
+} = require('./bridge');
+
+/**
+ * Returns the cached coffee script compiler or loads it
+ * if it is not found in the cache.
+ *
+ * @private
+ * @param {Object} [options] - Optional compiler options.
+ * @return {compileCallback} The coffee script compiler.
+ * @throws {VMError} If the coffee-script module can't be found.
+ */
+function getCoffeeScriptCompiler(options) {
+	try {
+		// The warning generated by webpack can be disabled by setting:
+		// ignoreWarnings[].message = /Can't resolve 'coffee-script'/
+		/* eslint-disable-next-line global-require */
+		const coffeeScript = require('coffee-script');
+		return (code, filename) => {
+			return coffeeScript.compile(code, Object.assign({header: false, bare: true}, options));
+		};
+	} catch (e) {
+		throw new VMError('Coffee-Script compiler is not installed.');
+	}
+}
+
+/**
+ * Returns the cached TypeScript compiler or loads it
+ * if it is not found in the cache.
+ *
+ * @private
+ * @param {Object} [options] - Optional compiler options.
+ * @return {compileCallback} The TypeScript compiler.
+ * @throws {VMError} If the TypeScript module can't be found.
+ */
+function getTypeScriptCompiler(options) {
+	try {
+		// The warning generated by webpack can be disabled by setting:
+		// ignoreWarnings[].message = /Can't resolve 'typescript'/
+		/* eslint-disable-next-line global-require */
+		const typescript = require('typescript');
+		return (code, filename) => {
+			return typescript.transpileModule(code, {
+				fileName: filename,
+				compilerOptions: Object.assign({
+					module: typescript.ModuleKind.CommonJS,
+				}, options)
+			}).outputText;
+		};
+	} catch (e) {
+		throw new VMError('TypeScript compiler is not installed.');
+	}
+}
+
+/**
+ * Remove the shebang from source code.
+ *
+ * @private
+ * @param {string} code - Code from which to remove the shebang.
+ * @return {string} code without the shebang.
+ */
+function removeShebang(code) {
+	if (!code.startsWith('#!')) return code;
+	return '//' + code.substring(2);
+}
+
+
+/**
+ * The JavaScript compiler, just a identity function.
+ *
+ * @private
+ * @type {compileCallback}
+ * @param {string} code - The JavaScript code.
+ * @param {string} filename - Filename of this script.
+ * @return {string} The code.
+ */
+function jsCompiler(code, filename) {
+	return removeShebang(code);
+}
+
+/**
+ * Look up the compiler for a specific name.
+ *
+ * @private
+ * @param {(string|compileCallback)} compiler - A compile callback or the name of the compiler.
+ * @param {Object} [options] - Optional compiler options.
+ * @return {compileCallback} The resolved compiler.
+ * @throws {VMError} If the compiler is unknown or the coffee script module was needed and couldn't be found.
+ */
+function lookupCompiler(compiler, options) {
+	if ('function' === typeof compiler) return compiler;
+	switch (compiler) {
+		case 'coffeescript':
+		case 'coffee-script':
+		case 'cs':
+		case 'text/coffeescript':
+			return getCoffeeScriptCompiler(options);
+		case 'javascript':
+		case 'java-script':
+		case 'js':
+		case 'text/javascript':
+			return jsCompiler;
+		case 'typescript':
+		case 'type-script':
+		case 'ts':
+		case 'text/typescript':
+			return getTypeScriptCompiler(options);
+		default:
+			throw new VMError(`Unsupported compiler '${compiler}'.`);
+	}
+}
+
+exports.removeShebang = removeShebang;
+exports.lookupCompiler = lookupCompiler;