import assert from "node:assert/strict" import { randomUUID } from "node:crypto" import { createServer } from "node:http" import { setTimeout as delay } from "node:timers/promises" import Fastify from "fastify" import { serializerCompiler, validatorCompiler } from "@fastify/type-provider-zod" import { mcpConnectionCreateSchema } from "@mmapp/contracts/mcp" import { pool } from "../../db/index.js" import type { AuthUser } from "../../lib/permissions.js" import wireguardRoutes from "../../routes/wireguard.js" import { wireguardInterfaceDependencyPaths } from "../../services/wireguard-interface-delete.js" import { createMcpConnection, authenticateMcpToken, setConnectionStatus } from "./store.js" import { invokeMcpTool, approvePlan, applyPlan } from "./runtime.js" type Rows = Record[]> export async function acceptWireguardInterfaceDeletion(actor: AuthUser) { const privateKey = Buffer.alloc(32, 31).toString("base64"), psk = Buffer.alloc(32, 32).toString("base64") const initial: Rows = Object.fromEntries(wireguardInterfaceDependencyPaths.map(path => [path, []])) initial["/interface/wireguard"] = [{ ".id": "*a1", name: "wg-cascade", disabled: "false", "private-key": privateKey, "listen-port": "13231", mtu: "1420", comment: "owned" }, { ".id": "*af", name: "wg-foreign", disabled: "true", "private-key": "NEVER_FOREIGN_PRIVATE" }] initial["/interface/wireguard/peers"] = [{ ".id": "*p1", interface: "wg-cascade", "public-key": Buffer.alloc(32, 33).toString("base64"), "preshared-key": psk, "allowed-address": "192.0.2.2/32", disabled: "true" }, { ".id": "*p2", interface: "*a1", "public-key": Buffer.alloc(32, 34).toString("base64"), "allowed-address": "192.0.2.3/32", disabled: "true" }, { ".id": "*pf", interface: "wg-foreign", "public-key": "foreign", rx: "0", opaque: "NEVER_FOREIGN_OPAQUE" }] initial["/interface"] = [{ ".id": "*a1", name: "wg-cascade", type: "wg" }, { ".id": "*af", name: "wg-foreign", type: "wg" }] initial["/ip/address"] = [{ ".id": "*v1", address: "198.19.244.1/30", interface: "wg-cascade", disabled: "true", dynamic: "false", invalid: "true" }, { ".id": "*vf", address: "203.0.113.2/24", interface: "ether1", dynamic: "false", disabled: "false" }] initial["/ipv6/address"] = [{ ".id": "*v2", address: "2001:db8:244::1/64", interface: "*a1", disabled: "true", dynamic: "false", invalid: "true" }, { ".id": "*ll", address: "fe80::1/64", interface: "wg-cascade", dynamic: "true" }] initial["/ip/route"] = [{ ".id": "*dc", dynamic: "true", connect: "true", gateway: "wg-cascade", "pref-src": "198.19.244.1" }] let rows = structuredClone(initial), mode = "normal", gets = 0, commands: string[] = [], afterDelete: (() => Promise) | undefined let duringRead: (() => Promise) | undefined const router = createServer((req, res) => { res.setHeader("content-type", "application/json") const path = decodeURIComponent((req.url ?? "").slice(5)) if (req.method === "GET") { gets++ const respond = () => { if (mode === "provider-error") { res.statusCode = 400; res.end('{"message":"NEVER_CASCADE_PROVIDER_PASSWORD"}'); return } if (!Object.hasOwn(rows, path)) { res.statusCode = 404; res.end("{}"); return } // Runtime traffic and DHCP lease clocks must not become configuration drift. rows["/interface/wireguard/peers"].find(row => row[".id"] === "*pf")!.rx = String(gets) res.end(JSON.stringify(rows[path])) } if (duringRead) { const hook = duringRead; duringRead = undefined; void hook().then(respond, () => { res.statusCode = 503; res.end("{}"); }); return } respond(); return } const bases = ["/interface/wireguard/peers", "/interface/wireguard", "/ip/address", "/ipv6/address"] const base = bases.find(base => path.startsWith(base + "/")) if (!base || !["PATCH", "DELETE"].includes(req.method ?? "")) { res.statusCode = 400; res.end("{}"); return } const id = path.slice(base.length + 1) let body = "" req.on("data", chunk => { body += chunk }); req.on("end", async () => { commands.push(req.method + " " + path) if (req.method === "PATCH") { Object.assign(rows[base].find(row => row[".id"] === id)!, JSON.parse(body)) rows["/ipv6/address"] = rows["/ipv6/address"].filter(row => row[".id"] !== "*ll") rows["/ip/route"] = rows["/ip/route"].filter(row => row[".id"] !== "*dc") } else { if (mode !== "ignored") rows[base] = rows[base].filter(row => row[".id"] !== id) if (base === "/interface/wireguard" && mode !== "ignored") rows["/interface"] = rows["/interface"].filter(row => row[".id"] !== id) if (mode === "collateral") rows["/ip/address"].find(row => row[".id"] === "*vf")!.comment = "foreign drift" if (afterDelete) { const hook = afterDelete; afterDelete = undefined; await hook() } if (mode === "lost") { req.socket.destroy(); return } } res.end("{}") }) }) await new Promise(resolve => router.listen(0, "127.0.0.1", resolve)) const rest = Fastify(); rest.setValidatorCompiler(validatorCompiler); rest.setSerializerCompiler(serializerCompiler) const reset = () => { rows = structuredClone(initial); commands = []; mode = "normal"; afterDelete = undefined } const wait = async (id: string) => { for (let n = 0; n < 3000; n++) { const state = (await pool.query("SELECT state FROM mcp_operations WHERE id=$1", [id])).rows[0].state; if (!["pending", "running"].includes(state)) return state; await delay(25) } throw Error("WireGuard cascade still live; never replay") } let connectionId: string | undefined try { await pool.query("INSERT INTO servers(id,name,host,port,use_ssl,password) VALUES(109,'wg-interface-delete','127.0.0.1',$1,false,'NEVER_CASCADE_ENDPOINT_PASSWORD')", [(router.address() as { port: number }).port]) await pool.query("INSERT INTO app_users(id,login,name) VALUES('wg-cascade-user','wg-cascade-user','Cascade fixture')") await rest.register(wireguardRoutes, { prefix: "/api" }) const connectionInput = { name: "WireGuard cascade deletion", mode: "approval", expiresAt: new Date(Date.now() + 1800000).toISOString(), permissions: ["mm:network:write"], scope: { serverIds: [109], operationIds: ["network.wireguard.interfaces.delete", "ros.wireguard.delete", "operations.reconcile", "operations.recover"], allowGlobal: false }, limits: { callsPerMinute: 120, mutationsPerHour: 100 } } const access = await createMcpConnection(mcpConnectionCreateSchema.parse(connectionInput), actor) connectionId = access.connection.id const principal = await authenticateMcpToken(access.token) const prepare = async (native = false) => { const result = await invokeMcpTool(principal, native ? "mm_wireguard_delete_plan" : "mm_wireguard_interface_remove_plan", native ? { serverId: 109, id: "*a1" } : { serverId: 109, interfaceId: "*a1" }) as { planId: string; state: string; changes: { mutationCost: number } } assert.equal(result.state, "awaiting-approval") for (const secret of [privateKey, psk, "NEVER_"]) assert.ok(!JSON.stringify(result).includes(secret)) return result } const hidden = gets await assert.rejects(invokeMcpTool(principal, "mm_wireguard_interface_remove_plan", { serverId: 1, interfaceId: "*a1" })) await assert.rejects(invokeMcpTool(principal, "mm_wireguard_interface_remove_plan", { serverId: 109, interfaceId: "../bad" })) assert.equal(gets, hidden) await assert.rejects(prepare(true), (error: { code?: string }) => error.code === "DEPENDENCY_CONFLICT") assert.equal(commands.length, 0, "Native alias must not acquire cascade permission") for (const [path, row] of [ ["/interface/list/member", { interface: "wg-cascade", list: "LAN" }], ["/interface/vxlan", { interface: "wg-cascade" }], ["/ip/route", { gateway: "198.19.244.2%wg-cascade" }], ["/routing/filter/rule", { rule: 'set gw "wg-cascade";' }], ["/ip/firewall/filter", { "in-interface": "wg-cascade" }], ["/ip/dhcp-server", { interface: "wg-cascade" }], ["/routing/filter/rule", { rule: 'set gw "wg\\2dcascade";' }], ["/ip/ipsec/peer", { "local-address": "198.19.244.1" }], ["/routing/bgp/session", { dynamic: "true", "local.address": "2001:0db8:0244:0:0:0:0:1" }], ["/routing/ospf/interface-template", { networks: "198.19.244.0/30" }], ["/routing/ospf/neighbor", { interface: "wg-cascade", state: "Full" }], ] as [string, Record][]) { reset(); rows[path].push({ ".id": "*ref", ...row }) await assert.rejects(prepare()); assert.equal(commands.length, 0) assert.equal((await rest.inject({ method: "DELETE", url: "/api/wireguard/interfaces/109/*a1" })).statusCode, 409) assert.equal(commands.length, 0) } reset() const bindingId = randomUUID() await pool.query("INSERT INTO user_interface_bindings(id,user_id,server_id,interface_name,peer_public_key) VALUES($1,'wg-cascade-user',109,'*a1','')", [bindingId]) await assert.rejects(prepare()); assert.equal((await rest.inject({ method: "DELETE", url: "/api/wireguard/interfaces/109/*a1" })).statusCode, 409) await pool.query("DELETE FROM user_interface_bindings WHERE id=$1", [bindingId]) const protectionId = randomUUID() await pool.query("INSERT INTO mcp_protections(id,object_ref,created_by) VALUES($1,$2::jsonb,'integration')", [protectionId, JSON.stringify({ kind: "wireguard_peer", id: "*p2", serverId: 109, protection: "deny" })]) await assert.rejects(prepare()); assert.equal((await rest.inject({ method: "DELETE", url: "/api/wireguard/interfaces/109/*a1" })).statusCode, 409) assert.equal(commands.length, 0); await pool.query("DELETE FROM mcp_protections WHERE id=$1", [protectionId]) rows["/interface/wireguard"][0].comment = "MikrotikManager traffic-flow overlay" await assert.rejects(prepare(), /NetFlow/); reset() rows["/ip/address"][0].dynamic = "true" await assert.rejects(prepare()); reset() const low = await createMcpConnection(mcpConnectionCreateSchema.parse({ ...connectionInput, name: "Insufficient cascade budget", limits: { callsPerMinute: 120, mutationsPerHour: 3 } }), actor) await assert.rejects(invokeMcpTool(await authenticateMcpToken(low.token), "mm_wireguard_interface_remove_plan", { serverId: 109, interfaceId: "*a1" }), (error: { code?: string }) => error.code === "BUDGET_EXCEEDED") assert.equal(commands.length, 0) for (const fault of ["normal", "ignored", "collateral", "lost"]) { reset() const plan = await prepare(); assert.equal(plan.changes.mutationCost, 7); await approvePlan(plan.planId, actor, true) mode = fault const key = randomUUID(), operation = await applyPlan(principal, plan.planId, key) const expected = fault === "normal" ? "applied" : fault === "lost" ? "unknown" : "partial" assert.equal(await wait(operation.id), expected) assert.equal(commands.length, fault === "normal" ? 6 : 2) assert.ok(commands[0].startsWith("PATCH /interface/wireguard/")) const count: number = commands.length assert.equal((await applyPlan(principal, plan.planId, key)).id, operation.id); assert.equal(commands.length, count) const reconciled = await invokeMcpTool(principal, "mm_operation_reconcile", { operationId: operation.id }) as { state: string; automaticRetry: boolean; results: { matchesDesiredState: boolean; matchesExpectedPrefixState: boolean; verifiedPrefixCommands: number | null }[] } assert.equal(reconciled.state, expected); assert.equal(reconciled.automaticRetry, false) assert.equal(reconciled.results[0].matchesDesiredState, fault === "normal") assert.equal(reconciled.results[0].matchesExpectedPrefixState, fault !== "collateral") assert.equal(reconciled.results[0].verifiedPrefixCommands, fault === "normal" ? 6 : fault === "ignored" ? 1 : fault === "lost" ? 2 : null) assert.equal(commands.length, count) await assert.rejects(invokeMcpTool(principal, "mm_operation_recovery_plan", { operationId: operation.id }), (error: { code?: string }) => error.code === "UNSUPPORTED_CAPABILITY") if (fault === "normal") { assert.deepEqual(rows["/interface/wireguard"], [initial["/interface/wireguard"][1]]) assert.deepEqual(rows["/ip/address"], [initial["/ip/address"][1]]); assert.deepEqual(rows["/ipv6/address"], []) } } reset() const paused = await prepare(); await approvePlan(paused.planId, actor, true) afterDelete = () => setConnectionStatus(access.connection.id, "paused", actor) const stopped = await applyPlan(principal, paused.planId, randomUUID()) assert.equal(await wait(stopped.id), "unknown"); assert.equal(commands.length, 2) await setConnectionStatus(access.connection.id, "active", actor) reset() const stale = await prepare(); await approvePlan(stale.planId, actor, true) rows["/interface/wireguard/peers"][2].opaque = "NEVER_LATE_CHANGE" assert.equal(await wait((await applyPlan(principal, stale.planId, randomUUID())).id), "rejected"); assert.equal(commands.length, 0) reset() const beforePause = gets duringRead = () => setConnectionStatus(access.connection.id, "paused", actor) await assert.rejects(prepare()); assert.equal(gets, beforePause + 1) await setConnectionStatus(access.connection.id, "active", actor) reset(); mode = "provider-error" await assert.rejects(prepare(), (error: Error) => !error.message.includes("NEVER_")) assert.ok(!(await rest.inject({ method: "DELETE", url: "/api/wireguard/interfaces/109/*a1" })).body.includes("NEVER_")) reset() const restResult = await rest.inject({ method: "DELETE", url: "/api/wireguard/interfaces/109/*a1" }) assert.equal(restResult.statusCode, 200, restResult.body); assert.equal(restResult.json().verified, true); assert.equal(restResult.json().revisionRecorded, true); assert.equal(restResult.json().afterProof, undefined); assert.equal(commands.length, 6) reset(); rows["/interface/wireguard/peers"] = rows["/interface/wireguard/peers"].filter(row => row.interface === "wg-foreign"); rows["/ip/address"] = rows["/ip/address"].filter(row => row.interface !== "wg-cascade"); rows["/ipv6/address"] = []; rows["/ip/route"] = [] const legacy = await prepare(true); await approvePlan(legacy.planId, actor, true); await pool.query("UPDATE mcp_plans SET operation_version=1 WHERE id=$1", [legacy.planId]) await assert.rejects(applyPlan(principal, legacy.planId, randomUUID()), (error: { code?: string }) => error.code === "PLAN_EXPIRED") const empty = await prepare(true); await approvePlan(empty.planId, actor, true) assert.equal(await wait((await applyPlan(principal, empty.planId, randomUUID())).id), "applied"); assert.equal(commands.length, 1); assert.ok(commands[0].startsWith("DELETE /interface/wireguard/")) assert.equal((await pool.query("SELECT count(*)::int AS n FROM mcp_requests WHERE connection_id=$1 AND (result::text LIKE '%NEVER_%' OR result::text LIKE $2 OR result::text LIKE $3)", [connectionId, "%" + privateKey + "%", "%" + psk + "%"])).rows[0].n, 0) console.log("✓ WireGuard interface cascade shares REST/MCP: explicit children and native single-object alias, pre-disable/order/budget, protocol/IP/user/NetFlow/protection guards, private prefix proofs, per-command read-back, partial/lost/revoke/no replay, revision receipt and preserved foreign configuration") } finally { await rest.close(); await new Promise(resolve => router.close(() => resolve())) if (connectionId) await setConnectionStatus(connectionId, "paused", actor) await pool.query("DELETE FROM user_interface_bindings WHERE user_id='wg-cascade-user'") await pool.query("DELETE FROM app_users WHERE id='wg-cascade-user'") await pool.query("DELETE FROM servers WHERE id=109") } }