Files
MikrotikManager/backend/src/modules/mcp/routing-network-configuration-bridge.ts
T

239 lines
19 KiB
TypeScript

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 { effectiveMcpConnection } from "./store.js"
import { findMcpOperation } from "./registry.js"
import { accessGeneration, decryptSecret, fingerprint, McpError, redact } from "./security.js"
import { assertScopedCommunityRequest } from "./routing-community-scoped-request.js"
import { loadScopedConfigurationPacket } from "./routing-community-scoped-checkpoint.js"
import { assertVerifiedReservedEffectOwner, isVerifiedManualEffectOwner } from "./routing-network-execution-session.js"
import { assertPersistentScopedProfileAuthority, routingProfileAuthorityBindingSchema } from "./routing-profile-authority.js"
import { readRouteCommunityContext, readRouteCommunityContextWithSharedNativeSession } from "./routing-community-context.js"
import { readRoutingNetworkScopedCommunityContext } from "./routing-network-scoped-context.js"
import { assertRoutingNetworkSharedContextReadOwner, closeRoutingNetworkSharedContext, inspectRoutingNetworkSharedContext, type RoutingNetworkSharedContext, type RoutingNetworkSharedContextRead } from "./routing-network-native-session.js"
import type { ActionContext, ChangeEvidence } from "./action-types.js"
import type { ConnectionRow } from "./store.js"
declare const contextBrand: unique symbol
/** A process-local read capability, never a mutation or full network proof. */
export type RoutingNetworkConfigurationContext = Readonly<{ [contextBrand]: true }>
const fail = (reason: string) => new McpError("STATE_CONFLICT", reason, 409)
const connectionAuthority = (value: ConnectionRow) => fingerprint({ id: value.id, ownerId: value.owner_id, permissions: value.owner_permissions,
policy: value.policy, generation: value.generation, ownerValidUntil: value.owner_valid_until, ownerClaimsIssuedAt: value.owner_claims_issued_at })
const issued = new Set<string>()
declare const roundContextBrand: unique symbol
/** Reusable read-only checkpoint binding on one already-admitted native owner.
* It grants no native write, inverse, READY or signed network authority. */
export type RoutingNetworkForwardRoundConfigurationContext = Readonly<{ [roundContextBrand]: true }>
type ConfigurationObservation = Readonly<{
operationId: string; phase: "forward"; checkpointProof: string; checkpointObservedAt: string; observedAt: string; deadline: number;
configuration: { serverId: number; nativeId: string; table: string; bodyIdentity: string; dependencyIdentity: string };
securityProof: false; forwardingVerified: false; sharedNetworkBudgetVerified: boolean;
}>
const roundContexts = new WeakMap<RoutingNetworkForwardRoundConfigurationContext, {
owner: RoutingNetworkSharedContext; close: () => void;
read: (acquisition?: RoutingNetworkSharedContextRead) => Promise<ConfigurationObservation>;
}>()
const contexts = new WeakMap<RoutingNetworkConfigurationContext, { consumed: boolean; close: () => void; consume: () => Promise<Readonly<{
operationId: string; phase: "forward"; checkpointProof: string; checkpointObservedAt: string; observedAt: string; deadline: number;
configuration: { serverId: number; nativeId: string; table: string; bodyIdentity: string; dependencyIdentity: string };
securityProof: false; forwardingVerified: false; sharedNetworkBudgetVerified: boolean;
}>>; read: (acquisition?: RoutingNetworkSharedContextRead) => Promise<ConfigurationObservation> }>()
function freeze<T>(value: T): T {
if (value && typeof value === "object") { Object.values(value).forEach(freeze); Object.freeze(value) }
return value
}
/** Fixed production resolver. Only an actual revision-3 approved source plan
* and its authenticated persisted CONFIG_APPLIED can reach native read-back.
* Existing context guards (including autoRecovery) remain mandatory.
* This bridge uses the existing bounded configuration reader; its acquisition
* counters are NOT the native observation session's shared 256-call budget.
* Do not use this independent bridge as per-round full verifier acceptance. */
export async function resolveRoutingNetworkConfigurationContext(sourceOperationId: string, action: ActionContext): Promise<RoutingNetworkConfigurationContext> {
return resolveConfigurationContext(sourceOperationId, action)
}
/** Same genuine checkpoint bridge on an existing running native session.
* The opaque owner fixes source, principal and shared transport/budget; caller
* JSON, captured metadata and supplied clients cannot select this path. */
export async function resolveRoutingNetworkConfigurationContextFromSharedContext(sharedContext: RoutingNetworkSharedContext, action: ActionContext): Promise<RoutingNetworkConfigurationContext> {
const binding = inspectRoutingNetworkSharedContext(sharedContext)
if (fingerprint(binding.principal) !== fingerprint(action.principal)) throw fail("Shared configuration principal changed")
return resolveConfigurationContext(binding.sourceOperationId, action, sharedContext)
}
/** Uses the SAME one-time source admission and genuine CONFIG_APPLIED checks
* as the existing bridge. Only its owning session can use it inside a queued
* round acquisition; JSON copies and caller-supplied observations cannot. */
export async function resolveRoutingNetworkForwardRoundConfigurationContext(sharedContext: RoutingNetworkSharedContext, action: ActionContext): Promise<RoutingNetworkForwardRoundConfigurationContext> {
const binding = inspectRoutingNetworkSharedContext(sharedContext)
if (fingerprint(binding.principal) !== fingerprint(action.principal)) throw fail("Shared configuration principal changed")
const initial = await resolveConfigurationContext(binding.sourceOperationId, action, sharedContext, true)
const entry = contexts.get(initial)
if (!entry) throw fail("Configuration bridge admission disappeared")
contexts.delete(initial)
const token = Object.freeze({}) as RoutingNetworkForwardRoundConfigurationContext
roundContexts.set(token, { owner: sharedContext, close: entry.close, read: entry.read })
return token
}
/** Fixed internal reader, called only with the session's ephemeral acquisition.
* This does not enqueue another shared-context task while the queue is held. */
export async function readRoutingNetworkForwardRoundConfigurationContext(context: RoutingNetworkForwardRoundConfigurationContext, acquisition: RoutingNetworkSharedContextRead) {
const entry = roundContexts.get(context)
if (!entry) throw fail("Unknown or closed forward-round configuration context")
try {
assertRoutingNetworkSharedContextReadOwner(entry.owner, acquisition)
return await entry.read(acquisition)
} catch (error) {
roundContexts.delete(context); entry.close(); closeRoutingNetworkSharedContext(entry.owner)
throw error
}
}
export function closeRoutingNetworkForwardRoundConfigurationContext(context: RoutingNetworkForwardRoundConfigurationContext) {
const entry = roundContexts.get(context)
roundContexts.delete(context); entry?.close()
}
async function resolveConfigurationContext(sourceOperationId: string, action: ActionContext, sharedContext?: RoutingNetworkSharedContext, deferredRoundReadback = false): Promise<RoutingNetworkConfigurationContext> {
if (deferredRoundReadback && !sharedContext) throw fail("Forward round requires its original shared owner")
z.string().uuid().parse(sourceOperationId)
const principal = freeze(structuredClone(action.principal)), connection = freeze(structuredClone(action.connection))
const abort = new AbortController()
let closed = false, deadline = Infinity
let signal = AbortSignal.any([abort.signal, ...(action.signal ? [action.signal] : [])])
const active = () => { if (closed || signal.aborted || Date.now() >= deadline) throw fail("Configuration bridge closed or original deadline expired") }
const close = () => { closed = true; abort.abort() }
const guarded = async <T>(work: () => Promise<T>) => { active(); const value = await work(); active(); return value }
const source = () => {
const query: QueryConfig & { query_timeout: number } = { text: `SELECT o.id,o.state,o.created_at,p.id AS plan_id,p.operation_id,p.operation_version,p.approved_by,p.expires_at,
CASE WHEN octet_length(p.evidence::text)<=1048576 THEN p.evidence END AS evidence,s.state AS step_state,
CASE WHEN octet_length(s.intended_state::text)<=1048576 THEN s.intended_state END AS intended_state
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
WHERE o.id=$1 AND o.connection_id=$2 AND s.step_index=0 LIMIT 2`, values: [sourceOperationId, principal.connectionId],
query_timeout: Math.max(1, Math.min(10000, Number.isFinite(deadline) ? deadline - Date.now() : 10000)) }
return guarded(() => pool.query(query))
}
try {
const initial = await guarded(() => effectiveMcpConnection(principal))
if (connectionAuthority(initial) !== connectionAuthority(connection)) throw fail("Original connection changed")
const found = await source()
if (found.rows.length !== 1) throw fail("Exact configuration source unavailable")
const row = found.rows[0]
if (row.id !== sourceOperationId || !["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.created_at instanceof Date) || !(row.expires_at instanceof Date) || typeof row.evidence?.sealed !== "string") throw fail("No compatible approved source intent")
deadline = Math.min(row.created_at.getTime() + 120000, row.expires_at.getTime(), Date.parse(principal.credentialExpiresAt), connection.owner_valid_until.getTime(), Date.parse(connection.policy.expiresAt),
sharedContext ? inspectRoutingNetworkSharedContext(sharedContext).deadline : Infinity)
active()
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("Exact scoped service source required")
const step = evidence.steps[0], input = freeze(structuredClone(step.input)), profile = routeAiProfileSchema.parse(input.profile)
if (sharedContext) {
const binding = inspectRoutingNetworkSharedContext(sharedContext)
if (binding.sourceOperationId !== sourceOperationId || fingerprint(binding.profile) !== fingerprint(profile) ||
fingerprint(binding.contextSources) !== fingerprint(input.contextSources) || binding.candidateId !== input.candidateId) throw fail("Shared configuration source binding changed")
}
const manual = !!sharedContext && deferredRoundReadback && isVerifiedManualEffectOwner(sharedContext)
const reservedOwner = profile.autoRecovery ? sharedContext : undefined
if (profile.autoRecovery && (!reservedOwner || !deferredRoundReadback || row.state !== "running" ||
row.step_state !== "intent" || row.approved_by !== connection.owner_id)) throw fail("Recovery guard remains closed")
if (manual) {
if (row.state !== "running" || row.step_state !== "intent" || input.proofRevision !== 2 ||
input.persistentProfileAuthority !== undefined || input.manualEffectPolicy !== "observational-v1") throw fail("Exact running manual effect source required")
} else {
if (input.proofRevision !== 3 || input.persistentProfileAuthority === undefined) throw fail("Persistent revision-3 source required")
const authority = routingProfileAuthorityBindingSchema.parse(input.persistentProfileAuthority)
deadline = Math.min(deadline, Date.parse(authority.packet.validUntil))
}
signal = AbortSignal.any([signal, AbortSignal.timeout(Math.max(1, deadline - Date.now()))])
active()
const ids = [...new Set([profile.serverId, ...profile.candidates.flatMap(candidate => [candidate.jumpHostId, candidate.exitNodeId])])].sort((a,b) => a-b)
if (input.serverId !== profile.serverId || input.ownerId !== connection.owner_id || fingerprint(input.principal) !== fingerprint(principal) ||
fingerprint(redact(step)) !== fingerprint(row.intended_state) || fingerprint([...evidence.target.serverIds].sort((a,b) => a-b)) !== fingerprint(ids)) throw fail("Source input or exact scope changed")
const requestSeal = await guarded(() => assertScopedCommunityRequest(input)), sourceProof = fingerprint(row)
const authorize = async () => {
const current = await guarded(() => effectiveMcpConnection(principal))
if (connectionAuthority(current) !== connectionAuthority(connection) || current.id !== principal.connectionId || current.owner_id !== input.ownerId || current.policy.mode === "observer" ||
current.generation !== input.connectionGeneration || fingerprint(current.policy) !== input.policyProof ||
ids.some(id => !current.policy.scope.serverIds.includes(id)) ||
["mm:network:read", "mm:filters:write"].some(permission => !hasPermission(current.owner_permissions, permission) || !hasPermission(current.policy.permissions, permission)) ||
!current.policy.scope.operationIds.includes("routing.community.switch") || await guarded(accessGeneration) !== input.generation) throw fail("Original authority revoked or changed")
await guarded(() => assertPersistentScopedProfileAuthority(input, signal))
const currentSource = await source()
if (currentSource.rows.length !== 1 || fingerprint(currentSource.rows[0]) !== sourceProof || await guarded(() => assertScopedCommunityRequest(input)) !== requestSeal) throw fail("Configuration source changed")
}
const checkpoint = async () => {
await authorize()
if (reservedOwner && await guarded(() => assertVerifiedReservedEffectOwner(reservedOwner, sourceOperationId, principal)) < deadline) {
throw fail("Reserved forward deadline changed")
}
const result = await guarded(() => loadScopedConfigurationPacket(input, requestSeal, { operationId: sourceOperationId, stepIndex: 0 }))
if (!result || result.packet.revision !== (manual ? 1 : 2) || result.packet.operationId !== sourceOperationId || result.packet.stepIndex !== 0 ||
result.packet.phase !== "CONFIG_APPLIED" || Date.parse(result.observedAt) < row.created_at.getTime() || Date.parse(result.observedAt) > Date.now() ||
Date.parse(result.observedAt) >= deadline) throw fail("Genuine persistent CONFIG_APPLIED unavailable")
await authorize()
return result
}
const original = await checkpoint()
if (issued.has(sourceOperationId) || issued.size >= 1024) throw fail("Configuration bridge source already issued or process capacity exhausted")
issued.add(sourceOperationId)
const readback = async (acquisition?: RoutingNetworkSharedContextRead) => {
const before = await checkpoint()
if (before.checkpointProof !== original.checkpointProof || fingerprint(before.packet) !== fingerprint(original.packet)) throw fail("Configuration checkpoint changed")
if (acquisition) {
if (!sharedContext) throw fail("Round acquisition requires its original shared owner")
assertRoutingNetworkSharedContextReadOwner(sharedContext, acquisition)
}
const context = await guarded(() => acquisition ? readRouteCommunityContextWithSharedNativeSession(acquisition) : sharedContext ? readRoutingNetworkScopedCommunityContext(sharedContext) : readRouteCommunityContext(profile, {
selectedCandidateId: String(input.candidateId), authorize, signal, expectedSources: input.contextSources as Array<{ serverId: number; proof: string }> }))
if (!(reservedOwner ? context.scopedTopologyAvailable : context.before.scopedExecutionAvailable) || !context.ownedTarget) {
throw fail(String(context.before.scopedExecutionReason ?? "Owned context unavailable"))
}
const owned = context.ownedTarget
if (owned.nativeId !== original.packet.nativeId || owned.nativeId !== input.nativeId ||
context.before.dependencyProof !== original.packet.dependencyProof ||
!owned.matchesRuleProof(original.packet.desiredRule, original.packet.desiredTargetProof) ||
context.before.currentCandidateId !== original.packet.desiredCandidateId || fingerprint(context.before.sourceProofs) !== fingerprint(original.packet.contextSources)) throw fail("Current owned rule or dependencies drifted from CONFIG_APPLIED")
await guarded(() => context.fence())
const after = await checkpoint()
if (after.checkpointProof !== original.checkpointProof || fingerprint(after.packet) !== fingerprint(original.packet)) throw fail("Configuration checkpoint changed after read-back")
await guarded(() => context.fence())
return freeze({ operationId: sourceOperationId, phase: "forward" as const, checkpointProof: original.checkpointProof,
checkpointObservedAt: original.observedAt, observedAt: new Date().toISOString(), deadline,
configuration: { serverId: original.packet.serverId, nativeId: owned.nativeId, table: profile.table,
bodyIdentity: fingerprint(original.packet.desiredRule), dependencyIdentity: original.packet.dependencyProof },
securityProof: false as const, forwardingVerified: false as const, sharedNetworkBudgetVerified: !!sharedContext })
}
// A forward-round token carries no native success observation. Its fixed
// owner must perform a fresh read immediately BEFORE every snapshot and
// another immediately AFTER. Avoid an unused eager native read here;
// independent/shared one-shot bridge semantics remain unchanged.
if (!deferredRoundReadback) await readback()
const token = Object.freeze({}) as RoutingNetworkConfigurationContext
contexts.set(token, { consumed: false, close, read: readback, consume: async () => {
try { return await readback() }
catch (error) { if (sharedContext) closeRoutingNetworkSharedContext(sharedContext); throw error }
finally { close() }
} })
return token
} catch (error) { close(); if (sharedContext) closeRoutingNetworkSharedContext(sharedContext); throw error }
}
/** Consume once, re-reading current rule/dependencies through the fixed reader.
* Serialized tokens and caller-created objects have no WeakMap membership. */
export async function consumeRoutingNetworkConfigurationContext(context: RoutingNetworkConfigurationContext) {
const entry = contexts.get(context)
if (!entry || entry.consumed) throw fail("Unknown or consumed configuration context")
entry.consumed = true
try { return await entry.consume() } finally { contexts.delete(context) }
}
export function closeRoutingNetworkConfigurationContext(context: RoutingNetworkConfigurationContext) {
const entry = contexts.get(context)
contexts.delete(context); entry?.close()
}