import { isIP } from "node:net" import { z } from "zod" import type { QueryConfig } from "pg" import { routeAiProfileSchema } from "@mmapp/contracts/mcp-routing" import { pool } from "../../db/index.js" import { hasPermission } from "../../lib/permissions.js" import { canonicalVrfMembers } from "../../services/vrf-members.js" import { readOspfEffectiveDisabled } from "../../services/ospf-effective-disabled.js" import { accessGeneration, decryptSecret, fingerprint, McpError, redact } from "./security.js" import { effectiveMcpConnection } from "./store.js" import { findMcpOperation } from "./registry.js" import { assertScopedCommunityRequest } from "./routing-community-scoped-request.js" import { assertPersistentScopedProfileAuthority, routingProfileAuthorityBindingSchema } from "./routing-profile-authority.js" import { createRoutingSourceContext, readRoutingEndpoints } from "./routing-observation-source.js" import { routeContextClients } from "./routing-community-context-native.js" import { resolveRoutingNetworkDestinationPins } from "./routing-network-native-destination.js" import { ROUTING_NATIVE_LOG_BUFFER, ROUTING_NATIVE_LOG_PATH } from "./routing-network-native-parser.js" import { readMeasurementAddress } from "./routing-measurement-address.js" import { readRouteCommunityContextWithSharedNativeSession, type OwnedRouteCommunityTarget } from "./routing-community-context.js" import type { ActionContext, ChangeEvidence } from "./action-types.js" import type { RoutingNetworkForwardRoundConfigurationContext } from "./routing-network-configuration-bridge.js" const sid = z.number().int().positive().safe() const address = z.string().min(1).max(45).refine(value => isIP(value) !== 0) const nativeName = z.string().min(1).max(128).regex(/^[^\u0000-\u001f\u007f]+$/) const manifestSchema = z.object({ servers: z.array(sid).min(1).max(40), probes: z.array(z.object({ key: z.string().min(1).max(128), serverId: sid, destination: address, source: address, interface: nativeName, probeVrf: nativeName, }).strict()).max(40).default([]) }).strict() export type RoutingNetworkNativeManifest = z.input export type RoutingNetworkNativeStage = "before" | "after-forward" | "after-inverse" type Row = Record export type RoutingNetworkNativeServerEnvelope = Readonly<{ serverId: number; routerOsVersion: string; routes: { resource: "/routing/route"; payload: Row[]; sessionsPayload: Row[]; connectionsPayload: Row[] }; bgp: { resource: "/routing/bgp/session"; payload: Row[]; connectionsPayload: Row[] }; bfd: { resource: "/routing/bfd/session"; payload: Row[] }; logs: { resource: "/log"; buffer: typeof ROUTING_NATIVE_LOG_BUFFER; payload: Row[]; coverage: "unknown" } }> export type RoutingNetworkNativeProbeEnvelope = Readonly<{ key: string; serverId: number; routerOsVersion: string; pingPayload: Row[]; tracePayload?: Row[]; expectedHopAddresses: { serverId: number; interface: string; address: string }[]; request: { destination: string; source: string; interface: string; probeVrf: string; count: 3; maxHops: 16 } }> const seenSources = new Set() const snapshotOwners = new WeakMap() /** Only original snapshots from one native session can bind effect diagnostics. */ export function sameConfigurationBoundForwardRounds(baseline: object, rounds: readonly object[]): boolean { const initial = snapshotOwners.get(baseline) if (!initial || initial.configuration !== undefined || rounds.length !== 2) return false const first = snapshotOwners.get(rounds[0]), second = snapshotOwners.get(rounds[1]) return first?.owner === initial.owner && second?.owner === initial.owner && first.round === 1 && second.round === 2 && first.startedAt! >= initial.finishedAt && second.startedAt! >= first.finishedAt && first.configuration !== undefined && first.configuration === second.configuration } declare const sharedContextBrand: unique symbol export type RoutingNetworkSharedContext = Readonly<{ [sharedContextBrand]: true }> declare const sharedReadBrand: unique symbol export type RoutingNetworkSharedContextRead = Readonly<{ [sharedReadBrand]: true }> type SharedBinding = Readonly<{ sourceOperationId: string; profile: z.infer; principal: ActionContext["principal"]; deadline: number; contextSources: Array<{ serverId: number; proof: string }>; candidateId: string; signal: AbortSignal }> type SharedContextResult = { scopedTopologyAvailable: boolean; before: { scopedExecutionAvailable: boolean; scopedExecutionReason: string | null; dependencyProof: string; targetRuleProof: string | null; currentCandidateId: string | null; sourceProofs: Array<{ serverId: number; proof: string }> }; fence(): Promise; ownedTarget: Pick | undefined } type SharedOwner = { binding: SharedBinding; active(): void; fence(): Promise; close(): void; read(serverId: number, path: string, body?: Record): Promise; run(): Promise } const sharedContexts = new WeakMap() const sharedReads = new WeakMap() const inverseReads = new WeakMap() function sharedOwner(context: RoutingNetworkSharedContext): SharedOwner { const owner = sharedContexts.get(context) if (!owner) throw fail("STATE_CONFLICT", "Unknown native shared context") owner.active() return owner } /** Metadata alone cannot create or reconstruct a shared transport owner. */ export function inspectRoutingNetworkSharedContext(context: RoutingNetworkSharedContext): SharedBinding { return sharedOwner(context).binding } function readOwner(context: RoutingNetworkSharedContextRead): SharedOwner { const owner = sharedReads.get(context) if (!owner) throw fail("STATE_CONFLICT", "Unknown or completed shared context acquisition") owner.active(); return owner } /** Capability membership and exact owner identity, not a metadata comparison. */ export function assertRoutingNetworkSharedContextReadOwner(context: RoutingNetworkSharedContext, acquisition: RoutingNetworkSharedContextRead): void { if (readOwner(acquisition) !== sharedOwner(context)) throw fail("STATE_CONFLICT", "Configuration acquisition belongs to another native owner") } export function inspectRoutingNetworkSharedContextRead(context: RoutingNetworkSharedContextRead): SharedBinding { const binding = readOwner(context).binding, candidateId = inverseReads.get(context) return candidateId ? Object.freeze({ ...binding, candidateId }) : binding } export async function assertRoutingNetworkSharedContextRead(context: RoutingNetworkSharedContextRead) { await readOwner(context).fence() } export function routingNetworkSharedContextPublicationFence(context: RoutingNetworkSharedContextRead): () => Promise { const owner = readOwner(context) return async () => { try { owner.active(); await owner.fence(); owner.active() } catch (error) { owner.close(); throw error } } } /** Internal fixed resource reader. No clients, callbacks or transport providers * can be supplied. Only a genuine process-local session token has membership. */ export async function readRoutingNetworkSharedResource(context: RoutingNetworkSharedContextRead, serverId: number, path: string, body?: Record): Promise { return readOwner(context).read(serverId, path, body) } export async function readRoutingNetworkSharedCommunityContext(context: RoutingNetworkSharedContext) { return sharedOwner(context).run() } export function closeRoutingNetworkSharedContext(context: RoutingNetworkSharedContext) { sharedContexts.get(context)?.close() } const configurationResources = new Set(["/routing/table", "/ip/vrf", "/system/resource", "/routing/bgp/connection", "/routing/bgp/template", "/routing/bgp/instance", "/routing/filter/rule", "/routing/ospf/instance", "/routing/rip/instance", "/routing/isis/instance", "/routing/filter/select-rule", "/routing/bgp/vpn", "/routing/rule", "/ip/firewall/mangle", "/ipv6/firewall/mangle", "/interface/gre", "/ip/route", "/ipv6/route", "/interface", "/ip/address", "/ipv6/address"]) const effectiveFields = new Set(["disabled", "templates", "instance", "input.filter-nlri", "output.filter-select", "vrf", "routing-table", "afi", "input.filter", "output.filter-chain"]) const fail = (code: string, message: string) => new McpError(code, message, 409) function freeze(value: T): T { if (value && typeof value === "object") { for (const child of Object.values(value)) freeze(child); Object.freeze(value) } return value } /** Unregistered internal reader, not a native-write grant or a network proof. * The actual encrypted operation/plan supplies authority and endpoint identity; * the runner callback is an additional fence, never an authority replacement. * One process allows at most1024 authenticated source sessions, without reopen * or eviction. Cross-restart budget admission requires a future durable owner. */ export async function createRoutingNetworkNativeSession(options: { sourceOperationId: string; context: ActionContext; authorize: () => Promise; deadline: number; manifest: RoutingNetworkNativeManifest; }) { const sourceOperationId = z.string().uuid().parse(options.sourceOperationId) const manifest = freeze(manifestSchema.parse(structuredClone(options.manifest))) if (new Set(manifest.servers).size !== manifest.servers.length || new Set(manifest.probes.map(probe => probe.key)).size !== manifest.probes.length || manifest.probes.some(probe => !manifest.servers.includes(probe.serverId))) throw fail("INVALID_INPUT", "Неоднозначный native manifest") // One baseline plus at most three forward and three inverse rounds. if ((manifest.servers.length * 6 + manifest.probes.length * 2) * 7 > 256) throw fail("LIMIT_EXCEEDED", "Полный native manifest превышает бюджет256 запросов") const principal = structuredClone(options.context.principal), connection = structuredClone(options.context.connection) const trustedAuthorize = options.authorize, deadline = options.deadline, startedAt = Date.now() if (typeof trustedAuthorize !== "function" || !Number.isFinite(deadline) || deadline <= startedAt || deadline > startedAt + 120000) throw fail("READ_CANCELLED", "Некорректный исходный срок native session") const abort = new AbortController(), signal = AbortSignal.any([abort.signal, AbortSignal.timeout(Math.max(1, deadline - startedAt)), ...(options.context.signal ? [options.context.signal] : [])]) let closed = false, rows = 0, phase = 0, tail: Promise = Promise.resolve() const rounds = { before: 0, "after-forward": 0, "after-inverse": 0 } const active = () => { if (closed || signal.aborted || Date.now() >= deadline) throw fail("READ_CANCELLED", "Native session закрыта или истекла") } const guarded = async (work: () => Promise) => { active(); await trustedAuthorize(); active() try { return await work() } finally { active(); await trustedAuthorize(); active() } } // Primitive source reads keep the immutable lifetime checks. The complete // authority fence surrounds their batch; native dispatch retains its own // fresh before/after authorization. Avoid recursively re-running the full // runtime authorization around every SQL/file leaf inside that same fence. const bounded = async (work: () => Promise) => { active() try { return await work() } finally { active() } } const currentAuthority = async () => { const current = await bounded(() => effectiveMcpConnection(principal)) if (current.id !== connection.id || current.owner_id !== connection.owner_id || current.generation !== connection.generation || fingerprint(current.policy) !== fingerprint(connection.policy) || fingerprint(current.owner_permissions) !== fingerprint(connection.owner_permissions) || !hasPermission(current.owner_permissions, "mm:network:read") || !hasPermission(current.policy.permissions, "mm:network:read") || manifest.servers.some(id => !current.policy.scope.serverIds.includes(id))) throw fail("RESET_REQUIRED", "Допуск native session изменён") } const sourceRow = async () => { const query: QueryConfig & { query_timeout: number } = { text: "SELECT o.id,o.state,o.connection_id,o.created_at,p.id AS plan_id,p.operation_id,p.operation_version,p.approved_by,p.expires_at,s.state AS step_state,CASE WHEN octet_length(s.intended_state::text)<=1048576 THEN s.intended_state END AS intended_state,CASE WHEN octet_length(p.evidence::text)<=1048576 THEN p.evidence END AS evidence FROM mcp_operations o JOIN mcp_plans p ON p.id=o.plan_id JOIN mcp_operation_steps s ON s.operation_id=o.id AND s.step_index=0 WHERE o.id=$1 AND o.connection_id=$2 LIMIT 2", values: [sourceOperationId, principal.connectionId], query_timeout: Math.max(1, Math.min(10000, deadline - Date.now())) } const result = await bounded(() => pool.query(query)) if (result.rows.length !== 1) throw fail("NOT_FOUND", "Exact source native session недоступен") const row = result.rows[0] if (!["running", "applied", "partial"].includes(row.state) || !["intent", "applied", "verified"].includes(row.step_state) || row.operation_id !== "routing.community.switch" || row.operation_version !== findMcpOperation(row.operation_id)?.version || !row.approved_by || !row.evidence?.sealed || !(row.created_at instanceof Date) || !(row.expires_at instanceof Date)) throw fail("STATE_CONFLICT", "Нет совместимого подтверждённого source intent") return row } try { await guarded(async () => {}) await currentAuthority() const row = await sourceRow() if (row.state !== "running" || row.step_state !== "intent") throw fail("STATE_CONFLICT", "Native session требует исходный running intent") const evidence = JSON.parse(await guarded(() => decryptSecret(row.evidence.sealed))) as ChangeEvidence if (evidence.steps?.length !== 1 || evidence.steps[0].kind !== "service" || evidence.steps[0].service !== "routing.community.scoped" || evidence.target.scope !== "servers") throw fail("STATE_CONFLICT", "Требуется один исходный scoped intent") const input = freeze(structuredClone(evidence.steps[0].input)), profile = routeAiProfileSchema.parse(input.profile) if (fingerprint(row.intended_state) !== fingerprint(redact(evidence.steps[0]))) throw fail("STATE_CONFLICT", "Исходный service intent не соответствует sealed plan") const fullScope = [...new Set([profile.serverId, ...profile.candidates.flatMap(candidate => [candidate.jumpHostId, candidate.exitNodeId])])].sort((a,b) => a-b) if (fingerprint([...manifest.servers].sort((a,b) => a-b)) !== fingerprint(fullScope) || fingerprint([...evidence.target.serverIds].sort((a,b) => a-b)) !== fingerprint(fullScope) || fingerprint(input.principal) !== fingerprint(principal) || input.ownerId !== connection.owner_id || input.policyProof !== fingerprint(connection.policy) || input.connectionGeneration !== connection.generation) throw fail("SERVER_DENIED", "Native manifest не соответствует полному исходному scope") await guarded(() => assertScopedCommunityRequest(input)) const generation = await guarded(() => accessGeneration()) if (input.generation !== generation) throw fail("RESET_REQUIRED", "Исходный access generation отозван") const authorityExpiry = input.persistentProfileAuthority === undefined ? Infinity : Date.parse(routingProfileAuthorityBindingSchema.parse(input.persistentProfileAuthority).packet.validUntil) if (deadline > Math.min(row.created_at.getTime() + 120000, row.expires_at.getTime(), authorityExpiry, Date.parse(principal.credentialExpiresAt), connection.owner_valid_until.getTime(), Date.parse(connection.policy.expiresAt))) throw fail("PLAN_EXPIRED", "Native session расширяет исходный срок") await guarded(() => assertPersistentScopedProfileAuthority(input, signal)) const original = profile.autoRecovery ? profile.candidates.find(candidate => candidate.id === input.originalCandidateId) : undefined if (profile.autoRecovery && (input.proofRevision !== 3 || !original?.controlProbe || manifest.probes.length !== 1 || manifest.probes[0].key !== input.candidateId || original.id === input.candidateId)) { throw fail("STATE_CONFLICT", "Исходный путь возврата отсутствует в подписанном плане") } const originalProbe = original ? { key: original.id, serverId: profile.serverId, interface: original.wanInterface, probeVrf: profile.probeVrf } : undefined const baselineProbes = originalProbe ? [...manifest.probes, originalProbe] : manifest.probes const probesFor = (stage: RoutingNetworkNativeStage) => stage === "before" ? baselineProbes : stage === "after-inverse" && originalProbe ? [originalProbe] : manifest.probes for (const probe of baselineProbes) { const candidate = profile.candidates.find(candidate => candidate.id === probe.key) if (!candidate?.controlProbe || probe.serverId !== profile.serverId || probe.interface !== candidate.wanInterface || probe.probeVrf !== profile.probeVrf || !candidate.controlProbe.expectedHops.some(hop => hop.serverId === candidate.jumpHostId) || candidate.controlProbe.expectedHops.at(-1)?.serverId !== candidate.exitNodeId) throw fail("SERVER_DENIED", "Probe manifest не соответствует исходному candidate") } const fixedRoundCalls = (stage: RoutingNetworkNativeStage) => { const probes = probesFor(stage), addressServers = new Set() for (const probe of probes) { const candidate = profile.candidates.find(candidate => candidate.id === probe.key)!, configured = candidate.controlProbe! addressServers.add(profile.serverId); addressServers.add(candidate.exitNodeId) for (const hop of configured.expectedHops) addressServers.add(hop.serverId) } return manifest.servers.length * 6 + probes.length * 2 + addressServers.size * 2 + (probes.length ? 1 : 0) } // Reject only a known mandatory seven-round footprint. Conditional /get // fallbacks consume the same measured budget at runtime; exhaustion closes // the session, without truncating any catalogue or claiming complete proof. if (fixedRoundCalls("before") + 3 * (fixedRoundCalls("after-forward") + fixedRoundCalls("after-inverse")) > 256) { throw fail("LIMIT_EXCEEDED", "Обязательный семираундовый native manifest с address catalogues превышает256 запросов") } if (seenSources.has(sourceOperationId)) throw fail("STATE_CONFLICT", "Source native session уже создавалась; повтор запрещён") if (seenSources.size >= 1024) throw fail("LIMIT_EXCEEDED", "Исчерпан process lifetime native sessions") seenSources.add(sourceOperationId) const sourceIdentity = fingerprint({ id: row.id, createdAt: row.created_at, planId: row.plan_id, evidence: row.evidence, expiresAt: row.expires_at, intendedState: row.intended_state }) const endpoints = await guarded(() => readRoutingEndpoints(fullScope)) if (endpoints.length !== fullScope.length || endpoints.some(endpoint => !endpoint.enabled) || fingerprint(endpoints.map(endpoint => endpoint.id).sort((a,b) => a-b)) !== fingerprint(fullScope)) throw fail("DEVICE_UNAVAILABLE", "Полный источник native manifest недоступен") const sources = await guarded(() => createRoutingSourceContext(endpoints)) if (fingerprint(sources.expected) !== fingerprint(input.contextSources)) throw fail("STATE_CONFLICT", "Исходный endpoint manifest изменился") const fence = async () => guarded(async () => { await currentAuthority() if (await bounded(() => accessGeneration()) !== generation) throw fail("RESET_REQUIRED", "Access generation native session изменён") await bounded(() => assertPersistentScopedProfileAuthority(input, signal)) const current = await sourceRow() if (fingerprint({ id: current.id, createdAt: current.created_at, planId: current.plan_id, evidence: current.evidence, expiresAt: current.expires_at, intendedState: current.intended_state }) !== sourceIdentity) throw fail("STATE_CONFLICT", "Исходный native intent изменён") await bounded(() => sources.assertCurrent()) }) const pins = await guarded(() => resolveRoutingNetworkDestinationPins(endpoints, { deadline, signal, authorize: fence })) await fence() const clients = routeContextClients(freeze(structuredClone(endpoints)), signal, { deadline, maxCalls: 256, maxBytes: 8 * 1048576, pins }) const readRaw = async (serverId: number, path: string, body?: Record) => { await fence() const client = clients.get(serverId) if (!client) throw fail("SERVER_DENIED", "Shared native read вне исходного scope") const timeout = Math.max(1, Math.min(10000, deadline - Date.now())) const raw = await guarded(() => body ? client.post(path, body, timeout) : client.get(path, timeout)) await fence() const payload = Array.isArray(raw) ? raw : (path === "/system/resource" || path.endsWith("/get")) && raw && typeof raw === "object" ? [raw] : null if (!payload || payload.length > 1000 || payload.some(value => !value || typeof value !== "object" || Array.isArray(value))) throw fail("INVALID_NATIVE_RESPONSE", "Native response не является bounded каталогом") rows += payload.length if (rows > 10000) throw fail("LIMIT_EXCEEDED", "Превышен общий бюджет10000 native rows") return raw } const read = async (serverId: number, path: string, body?: Record) => { const raw = await readRaw(serverId, path, body) return (Array.isArray(raw) ? raw : [raw]) as Row[] } const sharedContext = Object.freeze({}) as RoutingNetworkSharedContext const close = () => { closed = true; abort.abort(); sharedContexts.delete(sharedContext) } sharedContexts.set(sharedContext, { binding: Object.freeze({ sourceOperationId, profile: freeze(structuredClone(profile)), principal: freeze(structuredClone(principal)), deadline, contextSources: freeze(structuredClone(input.contextSources as Array<{ serverId: number; proof: string }>)), candidateId: String(input.candidateId), signal }), active, fence, close, read: async (serverId, path, body) => { try { const resource = body === undefined ? path : path.endsWith("/get") ? path.slice(0, -4) : "" if (!configurationResources.has(resource) || body !== undefined && (Object.keys(body).length !== 2 || !Object.hasOwn(body, ".id") || !Object.hasOwn(body, "value-name") || !/^\*[a-z0-9]+$/i.test(body[".id"]) || !effectiveFields.has(body["value-name"]))) throw fail("PERMISSION_DENIED", "Shared context допускает только fixed read resources и effective fields") return await readRaw(serverId, path, body) } catch (error) { close(); throw error } }, run: () => { const run = tail.then(async () => { const acquisition = Object.freeze({}) as RoutingNetworkSharedContextRead try { active(); sharedReads.set(acquisition, sharedOwner(sharedContext)) return await readRouteCommunityContextWithSharedNativeSession(acquisition) } catch (error) { close(); throw error } finally { sharedReads.delete(acquisition) } }) tail = run.catch(() => {}) return run }, }) let originalProbeIdentity: string | undefined const acquireSnapshot = async (stage: RoutingNetworkNativeStage) => { try { active() if (stage === "before" && phase === 0) { rounds.before++; phase = 1 } else if (stage === "after-forward" && phase === 1 && rounds[stage] < 3) rounds[stage]++ else if (stage === "after-inverse" && phase >= 1 && rounds["after-forward"] >= 2 && rounds[stage] < 3) { rounds[stage]++; phase = 2 } else throw fail("STATE_CONFLICT", "Native round нельзя повторить сверх лимита или переставить") const startedAt = new Date(Date.now()).toISOString() const servers: RoutingNetworkNativeServerEnvelope[] = [], probes: RoutingNetworkNativeProbeEnvelope[] = [] const catalogues = new Map() const catalogue = async (serverId: number, path: string) => { const key = serverId + ":" + path if (!catalogues.has(key)) catalogues.set(key, await read(serverId, path)) return catalogues.get(key)! } const disabledValues = new Map() const readDisabled = async (serverId: number, path: string, id: string) => { if (!/^\*[a-z0-9]+$/i.test(id)) throw fail("INVALID_NATIVE_RESPONSE", "Не подтверждён native ID probe dependency") const key = serverId + path + id if (!disabledValues.has(key)) { const values = await read(serverId, path + "/get", { ".id": id, "value-name": "disabled" }) if (values.length !== 1) throw fail("INVALID_NATIVE_RESPONSE", "Не подтверждён disabled probe dependency") disabledValues.set(key, values[0]) } return disabledValues.get(key) } const enabled = async (serverId: number, path: string, row: Row) => { const [observed] = await readOspfEffectiveDisabled([row], id => readDisabled(serverId, path, id)) if (![false, "false", "no"].includes(observed.disabled as string | boolean) || [true, "true", "yes"].includes(observed.invalid as string | boolean)) throw fail("MEASUREMENT_UNKNOWN", "Probe dependency не подтверждена включённой") } const addressOf = async (serverId: number, iface: string, selected?: string) => { const interfaces = (await catalogue(serverId, "/interface")).filter(row => row.name === iface) if (interfaces.length !== 1) throw fail("MEASUREMENT_UNKNOWN", "Не подтверждён exact probe interface") await enabled(serverId, "/interface", interfaces[0]) const path = profile.family === "ipv4" ? "/ip/address" : "/ipv6/address" const selectedAddress = await readMeasurementAddress(await catalogue(serverId, path), { dstInterface: iface, family: profile.family, dstAddress: selected }, id => readDisabled(serverId, path, id)) if (selectedAddress.linkLocal) throw fail("UNSUPPORTED_CAPABILITY", "Link-local probe требует отдельного контракта") return selectedAddress.address } for (const serverId of manifest.servers) { const resource = await read(serverId, "/system/resource"), version = resource.length === 1 ? resource[0].version : null if (typeof version !== "string" || version.length > 128) throw fail("INVALID_NATIVE_RESPONSE", "RouterOS version не подтверждена") const routes = await read(serverId, "/routing/route"), connectionsPayload = await read(serverId, "/routing/bgp/connection") const bgp = await read(serverId, "/routing/bgp/session"), bfd = await read(serverId, "/routing/bfd/session") const logs = await read(serverId, ROUTING_NATIVE_LOG_PATH) servers.push({ serverId, routerOsVersion: version, routes: { resource: "/routing/route", payload: routes, sessionsPayload: bgp, connectionsPayload }, bgp: { resource: "/routing/bgp/session", payload: bgp, connectionsPayload }, bfd: { resource: "/routing/bfd/session", payload: bfd }, logs: { resource: "/log", buffer: ROUTING_NATIVE_LOG_BUFFER, payload: logs, coverage: "unknown" } }) } for (const probe of probesFor(stage)) { const candidate = profile.candidates.find(candidate => candidate.id === probe.key)!, configured = candidate.controlProbe! const interfaceNames = new Set((await catalogue(profile.serverId, "/interface")).map(row => row.name)) let owner: unknown = null const vrfs = await catalogue(profile.serverId, "/ip/vrf") for (const row of vrfs) { const members = canonicalVrfMembers(row.interfaces).split(",") if ([true, "true", "yes"].includes(row.disabled as string | boolean)) continue await enabled(profile.serverId, "/ip/vrf", row) if (members.some(member => !["all", "none"].includes(member) && !interfaceNames.has(member))) throw fail("UNSUPPORTED_CAPABILITY", "VRF interface-list требует отдельного resolver") if (members.includes("all") || members.includes(candidate.wanInterface)) { owner = row.name; break } } if (owner !== profile.probeVrf) throw fail("MEASUREMENT_UNKNOWN", "Probe WAN не принадлежит exact ordered VRF") const source = await addressOf(profile.serverId, candidate.wanInterface, configured.sourceAddress) const destination = await addressOf(candidate.exitNodeId, configured.targetInterface, configured.targetAddress) if ("source" in probe && "destination" in probe && (source !== probe.source || destination !== probe.destination)) { throw fail("STATE_CONFLICT", "Probe manifest addresses не соответствуют native ownership") } const expectedHopAddresses = [] for (const hop of configured.expectedHops) expectedHopAddresses.push({ serverId: hop.serverId, interface: hop.interface, address: await addressOf(hop.serverId, hop.interface, hop.address) }) const request = { destination, source, interface: probe.interface, probeVrf: probe.probeVrf, count: 3 as const, maxHops: 16 as const } if (probe === originalProbe) { const identity = fingerprint({ request, expectedHopAddresses }) if (stage === "before") originalProbeIdentity = identity else if (originalProbeIdentity !== identity) throw fail("STATE_CONFLICT", "Адреса исходного пути изменились после возврата") } const routerOsVersion = servers.find(server => server.serverId === probe.serverId)!.routerOsVersion const pingRequest = { address: destination, "src-address": source, interface: probe.interface, vrf: probe.probeVrf, count: "3" } const pingPayload = await read(probe.serverId, "/tool/ping", pingRequest) // This is a command-selection check, never a failure proof. The // parser must still validate every raw counter/row independently. const terminal = pingPayload.at(-1), loss = terminal?.["packet-loss"] const zeroReceived = [3,"3"].includes(terminal?.sent as string | number) && [0,"0"].includes(terminal?.received as string | number) && (loss === undefined || loss === 100 || typeof loss === "string" && /^100(?:\.0+)?%?$/.test(loss)) const tracePayload = zeroReceived ? undefined : await read(probe.serverId, "/tool/traceroute", { ...pingRequest, "max-hops": "16" }) probes.push({ key: probe.key, serverId: probe.serverId, routerOsVersion, pingPayload, ...(tracePayload === undefined ? {} : { tracePayload }), expectedHopAddresses, request }) } await fence() const observedAt = new Date(Date.now()).toISOString() const snapshot = freeze({ sourceOperationId, stage, round: rounds[stage], startedAt, observedAt, servers, probes, securityProof: false as const, logCoverage: "unknown" as const, budget: { ...clients.readBudget(), rows } }) if (stage === "before") snapshotOwners.set(snapshot, { owner: sharedContext, finishedAt: Date.parse(observedAt) }) return snapshot } catch (error) { close() if (error instanceof McpError) throw error throw fail("STATE_UNAVAILABLE", "Native read session не подтверждена; повтор запрещён") } } const readSnapshot = (stage: RoutingNetworkNativeStage) => { const run = tail.then(() => acquireSnapshot(stage)) tail = run.catch(() => {}) return run } const readConfigurationBoundForwardSnapshot = (configuration: RoutingNetworkForwardRoundConfigurationContext) => { const run = tail.then(async () => { const acquisition = Object.freeze({}) as RoutingNetworkSharedContextRead try { active() sharedReads.set(acquisition, sharedOwner(sharedContext)) // Fixed lazy import avoids a bridge/session initialization cycle. // No caller can supply a verifier, reader, proof JSON or client. const { readRoutingNetworkForwardRoundConfigurationContext } = await import("./routing-network-configuration-bridge.js") const before = await readRoutingNetworkForwardRoundConfigurationContext(configuration, acquisition) const snapshot = await acquireSnapshot("after-forward") const after = await readRoutingNetworkForwardRoundConfigurationContext(configuration, acquisition) await fence() const capturedAt = Date.now() const ordered = [before.checkpointObservedAt, before.observedAt, snapshot.startedAt, snapshot.observedAt, after.observedAt].map(value => Date.parse(value)) ordered.push(capturedAt) if (before.operationId !== sourceOperationId || after.operationId !== sourceOperationId || before.phase !== "forward" || after.phase !== "forward" || !Number.isFinite(before.deadline) || before.deadline > deadline || before.deadline !== after.deadline || !before.sharedNetworkBudgetVerified || !after.sharedNetworkBudgetVerified || before.checkpointObservedAt !== after.checkpointObservedAt || before.checkpointProof !== after.checkpointProof || ordered.some((time, index) => !Number.isFinite(time) || time >= before.deadline || index > 0 && time < ordered[index - 1]) || fingerprint(before.configuration) !== fingerprint(after.configuration)) throw fail("STATE_CONFLICT", "Forward-round configuration changed") // Both readbacks consume this owner's measured transport and row // budget. Preserve raw observation times; publication is later. const bound = freeze({ ...snapshot, configurationReadbacks: { before, after }, capturedAt: new Date(capturedAt).toISOString(), budget: { ...clients.readBudget(), rows }, securityProof: false as const, forwardingVerified: false as const }) snapshotOwners.set(bound, { owner: sharedContext, round: bound.round, startedAt: ordered[1], finishedAt: capturedAt, configuration: fingerprint({ deadline: before.deadline, checkpointProof: before.checkpointProof, configuration: before.configuration }) }) return bound } catch (error) { close(); throw error } finally { sharedReads.delete(acquisition) } }) tail = run.catch(() => {}) return run } const readConfigurationBoundInverseSnapshot = (assertCheckpoint: () => Promise) => { const run = tail.then(async () => { const acquisition = Object.freeze({}) as RoutingNetworkSharedContextRead try { active() if (!originalProbe || !originalProbeIdentity || rounds["after-forward"] < 2 || rounds["after-inverse"] >= 3) { throw fail("STATE_CONFLICT", "Исходный раунд A для возврата не подтверждён") } sharedReads.set(acquisition, sharedOwner(sharedContext)) inverseReads.set(acquisition, originalProbe.key) const body = await guarded(() => decryptSecret(String(input.originalRuleCiphertext))) const assertOriginalConfiguration = async () => { await guarded(assertCheckpoint) const current = await readRouteCommunityContextWithSharedNativeSession(acquisition) if (!current.scopedTopologyAvailable || current.before.currentCandidateId !== originalProbe.key || current.before.dependencyProof !== input.dependencyProof || current.ownedTarget?.nativeId !== input.nativeId || !current.ownedTarget?.matchesRuleProof(body, input.originalTargetProof)) { throw fail("STATE_CONFLICT", "Конфигурация A изменилась во время обратного раунда") } await current.fence() await guarded(assertCheckpoint) } await assertOriginalConfiguration() const snapshot = await acquireSnapshot("after-inverse") await assertOriginalConfiguration() return freeze({ ...snapshot, budget: { ...clients.readBudget(), rows } }) } catch (error) { close(); throw error } finally { inverseReads.delete(acquisition); sharedReads.delete(acquisition) } }) tail = run.catch(() => {}) return run } return Object.freeze({ readSnapshot, readConfigurationBoundForwardSnapshot, readConfigurationBoundInverseSnapshot, sharedContext, close, readBudget: () => Object.freeze({ ...clients.readBudget(), rows, closed }) }) } catch (error) { closed = true; abort.abort() if (error instanceof McpError) throw error throw fail("STATE_UNAVAILABLE", "Исходный native session не подтверждён") } }