import test from 'node:test'; import assert from 'node:assert/strict'; import fs from 'node:fs'; import http from 'node:http'; import net from 'node:net'; import tls from 'node:tls'; import { fixture, until, workspace } from './helpers.mjs'; import { Provider } from '../src/server/provider.mjs'; import { Runtime } from '../src/server/runtime.mjs'; import { ModelTransport } from '../src/core/models/transport.mjs'; import { NetworkDiagnostics } from '../src/core/models/network-diagnostics.mjs'; import { CompanionTLS } from '../src/core/companion/tls-authority.mjs'; import { createRequestHandler } from '../src/server/app.mjs'; import { hostAuthority } from '../src/core/desktop/host-authority.mjs'; import { installUpgrade } from '../src/server/hot-upgrade.mjs'; async function listener(f, server) { const sockets = new Set(); server.on('connection', socket => { sockets.add(socket); socket.on('close', () => sockets.delete(socket)); }); await new Promise(resolve => server.listen(0, '127.0.0.1', resolve)); f.onCleanup(async () => { for (const socket of sockets) socket.destroy(); await new Promise(resolve => server.close(resolve)); }); return server.address().port; } function setup(t, options = {}) { const f = fixture(t), provider = new Provider({ transport: options.transport ?? new ModelTransport({ environment: {} }) }); const hub = provider.modelHub(f.store); hub.networkChecks = new NetworkDiagnostics(hub, options); f.onCleanup(() => provider.abortRequests()); const add = baseUrl => hub.upsert({ name: 'Owned network check', model: 'owned-no-model', baseUrl, requiresKey: true }); const run = async connection => { const { job } = hub.networkChecks.start({ id: connection.id, revision: connection.revision }); await hub.networkChecks.active.get(job.id).promise; return hub.networkChecks.view().jobs.find(row => row.id === job.id); }; return { ...f, provider, hub, add, run, manager: hub.networkChecks }; } async function material() { const state = { gatewayId: 'owned-network-test' }, registry = { binding: 'owned-network-test', read: () => state, mutate: action => action(state) }; return new CompanionTLS(registry, { protect: value => Buffer.from(value), unprotect: value => Buffer.from(value) }).material('127.0.0.1'); } test('plain endpoint checks only TCP, records family coverage and never reads model credentials or writes routing/health/attempts', async t => { const f = setup(t); let bytes = 0; const port = await listener(f, net.createServer(socket => socket.on('data', chunk => { bytes += chunk.length; }))); const connection = f.add('http://127.0.0.1:' + port + '/v1'), state = structuredClone(f.hub.state), config = structuredClone(f.store.config); f.hub.credential = () => { throw Error('Credential access forbidden.'); }; f.provider.redact = () => { throw Error('Redaction must not enumerate saved keys.'); }; const job = await f.run(connection); assert.equal(job.status, 'passed'); assert.equal(job.stages.dns.status, 'passed'); assert.equal(job.trials[0].tls, 'not_applicable'); assert.equal(job.trials[2].status, 'skipped'); assert.equal(job.trials[2].code, 'ADDRESS_FAMILY_UNAVAILABLE'); assert.equal(bytes, 0); assert.deepEqual(f.hub.state, state); assert.deepEqual(f.store.config, config); assert.deepEqual(f.hub.attempts, []); assert.equal(f.hub.health.size, 0); assert.equal(job.credentialAccess, false); assert.equal(job.httpRequests, 0); assert.equal(job.modelRequests, 0); }); test('local DNS failure is separate from TCP/TLS and arbitrary input, stale revision and TLS overrides are rejected', async t => { let lookups = 0; const f = setup(t, { lookup: (_name, _options, callback) => { lookups++; callback(Object.assign(new Error('owned lookup'), { code: 'ENOTFOUND' })); } }); const connection = f.add('https://owned-dns.invalid/v1'); for (const extra of [{ revision: 99 }, { rejectUnauthorized: false }, { apiKey: 'must-not-read' }, { port: 1 }]) assert.throws(() => f.manager.start({ id: connection.id, revision: connection.revision, ...extra })); const job = await f.run(connection); assert.equal(lookups, 1); assert.equal(job.status, 'failed'); assert.equal(job.stages.dns.code, 'ENOTFOUND'); assert.ok(job.trials.every(row => row.status === 'skipped')); assert.equal(job.target.host, 'owned-dns.invalid'); }); test('refused TCP socket preserves its stage and cannot masquerade as a TLS or API response', async t => { const f = setup(t), server = net.createServer(), port = await listener(f, server); await new Promise(resolve => server.close(resolve)); const job = await f.run(f.add('https://127.0.0.1:' + port + '/v1')); assert.equal(job.status, 'failed'); assert.equal(job.trials[0].stage, 'tcp'); assert.equal(job.trials[0].code, 'ECONNREFUSED'); assert.equal(job.trials[0].tlsProtocol, undefined); assert.equal(job.modelRequests, 0); }); test('TLS validation succeeds for a trusted owned certificate and rejects the same untrusted certificate', async t => { const cert = await material(), f = setup(t, { ca: cert.ca }); const server = tls.createServer(cert); server.on('tlsClientError', () => {}); const port = await listener(f, server), connection = f.add('https://127.0.0.1:' + port + '/v1'); const good = await f.run(connection); assert.equal(good.status, 'passed'); assert.equal(good.trials[0].certificateAuthorized, true); assert.ok(good.trials[0].certificateFingerprint256); assert.ok(good.trials[0].tlsMs >= 0); delete f.manager.options.ca; const bad = await f.run(connection); assert.equal(bad.status, 'failed'); assert.equal(bad.trials[0].stage, 'tls'); assert.ok(['SELF_SIGNED_CERT_IN_CHAIN', 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'].includes(bad.trials[0].code), bad.trials[0].code); assert.notEqual(bad.trials[0].certificateAuthorized, true); }); test('a TCP peer that never answers TLS is bounded, and cancellation waits for owned sockets to close', async t => { let open = 0; const f = setup(t, { stageTimeoutMs: 80 }); const server = net.createServer(socket => { open++; socket.on('data', () => {}); socket.on('close', () => open--); }); const port = await listener(f, server), connection = f.add('https://127.0.0.1:' + port + '/v1'); const timed = await f.run(connection); assert.equal(timed.trials[0].stage, 'tls'); assert.equal(timed.trials[0].code, 'TLS_HANDSHAKE_TIMEOUT'); await until(() => open === 0); f.manager.options.stageTimeoutMs = 10000; const { job } = f.manager.start({ id: connection.id, revision: connection.revision }); await until(() => open > 0); assert.throws(() => f.manager.start({ id: connection.id, revision: connection.revision }), /等待/); const stopped = await f.manager.stop(job.id, {}); assert.equal(stopped.job.status, 'cancelled'); assert.equal(f.manager.active.size, 0); await until(() => open === 0); const repeated = await f.manager.stop(job.id, {}); assert.deepEqual(repeated, stopped); }); test('a stalled lookup is cancellable and the overall deadline bounds DNS without late socket work', async t => { let callback; const f = setup(t, { budgetMs: 65, lookup: (_name, _options, done) => { callback = done; } }); const connection = f.add('https://owned-stalled.invalid/v1'), job = await f.run(connection); assert.equal(job.status, 'failed'); assert.equal(job.code, 'DIAGNOSTIC_DEADLINE'); assert.equal(job.stages.dns.status, 'cancelled'); const frozen = JSON.stringify(f.manager.view()); callback(null, [{ address: '127.0.0.1', family: 4 }]); await new Promise(resolve => setImmediate(resolve)); assert.equal(JSON.stringify(f.manager.view()), frozen); assert.equal(f.manager.active.size, 0); }); test('dual-stack fallback and explicit family results remain separate and never change global DNS defaults', async t => { const lookup = (_name, options, callback) => callback(null, [{ address: '::1', family: 6 }, { address: '127.0.0.1', family: 4 }]); const f = setup(t, { transport: new ModelTransport({ environment: {}, lookup }) }); const port = await listener(f, net.createServer()), previous = net.getDefaultAutoSelectFamily(); const job = await f.run(f.add('http://owned-dual.invalid:' + port + '/v1')); assert.equal(job.status, 'partial'); assert.equal(job.trials[0].status, 'passed'); assert.equal(job.trials[0].family, 'IPv4'); assert.equal(job.trials[2].status, 'failed'); assert.equal(job.trials[2].code, 'ECONNREFUSED'); assert.equal(net.getDefaultAutoSelectFamily(), previous); assert.equal(f.hub.attempts.length, 0); }); test('proxy settings are reported as scope only; diagnostics do not contact the proxy or leak its credentials', async t => { let contacts = 0; const f = setup(t), proxy = net.createServer(() => { contacts++; }), proxyPort = await listener(f, proxy); f.provider.transport = new ModelTransport({ environment: { HTTPS_PROXY: 'http://owned-user:owned-secret@127.0.0.1:' + proxyPort, NO_PROXY: '127.0.0.1' } }); const port = await listener(f, net.createServer()), job = await f.run(f.add('http://127.0.0.1:' + port + '/v1')); assert.equal(job.route.proxyConfigured, true); assert.equal(job.route.noProxyConfigured, true); assert.equal(job.route.kind, 'direct-endpoint-only'); assert.equal(job.route.modelApiRouteVerified, false); assert.equal(contacts, 0); assert.equal(JSON.stringify(job).includes('owned-secret'), false); }); test('history is bounded, survives reopening, marks interrupted work and reports changed revisions without rewriting frozen targets', async t => { const f = setup(t), connection = f.add('http://127.0.0.1:9/v1'); assert.equal(f.store.storage.meta('modelNetworkDiagnostics', null), null, 'Reading an empty history does not create metadata.'); const job = await f.run(connection); f.hub.toggle(connection.id, false); assert.equal(f.manager.view().jobs[0].stale, true); assert.equal(job.connectionRevision, connection.revision); const rows = f.store.storage.meta('modelNetworkDiagnostics', []); rows[0].status = 'running'; rows[0].stages.dns.status = 'running'; f.store.storage.setMeta('modelNetworkDiagnostics', rows); const reopened = new NetworkDiagnostics(f.hub); assert.equal(reopened.view().jobs[0].status, 'interrupted'); assert.equal(reopened.active.size, 0); assert.equal(reopened.view().jobs[0].stages.dns.status, 'interrupted'); reopened.jobs = Array.from({ length: 30 }, (_, index) => ({ ...job, id: 'retained-' + index })); f.hub.networkChecks = reopened; const next = f.hub.connection(connection.id); const result = reopened.start({ id: next.id, revision: next.revision }); await reopened.active.get(result.job.id).promise; assert.equal(reopened.view().jobs.length, 30); assert.equal(reopened.view().jobs.at(-1).id, 'retained-1'); }); test('HTTP API, host activity, configuration edits, model start and upgrade honor the same active diagnostic and stop operation', async t => { const f = setup(t), port = await listener(f, net.createServer(socket => socket.on('data', () => {}))); const connection = f.add('https://127.0.0.1:' + port + '/v1'), runtime = new Runtime(f.store, f.provider), server = http.createServer(); await listener(f, server); const token = 'owned-network-token'; const context = { appDirectory: workspace, server, store: f.store, provider: f.provider, runtime, token, clients: new Set(), started: Date.now(), getPort: () => server.address().port, exampleProject: f.project, shutdown: () => {} }; server.on('request', createRequestHandler(context)); const api = async (route, input, auth = token) => { const response = await fetch('http://127.0.0.1:' + server.address().port + '/api' + route, { method: input === undefined ? 'GET' : 'POST', headers: { 'X-Workbench-Token': auth, 'Content-Type': 'application/json', Connection: 'close' }, ...(input === undefined ? {} : { body: JSON.stringify(input) }) }); return { status: response.status, value: await response.json() }; }; assert.equal((await api('/model-center/network-diagnostics', undefined, '')).status, 403); const started = await api('/model-center/network-diagnostics', { id: connection.id, revision: connection.revision }); assert.equal(started.status, 201); assert.equal(runtime.hasActivity(), true); assert.equal(hostAuthority(context).activity().counts.networkDiagnostics, 1); assert.equal((await api('/model-center/connections', { name: 'blocked' })).status, 409); assert.equal((await api('/sessions/' + f.session.id + '/messages', { content: 'Do not start.' })).status, 409); assert.throws(() => installUpgrade(context, { appDirectory: workspace, updateServiceInfo: false }), /connection diagnostics/); const stopped = await api('/model-center/network-diagnostics/' + started.value.job.id + '/stop', {}); assert.equal(stopped.value.job.status, 'cancelled'); assert.equal(runtime.hasActivity(), false); assert.equal(hostAuthority(context).activity().active, false); const network = f.hub.networkChecks, before = JSON.stringify(network.jobs); installUpgrade(context, { appDirectory: workspace, updateServiceInfo: false }); assert.equal(f.hub.networkChecks, network); assert.equal(JSON.stringify(network.jobs), before); assert.equal((await api('/model-center/network-diagnostics')).value.jobs[0].id, started.value.job.id); }); test('provider shutdown cancels diagnostics and permits explicit reuse after a failed host stop', async t => { const f = setup(t), port = await listener(f, net.createServer(socket => socket.on('data', () => {}))), connection = f.add('https://127.0.0.1:' + port + '/v1'); const { job } = f.manager.start({ id: connection.id, revision: connection.revision }); await until(() => f.manager.jobs[0].trials.some(row => row.stage === 'tls')); await f.provider.abortRequests(); assert.equal(f.manager.active.size, 0); assert.equal(f.manager.view().jobs[0].status, 'cancelled'); assert.equal(f.manager.view().jobs[0].id, job.id); assert.throws(() => f.manager.start({ id: connection.id, revision: connection.revision }), /停止/); f.provider.resumeRequests(); const next = f.manager.start({ id: connection.id, revision: connection.revision }); await f.manager.stop(next.job.id, {}); assert.equal(f.manager.view().jobs[0].status, 'cancelled'); });