Files
Agent-Workbench/src/core/models/network-probe.mjs
T
2026-11-06 06:21:59 +08:00

90 lines
6.2 KiB
JavaScript

import dns from 'node:dns';
import net from 'node:net';
import tls from 'node:tls';
import { performance } from 'node:perf_hooks';
const elapsed = start => Math.max(0, Math.round(performance.now() - start));
const code = error => /^[A-Z0-9_]{1,80}$/.test(error?.code ?? '') ? error.code : 'NETWORK_CHECK_FAILED';
const cancelled = signal => Object.assign(new Error('连接诊断已停止。'), { code: signal.reason?.code ?? 'DIAGNOSTIC_CANCELLED' });
export async function probeNetwork(target, profile, { signal, update, lookup = dns.lookup, ca, stageTimeoutMs = profile.connectTimeoutMs, maxAddresses = 32 } = {}) {
const started = performance.now(), stages = { dns: { status: 'running', startedAt: new Date().toISOString() } };
const trials = ['auto', 'ipv4', 'ipv6'].map(mode => ({ mode, status: 'pending', stage: 'dns', attempts: [] }));
let updateError;
const publish = () => { try { update?.(structuredClone({ stages, trials, elapsedMs: elapsed(started) })); } catch (error) { updateError ??= error; } };
const lookupStart = performance.now(); let addresses;
publish();
try {
addresses = await new Promise((resolve, reject) => {
let done = false;
const finish = (error, value) => { if (done) return; done = true; signal?.removeEventListener('abort', abort); error ? reject(error) : resolve(value); };
const abort = () => finish(cancelled(signal));
if (signal?.aborted) { abort(); return; }
signal?.addEventListener('abort', abort, { once: true });
const family = net.isIP(target.host);
if (family) { finish(null, [{ address: target.host, family }]); return; }
try { lookup(target.host, { all: true, verbatim: true }, (error, rows) => finish(error, rows)); }
catch (error) { finish(error); }
});
addresses = addresses.filter(row => [4, 6].includes(row.family) && net.isIP(row.address) === row.family).slice(0, maxAddresses);
if (!addresses.length) throw Object.assign(new Error('没有可用地址。'), { code: 'DNS_NO_ADDRESSES' });
stages.dns = { ...stages.dns, status: 'passed', elapsedMs: elapsed(lookupStart), addresses };
} catch (error) {
stages.dns = { ...stages.dns, status: signal?.aborted ? 'cancelled' : 'failed', elapsedMs: elapsed(lookupStart), code: code(error) };
for (const trial of trials) { trial.status = signal?.aborted ? 'cancelled' : 'skipped'; trial.code = 'DNS_NOT_COMPLETED'; }
publish(); return { stages, trials, elapsedMs: elapsed(started) };
}
publish();
if (updateError) throw updateError;
await Promise.all(trials.map(trial => new Promise(resolve => {
const candidates = trial.mode === 'auto' ? addresses : addresses.filter(row => row.family === (trial.mode === 'ipv4' ? 4 : 6));
if (!candidates.length) { trial.status = 'skipped'; trial.code = 'ADDRESS_FAMILY_UNAVAILABLE'; publish(); resolve(); return; }
const began = performance.now(); let tcp, secure, timer, finished = false, tcpConnected = false, tlsStarted;
const finish = (status, error) => {
if (finished) return; finished = true; clearTimeout(timer); signal?.removeEventListener('abort', abort);
if (trial.stage === 'tcp') trial.tcpMs = elapsed(began); else if (tlsStarted !== undefined) trial.tlsMs = elapsed(tlsStarted);
trial.status = status; trial.elapsedMs = elapsed(began); if (error) trial.code = code(error);
const sockets = [...new Set([secure, tcp].filter(Boolean))];
for (const socket of sockets) socket.destroy();
// A final state means owned sockets have actually closed, including cancellation.
Promise.all(sockets.map(socket => socket.closed ? null : new Promise(done => socket.once('close', done))))
.then(() => { publish(); resolve(); });
};
const abort = () => finish('cancelled', cancelled(signal));
if (signal?.aborted) { abort(); return; }
signal?.addEventListener('abort', abort, { once: true });
trial.status = 'running'; trial.stage = 'tcp'; publish();
if (stageTimeoutMs > 0) timer = setTimeout(() => finish('failed', { code: trial.stage === 'tcp' ? 'TCP_CONNECT_TIMEOUT' : 'TLS_HANDSHAKE_TIMEOUT' }), stageTimeoutMs);
const frozenLookup = (_host, options, callback) => options.all ? callback(null, candidates)
: callback(null, candidates[0].address, candidates[0].family);
try {
tcp = net.createConnection({ host: target.host, port: target.port, lookup: frozenLookup,
autoSelectFamily: profile.autoSelectFamily, autoSelectFamilyAttemptTimeout: profile.familyAttemptTimeoutMs });
tcp.on('error', error => finish('failed', error));
tcp.on('connectionAttempt', (address, port, family) => { if (trial.attempts.length < maxAddresses) trial.attempts.push({ address, port, family }); });
tcp.on('connectionAttemptFailed', (address, _port, _family, error) => {
const attempt = trial.attempts.findLast(row => row.address === address); if (attempt) attempt.code = code(error);
});
tcp.once('connect', () => {
if (finished) return; tcpConnected = true;
trial.tcpMs = elapsed(began); trial.address = tcp.remoteAddress; trial.family = tcp.remoteFamily;
if (target.scheme === 'http:') { trial.tls = 'not_applicable'; finish('passed'); return; }
trial.stage = 'tls'; tlsStarted = performance.now(); publish();
try {
secure = tls.connect({ socket: tcp, host: target.host, servername: net.isIP(target.host) ? undefined : target.host,
rejectUnauthorized: true, ...(ca ? { ca } : {}) });
secure.on('error', error => finish('failed', error));
secure.once('secureConnect', () => {
trial.certificateAuthorized = secure.authorized === true; trial.tlsProtocol = secure.getProtocol();
trial.certificateFingerprint256 = secure.getPeerCertificate().fingerprint256;
finish(secure.authorized ? 'passed' : 'failed', secure.authorized ? null : { code: 'TLS_CERTIFICATE_REJECTED' });
});
} catch (error) { finish('failed', error); }
});
tcp.once('close', () => { if (!finished) finish('failed', { code: tcpConnected ? 'TLS_CONNECTION_CLOSED' : 'TCP_CONNECTION_CLOSED' }); });
} catch (error) { finish('failed', error); }
})));
if (updateError) throw updateError;
return { stages, trials, elapsedMs: elapsed(started) };
}