497 lines
27 KiB
JavaScript
497 lines
27 KiB
JavaScript
#!/usr/bin/env node
|
||
'use strict';
|
||
|
||
const fs = require('fs');
|
||
const path = require('path');
|
||
const vm = require('vm');
|
||
const { loadNativeAddon } = require('./load_native_addon');
|
||
|
||
function parseArgs(argv) {
|
||
const args = { target: '', entry: '', fixture: '', trace: '', summary: '', output: '', addon: '', timeout: 5000, json: false, markdown: false };
|
||
for (let i = 2; i < argv.length; i++) {
|
||
const a = argv[i];
|
||
if (a === '--target') args.target = argv[++i] || '';
|
||
else if (a === '--entry') args.entry = argv[++i] || '';
|
||
else if (a === '--fixture') args.fixture = argv[++i] || '';
|
||
else if (a === '--trace') args.trace = argv[++i] || '';
|
||
else if (a === '--summary') args.summary = argv[++i] || '';
|
||
else if (a === '--output') args.output = argv[++i] || '';
|
||
else if (a === '--addon') args.addon = argv[++i] || '';
|
||
else if (a === '--timeout') args.timeout = Number(argv[++i] || '5000');
|
||
else if (a === '--json') args.json = true;
|
||
else if (a === '--markdown') args.markdown = true;
|
||
else if (a === '--help' || a === '-h') args.help = true;
|
||
else throw new Error(`未知参数：${a}`);
|
||
}
|
||
if (!args.json && !args.markdown) args.markdown = true;
|
||
return args;
|
||
}
|
||
|
||
function usage() {
|
||
return `用法：
|
||
node scripts/run_with_trace.js --target case/js/original/app.js --entry window.makeSign --fixture case/fixtures/sample.fixture.json --trace case/tmp/env-trace.jsonl --summary case/tmp/missing-env.json --output case/tmp/node-output.json
|
||
|
||
说明：该脚本用于探测模式。默认在 vm 探测上下文内定义浏览器桩函数，避免把宿主 require/process/Buffer 以及 Node 自带 navigator/performance/localStorage 等 Web API 兼容层暴露给目标 JS；正式交付不强制只能使用 vm。`;
|
||
}
|
||
|
||
function readJson(p) { return p ? JSON.parse(fs.readFileSync(p, 'utf8').replace(/^\uFEFF/, '')) : {}; }
|
||
function ensureParent(p) { if (p) fs.mkdirSync(path.dirname(path.resolve(p)), { recursive: true }); }
|
||
|
||
function bootstrapSource(fixture) {
|
||
const fixtureText = JSON.stringify(JSON.stringify(fixture || {}));
|
||
return `
|
||
'use strict';
|
||
const __fixture = JSON.parse(${fixtureText});
|
||
Object.defineProperty(globalThis, '__events', { value: [], enumerable: false, configurable: true });
|
||
function __safe(v) {
|
||
if (v == null || ['string', 'number', 'boolean'].includes(typeof v)) return v;
|
||
if (Array.isArray(v)) return v.slice(0, 20).map(__safe);
|
||
if (typeof v === 'function') return '[Function ' + (v.name || 'anonymous') + ']';
|
||
if (typeof v === 'object') return '[Object ' + ((v.constructor && v.constructor.name) || 'Object') + ']';
|
||
return '[' + typeof v + ']';
|
||
}
|
||
function __push(e) {
|
||
try {
|
||
e.ts = Date.now();
|
||
__events.push(e);
|
||
} catch (_) {}
|
||
}
|
||
Object.defineProperty(globalThis, '__push', { value: __push, enumerable: false, configurable: true });
|
||
|
||
function traceProxy(name, options) {
|
||
options = options || {};
|
||
const target = function traceProxyFunction() {};
|
||
const cache = Object.create(null);
|
||
const primitive = options.primitive == null ? '' : options.primitive;
|
||
return new Proxy(target, {
|
||
get(t, prop) {
|
||
if (prop === Symbol.toPrimitive) return function(hint) { __push({ type: 'toPrimitive', path: name, hint: hint }); return hint === 'number' ? 0 : primitive; };
|
||
if (prop === Symbol.toStringTag) return options.tag || name.split('.').pop() || 'Object';
|
||
if (prop === 'then') return undefined;
|
||
if (prop === 'toString') return function toString() { __push({ type: 'call', path: name + '.toString', args: [] }); return String(primitive || '[object ' + (options.tag || 'Object') + ']'); };
|
||
if (prop === 'valueOf') return function valueOf() { __push({ type: 'call', path: name + '.valueOf', args: [] }); return primitive || 0; };
|
||
const key = String(prop);
|
||
__push({ type: 'get', path: name + '.' + key });
|
||
if (!cache[key]) cache[key] = traceProxy(name + '.' + key);
|
||
return cache[key];
|
||
},
|
||
set(t, prop, value) { const key = String(prop); __push({ type: 'set', path: name + '.' + key, value: __safe(value), valueType: typeof value }); cache[key] = value; return true; },
|
||
has(t, prop) { __push({ type: 'has', path: name, prop: String(prop) }); return Object.prototype.hasOwnProperty.call(cache, String(prop)); },
|
||
ownKeys() { __push({ type: 'ownKeys', path: name }); return Object.keys(cache); },
|
||
getOwnPropertyDescriptor(t, prop) { __push({ type: 'getOwnPropertyDescriptor', path: name, prop: String(prop) }); return cache[String(prop)] ? { value: cache[String(prop)], enumerable: true, configurable: true, writable: true } : undefined; },
|
||
getPrototypeOf() { __push({ type: 'getPrototypeOf', path: name }); return Function.prototype; },
|
||
apply(t, thisArg, args) { __push({ type: 'call', path: name, args: Array.from(args).map(v => typeof v) }); return traceProxy(name + '()'); },
|
||
construct(t, args) { __push({ type: 'new', path: name, args: Array.from(args).map(v => typeof v) }); return traceProxy('new ' + name); },
|
||
});
|
||
}
|
||
|
||
function makeStorage(name, initial) {
|
||
const data = new Map(Object.entries(initial || {}).map(([k, v]) => [String(k), String(v)]));
|
||
const storage = {
|
||
get length() { __push({ type: 'get', path: name + '.length' }); return data.size; },
|
||
key(i) { __push({ type: 'call', path: name + '.key', args: ['number'] }); return Array.from(data.keys())[Number(i)] ?? null; },
|
||
getItem(k) { __push({ type: 'call', path: name + '.getItem', args: ['string'] }); k = String(k); return data.has(k) ? data.get(k) : null; },
|
||
setItem(k, v) { __push({ type: 'call', path: name + '.setItem', args: ['string', 'string'] }); data.set(String(k), String(v)); },
|
||
removeItem(k) { __push({ type: 'call', path: name + '.removeItem', args: ['string'] }); data.delete(String(k)); },
|
||
clear() { __push({ type: 'call', path: name + '.clear', args: [] }); data.clear(); },
|
||
};
|
||
Object.defineProperty(storage, '__data', { value: data, enumerable: false });
|
||
return storage;
|
||
}
|
||
|
||
function parseLocation(raw) {
|
||
const s = String(raw || 'https://example.com/');
|
||
const m = s.match(/^([a-z][a-z0-9+.-]*:)\\/\\/([^\\/?#]*)([^?#]*)(\\?[^#]*)?(#.*)?$/i);
|
||
if (!m) return { href: s, origin: '', protocol: '', host: '', hostname: '', port: '', pathname: '', search: '', hash: '', toString() { return this.href; } };
|
||
const protocol = m[1], host = m[2], pathname = m[3] || '/', search = m[4] || '', hash = m[5] || '';
|
||
const hp = host.split(':');
|
||
return { href: protocol + '//' + host + pathname + search + hash, origin: protocol + '//' + host, protocol, host, hostname: hp[0], port: hp[1] || '', pathname, search, hash, toString() { return this.href; } };
|
||
}
|
||
|
||
class URLSearchParams {
|
||
constructor(init) {
|
||
this._pairs = [];
|
||
if (typeof init === 'string') {
|
||
const text = init.replace(/^\\?/, '');
|
||
if (text) for (const part of text.split('&')) {
|
||
if (!part) continue;
|
||
const idx = part.indexOf('=');
|
||
const k = idx >= 0 ? part.slice(0, idx) : part;
|
||
const v = idx >= 0 ? part.slice(idx + 1) : '';
|
||
this.append(decodeURIComponent(k.replace(/\\+/g, ' ')), decodeURIComponent(v.replace(/\\+/g, ' ')));
|
||
}
|
||
} else if (init && typeof init === 'object') {
|
||
for (const k of Object.keys(init)) this.append(k, init[k]);
|
||
}
|
||
}
|
||
append(k, v) { this._pairs.push([String(k), String(v)]); }
|
||
set(k, v) { k = String(k); this._pairs = this._pairs.filter(p => p[0] !== k); this.append(k, v); }
|
||
get(k) { k = String(k); const p = this._pairs.find(x => x[0] === k); return p ? p[1] : null; }
|
||
has(k) { k = String(k); return this._pairs.some(x => x[0] === k); }
|
||
toString() { return this._pairs.map(p => encodeURIComponent(p[0]) + '=' + encodeURIComponent(p[1])).join('&'); }
|
||
}
|
||
globalThis.URLSearchParams = URLSearchParams;
|
||
|
||
class URL {
|
||
constructor(input, base) {
|
||
const loc = parseLocation(input || base || 'https://example.com/');
|
||
Object.assign(this, loc);
|
||
this.searchParams = new URLSearchParams(this.search);
|
||
}
|
||
toString() { return this.href; }
|
||
}
|
||
globalThis.URL = URL;
|
||
|
||
class TextEncoder {
|
||
encode(input) {
|
||
const s = unescape(encodeURIComponent(String(input)));
|
||
const out = new Uint8Array(s.length);
|
||
for (let i = 0; i < s.length; i++) out[i] = s.charCodeAt(i);
|
||
return out;
|
||
}
|
||
}
|
||
class TextDecoder {
|
||
decode(input) {
|
||
const arr = Array.from(input || []);
|
||
return decodeURIComponent(escape(String.fromCharCode.apply(null, arr)));
|
||
}
|
||
}
|
||
globalThis.TextEncoder = TextEncoder;
|
||
globalThis.TextDecoder = TextDecoder;
|
||
|
||
const __b64chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
|
||
function btoa(input) {
|
||
let str = String(input), output = '';
|
||
for (let block = 0, charCode, i = 0, map = __b64chars; str.charAt(i | 0) || (map = '=', i % 1); output += map.charAt(63 & block >> 8 - i % 1 * 8)) {
|
||
charCode = str.charCodeAt(i += 3 / 4);
|
||
if (charCode > 0xFF) throw new Error('字符超出 Latin1 范围');
|
||
block = block << 8 | charCode;
|
||
}
|
||
return output;
|
||
}
|
||
function atob(input) {
|
||
let str = String(input).replace(/=+$/, ''), output = '';
|
||
if (str.length % 4 === 1) throw new Error('无效 base64');
|
||
for (let bc = 0, bs = 0, buffer, i = 0; buffer = str.charAt(i++); ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer, bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0) {
|
||
buffer = __b64chars.indexOf(buffer);
|
||
}
|
||
return output;
|
||
}
|
||
globalThis.atob = atob;
|
||
globalThis.btoa = btoa;
|
||
|
||
const console = {};
|
||
for (const name of ['log', 'warn', 'error', 'info', 'debug', 'trace', 'group', 'groupEnd']) {
|
||
console[name] = function() { __push({ type: 'console', path: 'console.' + name, args: Array.from(arguments).map(v => typeof v) }); };
|
||
}
|
||
globalThis.console = console;
|
||
|
||
let __timerId = 1;
|
||
globalThis.setTimeout = function(fn, delay) { __push({ type: 'call', path: 'setTimeout', args: [typeof fn, typeof delay] }); return __timerId++; };
|
||
globalThis.clearTimeout = function(id) { __push({ type: 'call', path: 'clearTimeout', args: [typeof id] }); };
|
||
globalThis.setInterval = function(fn, delay) { __push({ type: 'call', path: 'setInterval', args: [typeof fn, typeof delay] }); return __timerId++; };
|
||
globalThis.clearInterval = function(id) { __push({ type: 'call', path: 'clearInterval', args: [typeof id] }); };
|
||
|
||
globalThis.window = globalThis;
|
||
globalThis.self = globalThis;
|
||
globalThis.top = globalThis;
|
||
globalThis.parent = globalThis;
|
||
|
||
const browser = __fixture.browser || {};
|
||
const request = __fixture.request || {};
|
||
const runtime = __fixture.runtime || {};
|
||
globalThis.location = parseLocation(__fixture.pageUrl || __fixture.url || __fixture.apiUrl || 'https://example.com/');
|
||
globalThis.screen = Object.assign({ width: 1920, height: 1080, availWidth: 1920, availHeight: 1040, colorDepth: 24, pixelDepth: 24 }, browser.screen || {});
|
||
globalThis.devicePixelRatio = browser.devicePixelRatio || 1;
|
||
globalThis.history = traceProxy('history');
|
||
const __navigatorData = {
|
||
userAgent: browser.userAgent || '',
|
||
language: browser.language || 'zh-CN',
|
||
languages: browser.languages || [browser.language || 'zh-CN', 'zh'],
|
||
platform: browser.platform || 'Win32',
|
||
hardwareConcurrency: browser.hardwareConcurrency || 8,
|
||
deviceMemory: browser.deviceMemory || 8,
|
||
webdriver: false,
|
||
plugins: traceProxy('navigator.plugins', { tag: 'PluginArray' }),
|
||
mimeTypes: traceProxy('navigator.mimeTypes', { tag: 'MimeTypeArray' }),
|
||
};
|
||
globalThis.navigator = {};
|
||
for (const key of Object.keys(__navigatorData)) {
|
||
Object.defineProperty(globalThis.navigator, key, {
|
||
get() { __push({ type: 'get', path: 'navigator.' + key }); return __navigatorData[key]; },
|
||
enumerable: true,
|
||
configurable: true,
|
||
});
|
||
}
|
||
|
||
class Document {}
|
||
class HTMLDocument extends Document {}
|
||
globalThis.Document = Document;
|
||
globalThis.HTMLDocument = HTMLDocument;
|
||
const document = new HTMLDocument();
|
||
let cookieText = request.cookies && typeof request.cookies === 'object' ? Object.entries(request.cookies).map(([k, v]) => k + '=' + v).join('; ') : '';
|
||
Object.defineProperty(Document.prototype, 'cookie', {
|
||
get() { __push({ type: 'get', path: 'document.cookie' }); return cookieText; },
|
||
set(v) { __push({ type: 'set', path: 'document.cookie', valueType: typeof v }); cookieText = cookieText ? cookieText + '; ' + String(v).split(';')[0] : String(v).split(';')[0]; },
|
||
enumerable: true,
|
||
configurable: true,
|
||
});
|
||
document.URL = globalThis.location.href;
|
||
document.referrer = __fixture.referrer || '';
|
||
document.createElement = function(tag) { __push({ type: 'call', path: 'document.createElement', args: ['string'] }); return traceProxy('document.createElement(' + String(tag) + ')', { tag: String(tag).toUpperCase() }); };
|
||
document.querySelector = function() { __push({ type: 'call', path: 'document.querySelector', args: ['string'] }); return null; };
|
||
document.querySelectorAll = function() { __push({ type: 'call', path: 'document.querySelectorAll', args: ['string'] }); return []; };
|
||
Object.defineProperty(document, 'all', { get() { __push({ type: 'get', path: 'document.all' }); return undefined; }, enumerable: false, configurable: true });
|
||
globalThis.document = document;
|
||
|
||
globalThis.localStorage = makeStorage('localStorage', request.localStorage || __fixture.localStorage || {});
|
||
globalThis.sessionStorage = makeStorage('sessionStorage', request.sessionStorage || __fixture.sessionStorage || {});
|
||
|
||
const randomBytes = Array.isArray(runtime.randomBytes) ? runtime.randomBytes : [];
|
||
globalThis.crypto = {
|
||
getRandomValues(arr) { __push({ type: 'call', path: 'crypto.getRandomValues', args: [arr && arr.constructor && arr.constructor.name || typeof arr] }); for (let i = 0; i < arr.length; i++) arr[i] = randomBytes[i] ?? 0; return arr; },
|
||
randomUUID() { __push({ type: 'call', path: 'crypto.randomUUID', args: [] }); return runtime.randomUUID || '00000000-0000-4000-8000-000000000000'; },
|
||
subtle: traceProxy('crypto.subtle'),
|
||
};
|
||
globalThis.performance = {
|
||
now() { __push({ type: 'call', path: 'performance.now', args: [] }); return runtime.performanceNow ?? 0; },
|
||
timeOrigin: runtime.timeOrigin ?? runtime.now ?? Date.now(),
|
||
};
|
||
globalThis.fetch = function fetchStub() { __push({ type: 'call', path: 'fetch', args: Array.from(arguments).map(v => typeof v) }); return Promise.reject(new Error('补环境探测模式默认不发起真实网络请求')); };
|
||
for (const name of ['XMLHttpRequest', 'Image', 'HTMLElement', 'HTMLCanvasElement', 'WebGLRenderingContext', 'Headers', 'Request', 'Response', 'WebSocket', 'Worker', 'MessageChannel']) {
|
||
globalThis[name] = traceProxy(name);
|
||
}
|
||
|
||
if (runtime.now) {
|
||
const RealDate = Date;
|
||
function FixedDate() {
|
||
const args = Array.from(arguments);
|
||
if (!(this instanceof FixedDate)) return new RealDate(args.length ? args[0] : runtime.now).toString();
|
||
return new RealDate(args.length ? args[0] : runtime.now);
|
||
}
|
||
FixedDate.now = function() { return runtime.now; };
|
||
FixedDate.parse = RealDate.parse;
|
||
FixedDate.UTC = RealDate.UTC;
|
||
FixedDate.prototype = RealDate.prototype;
|
||
globalThis.Date = FixedDate;
|
||
}
|
||
|
||
function __resolveEntry(entry) {
|
||
const parts = String(entry || '').split('.').filter(Boolean);
|
||
if (parts[0] === 'globalThis' || parts[0] === 'window') parts.shift();
|
||
let cur = globalThis;
|
||
for (const part of parts) { if (cur == null) return undefined; cur = cur[part]; }
|
||
return cur;
|
||
}
|
||
function __serialize(v) {
|
||
if (v == null || ['string', 'number', 'boolean'].includes(typeof v)) return v;
|
||
if (typeof v === 'bigint') return String(v);
|
||
if (typeof v === 'function') return '[Function ' + (v.name || 'anonymous') + ']';
|
||
try { return JSON.parse(JSON.stringify(v)); } catch (_) { return String(v); }
|
||
}
|
||
Object.defineProperty(globalThis, '__callEntry', { value: function(entry, argsJson) {
|
||
const fn = __resolveEntry(entry);
|
||
if (typeof fn !== 'function') return JSON.stringify({ entryFound: false, output: undefined, error: { name: 'EntryError', message: '入口不是函数或不存在：' + entry } });
|
||
try {
|
||
const args = JSON.parse(argsJson || '[]');
|
||
const ret = fn.apply(globalThis, Array.isArray(args) ? args : []);
|
||
if (ret && typeof ret.then === 'function') return JSON.stringify({ entryFound: true, output: '[Promise]', async: true });
|
||
return JSON.stringify({ entryFound: true, output: __serialize(ret), outputType: typeof ret });
|
||
} catch (err) {
|
||
return JSON.stringify({ entryFound: true, output: undefined, error: { name: err && err.name || 'Error', message: err && err.message || String(err) } });
|
||
}
|
||
}, enumerable: false, configurable: true });
|
||
Object.defineProperty(globalThis, '__dumpEvents', { value: function() { return JSON.stringify(__events); }, enumerable: false, configurable: true });
|
||
Object.defineProperty(globalThis, '__leakageCheck', { value: function() {
|
||
let functionProcess = 'error';
|
||
let objectCtorProcess = 'error';
|
||
let arrayCtorProcess = 'error';
|
||
try { functionProcess = Function('return typeof process')(); } catch (err) { functionProcess = 'error:' + err.message; }
|
||
try { objectCtorProcess = ({}).constructor.constructor('return typeof process')(); } catch (err) { objectCtorProcess = 'error:' + err.message; }
|
||
try { arrayCtorProcess = ([]).constructor.constructor('return typeof process')(); } catch (err) { arrayCtorProcess = 'error:' + err.message; }
|
||
const navUserAgent = typeof navigator !== 'undefined' && navigator ? String(navigator.userAgent || '') : 'undefined';
|
||
const perfHas = function(name) { try { return typeof performance !== 'undefined' && performance ? (name in performance) : false; } catch (_) { return false; } };
|
||
return JSON.stringify({
|
||
process: typeof process,
|
||
Buffer: typeof Buffer,
|
||
require: typeof require,
|
||
module: typeof module,
|
||
exports: typeof exports,
|
||
global: typeof global,
|
||
setImmediate: typeof setImmediate,
|
||
clearImmediate: typeof clearImmediate,
|
||
functionProcess,
|
||
objectCtorProcess,
|
||
arrayCtorProcess,
|
||
navigator: typeof navigator,
|
||
navigatorUserAgent: navUserAgent,
|
||
navigatorIsNodeUserAgent: /^Node\\.js\\//.test(navUserAgent),
|
||
navigatorLocks: typeof navigator !== 'undefined' && navigator ? typeof navigator.locks : 'undefined',
|
||
performance: typeof performance,
|
||
performanceNodeTiming: perfHas('nodeTiming') ? 'present' : 'absent',
|
||
performanceEventLoopUtilization: perfHas('eventLoopUtilization') ? 'present' : 'absent',
|
||
performanceTimerify: perfHas('timerify') ? 'present' : 'absent',
|
||
performanceMarkResourceTiming: perfHas('markResourceTiming') ? 'present' : 'absent',
|
||
localStorage: typeof localStorage,
|
||
localStorageConstructor: typeof localStorage !== 'undefined' && localStorage && localStorage.constructor ? localStorage.constructor.name : 'undefined',
|
||
sessionStorage: typeof sessionStorage,
|
||
sessionStorageConstructor: typeof sessionStorage !== 'undefined' && sessionStorage && sessionStorage.constructor ? sessionStorage.constructor.name : 'undefined',
|
||
fetch: typeof fetch,
|
||
webSocket: typeof WebSocket,
|
||
broadcastChannel: typeof BroadcastChannel,
|
||
messageChannel: typeof MessageChannel,
|
||
crypto: typeof crypto,
|
||
cryptoConstructor: typeof crypto !== 'undefined' && crypto && crypto.constructor ? crypto.constructor.name : 'undefined',
|
||
subtleCrypto: typeof crypto !== 'undefined' && crypto && crypto.subtle ? typeof crypto.subtle : 'undefined',
|
||
URL: typeof URL,
|
||
URLConstructor: typeof URL !== 'undefined' && URL ? URL.name : 'undefined',
|
||
URLSearchParams: typeof URLSearchParams,
|
||
TextEncoder: typeof TextEncoder,
|
||
TextDecoder: typeof TextDecoder,
|
||
ReadableStream: typeof ReadableStream,
|
||
EventTarget: typeof EventTarget,
|
||
AbortController: typeof AbortController,
|
||
WebAssembly: typeof WebAssembly,
|
||
queueMicrotask: typeof queueMicrotask,
|
||
});
|
||
}, enumerable: false, configurable: true });
|
||
`;
|
||
}
|
||
|
||
function classifyError(err) {
|
||
const message = err && err.message ? err.message : String(err);
|
||
const name = err && err.name ? err.name : 'Error';
|
||
let m = message.match(/^([A-Za-z_$][\w$]*) is not defined$/);
|
||
if (name === 'ReferenceError' && m) return { type: 'missing-global', name, message, missing: m[1] };
|
||
m = message.match(/Cannot read (?:properties|property) of undefined \(reading ['"]([^'"]+)['"]\)/);
|
||
if (m) return { type: 'missing-property', name, message, missing: m[1] };
|
||
m = message.match(/([A-Za-z0-9_$\.]+) is not a function/);
|
||
if (m) return { type: 'missing-method', name, message, missing: m[1] };
|
||
return { type: 'runtime-error', name, message };
|
||
}
|
||
|
||
function summarize(events, errors, addonResult, leakageCheck) {
|
||
const missingGlobals = [], missingMethods = [], missingProperties = [], specialObjects = [], proxyRiskSignals = [];
|
||
for (const e of errors) {
|
||
if (e.type === 'missing-global') missingGlobals.push(e.missing);
|
||
if (e.type === 'missing-method') missingMethods.push(e.missing);
|
||
if (e.type === 'missing-property') missingProperties.push(e.missing);
|
||
}
|
||
for (const e of events) {
|
||
if (e.path === 'document.all' || (e.path && e.path.startsWith('document.all.'))) specialObjects.push('document.all');
|
||
if (['ownKeys', 'getOwnPropertyDescriptor', 'getPrototypeOf', 'toPrimitive'].includes(e.type)) proxyRiskSignals.push(`${e.type}:${e.path || e.prop || ''}`);
|
||
if (e.path && e.path.endsWith('.toString')) proxyRiskSignals.push(`toString:${e.path}`);
|
||
}
|
||
const uniq = a => [...new Set(a)].filter(Boolean);
|
||
return {
|
||
eventCount: events.length,
|
||
missingGlobals: uniq(missingGlobals),
|
||
missingMethods: uniq(missingMethods),
|
||
missingProperties: uniq(missingProperties),
|
||
specialObjects: uniq(specialObjects),
|
||
nativeAddon: { available: !!(addonResult && addonResult.available), path: addonResult && addonResult.path || '', exports: addonResult && addonResult.exports || [] },
|
||
nodeLeakage: leakageCheck || {},
|
||
proxyRiskSignals: uniq(proxyRiskSignals).slice(0, 100),
|
||
runtimeErrors: errors,
|
||
};
|
||
}
|
||
|
||
function run(args) {
|
||
if (!args.target) throw new Error('必须提供 --target');
|
||
const targetFiles = args.target.split(',').map(s => s.trim()).filter(Boolean).map(p => path.resolve(p));
|
||
for (const f of targetFiles) if (!fs.existsSync(f)) throw new Error(`目标 JS 文件不存在：${f}`);
|
||
const fixture = readJson(args.fixture);
|
||
const addonResult = loadNativeAddon({ addon: args.addon });
|
||
const context = vm.createContext({}, { name: 'web-js-env-patcher' });
|
||
const errors = [];
|
||
let entryResult;
|
||
let entryFound = false;
|
||
|
||
new vm.Script(bootstrapSource(fixture), { filename: 'web-js-env-patcher-bootstrap.js' }).runInContext(context, { timeout: args.timeout });
|
||
|
||
if (addonResult && addonResult.available && addonResult.addon && addonResult.addon.createUndetectable) {
|
||
try {
|
||
context.__documentAllAddon = addonResult.addon.createUndetectable(function () { return undefined; });
|
||
vm.runInContext("Object.defineProperty(document, 'all', { get() { __push({ type: 'get', path: 'document.all' }); return globalThis.__documentAllAddon; }, enumerable: false, configurable: true });", context, { timeout: args.timeout });
|
||
} catch (err) {
|
||
errors.push({ type: 'native-addon-error', name: err.name || 'Error', message: err.message || String(err) });
|
||
}
|
||
}
|
||
|
||
for (const file of targetFiles) {
|
||
try {
|
||
const script = new vm.Script(fs.readFileSync(file, 'utf8'), { filename: file });
|
||
script.runInContext(context, { timeout: args.timeout });
|
||
} catch (err) { errors.push(classifyError(err)); }
|
||
}
|
||
|
||
const entry = args.entry || fixture.entry || '';
|
||
if (entry) {
|
||
try {
|
||
const callCode = `__callEntry(${JSON.stringify(entry)}, ${JSON.stringify(JSON.stringify(Array.isArray(fixture.args) ? fixture.args : []))})`;
|
||
const callResult = JSON.parse(vm.runInContext(callCode, context, { timeout: args.timeout }));
|
||
entryFound = !!callResult.entryFound;
|
||
entryResult = callResult.output;
|
||
if (!entryFound) errors.push({ type: 'entry-not-found', name: 'EntryError', message: `入口不是函数或不存在：${entry}`, missing: entry });
|
||
if (callResult.error) errors.push(classifyError(callResult.error));
|
||
} catch (err) { errors.push(classifyError(err)); }
|
||
}
|
||
|
||
let events = [];
|
||
let leakageCheck = {};
|
||
try { events = JSON.parse(vm.runInContext('__dumpEvents()', context, { timeout: args.timeout })); } catch (_) { events = []; }
|
||
try { leakageCheck = JSON.parse(vm.runInContext('__leakageCheck()', context, { timeout: args.timeout })); } catch (_) { leakageCheck = {}; }
|
||
|
||
const output = { entry, entryFound, output: entryResult, errors };
|
||
const summary = summarize(events, errors, addonResult, leakageCheck);
|
||
if (args.trace) { ensureParent(args.trace); fs.writeFileSync(args.trace, events.map(e => JSON.stringify(e)).join('\n') + (events.length ? '\n' : ''), 'utf8'); }
|
||
if (args.summary) { ensureParent(args.summary); fs.writeFileSync(args.summary, JSON.stringify(summary, null, 2) + '\n', 'utf8'); }
|
||
if (args.output) { ensureParent(args.output); fs.writeFileSync(args.output, JSON.stringify(output, null, 2) + '\n', 'utf8'); }
|
||
return { targetFiles, fixture: args.fixture || '', trace: args.trace || '', summaryFile: args.summary || '', outputFile: args.output || '', output, summary };
|
||
}
|
||
|
||
function renderMarkdown(result) {
|
||
const lines = [];
|
||
lines.push('# Node.js 缺失环境追踪结果');
|
||
lines.push('');
|
||
lines.push(`- 目标 JS：${result.targetFiles.join(', ')}`);
|
||
lines.push(`- fixture：${result.fixture || '未提供'}`);
|
||
lines.push(`- 入口函数：${result.output.entry || '未指定'}`);
|
||
lines.push(`- 入口是否找到：${result.output.entry ? (result.output.entryFound ? '是' : '否') : '未指定'}`);
|
||
lines.push(`- trace 文件：${result.trace || '未写入'}`);
|
||
lines.push(`- 摘要文件：${result.summaryFile || '未写入'}`);
|
||
lines.push(`- 输出文件：${result.outputFile || '未写入'}`);
|
||
lines.push(`- native addon：${result.summary.nativeAddon.available ? '可用' : '不可用或未启用'}`);
|
||
lines.push(`- trace 事件数量：${result.summary.eventCount}`);
|
||
lines.push(`- 运行错误数量：${result.summary.runtimeErrors.length}`);
|
||
if (result.summary.nodeLeakage && Object.keys(result.summary.nodeLeakage).length) {
|
||
lines.push('');
|
||
lines.push('## Node 泄露自检');
|
||
for (const [k, v] of Object.entries(result.summary.nodeLeakage)) lines.push(`- ${k}：${v}`);
|
||
}
|
||
if (result.summary.runtimeErrors.length) {
|
||
lines.push('');
|
||
lines.push('## 运行错误');
|
||
for (const e of result.summary.runtimeErrors) lines.push(`- ${e.type}：${e.message}`);
|
||
}
|
||
if (result.summary.proxyRiskSignals.length) {
|
||
lines.push('');
|
||
lines.push('## Proxy 检测风险信号');
|
||
for (const e of result.summary.proxyRiskSignals.slice(0, 20)) lines.push(`- ${e}`);
|
||
}
|
||
return lines.join('\n') + '\n';
|
||
}
|
||
|
||
try {
|
||
const args = parseArgs(process.argv);
|
||
if (args.help) { console.log(usage()); process.exit(0); }
|
||
const result = run(args);
|
||
if (args.json) console.log(JSON.stringify(result, null, 2));
|
||
if (args.markdown) process.stdout.write(renderMarkdown(result));
|
||
if (result.output.errors.some(e => e.type === 'entry-not-found')) process.exit(2);
|
||
} catch (err) {
|
||
console.error(err.message || String(err));
|
||
console.error(usage());
|
||
process.exit(1);
|
||
}
|