import assert from "node:assert/strict" import { randomUUID } from "node:crypto" import { pool } from "../../db/index.js" import type { ActionContext } from "./action-types.js" import type { ConnectionRow } from "./store.js" import type { ServerRow } from "../servers/repository/servers-repository.js" import type { IpsecPeerDeleteState } from "../../services/ipsec-peer-delete.js" import type { IpsecServerDeleteCommand } from "../../services/ipsec-server-delete-model.js" import { createIpsecServerDeleteAdapter, ipsecServerDeleteActionSchema } from "./ipsec-server-delete-actions.js" import { fingerprint, redact } from "./security.js" const operation = "network.ipsec.server.delete", sourceProof = "a".repeat(64), beforeProof = "b".repeat(64), afterProof = "c".repeat(64) const principal = { connectionId: randomUUID(), credentialId: randomUUID(), credentialExpiresAt: new Date(Date.now() + 600000).toISOString() } const connection = { id: principal.connectionId, owner_id: "fixture-owner", owner_permissions: ["mm:network:write"], generation: "fixture-generation", owner_valid_until: new Date(Date.now() + 600000), policy: { mode: "autonomous", status: "active", expiresAt: principal.credentialExpiresAt, permissions: ["mm:network:write"], scope: { serverIds: [1], operationIds: [operation], allowGlobal: false } } } as ConnectionRow const context = { principal, connection } as ActionContext assert.deepEqual(ipsecServerDeleteActionSchema.parse({ serverId: 1 }), { serverId: 1, removeCertificates: true }) for (const raw of [{ serverId: 1, removeCertificates: "true" }, { serverId: 1, psk: "NEVER_SECRET" }, { serverId: 0 }, { serverId: 1, force: true }]) assert.equal(ipsecServerDeleteActionSchema.safeParse(raw).success, false) const originalQuery = pool.query, originalConnect = pool.connect const forbidden = () => { throw Error("Unexpected real SQL/native/network access") } pool.query = forbidden as typeof pool.query; pool.connect = forbidden as typeof pool.connect try { let current: ConnectionRow, state: IpsecPeerDeleteState, endpoint = sourceProof, reads = 0, deletes = 0, histories = 0, historyFails = false, noCommands = false, lateAuthority: (() => void) | undefined let storedRows: Record[] = [], unexpectedManifest = false const sealed = new Map() const reset = () => { current = structuredClone(connection); endpoint = sourceProof; historyFails = false; noCommands = false; lateAuthority = undefined; unexpectedManifest = false; storedRows = [] state = { source: sourceProof, proof: beforeProof, catalogs: {}, protections: [{ object_ref: { kind: "ipsec_identity", id: "*protected" } }] } } reset() const commands = (removeCertificates: boolean): IpsecServerDeleteCommand[] => noCommands ? [] : removeCertificates ? [{ path: "/certificate", id: "*ca", cascadeIds: ["*child"] }] : [{ path: "/ip/ipsec/identity", id: "*i1" }] const objects = (removeCertificates: boolean) => noCommands ? [] : removeCertificates ? [{ kind: "certificate", id: "*ca" }, { kind: "certificate", id: "*child" }] : [{ kind: "ipsec_identity", id: "*i1" }] const adapter = createIpsecServerDeleteAdapter({ connection: async () => current, router: async () => ({ server: { id: 1 } as ServerRow, client: {} as never }), sourceProof: async () => endpoint, read: async (_server, authorize) => { await authorize?.(); reads++; await authorize?.(); return structuredClone(state) }, seal: async value => { const key = `sealed:${randomUUID()}`; sealed.set(key, value); return key }, open: async value => { const found = sealed.get(value); if (!found) throw Error("invalid ciphertext"); return found }, manifestProof: async value => fingerprint({ privateTestKey: "fixed-pure-fixture", value }), query: async () => storedRows, verifiedAccess: async () => {}, checkpoint: async () => {}, plan: (_state, removeCertificates = true) => ({ commands: unexpectedManifest ? [{ path: "/certificate", id: "*different" }] : commands(removeCertificates), objects: objects(removeCertificates), companions: objects(removeCertificates), removeCertificates }), stages: async (before, manifest) => [before.proof, ...manifest.map(() => afterProof)], remove: (async (_server: unknown, removeCertificates: boolean, expected: string, authorize: () => Promise, options: { receiptId: string; checkpoint: (value: unknown) => Promise }) => { assert.equal(expected, beforeProof); await authorize(); lateAuthority?.(); await authorize() const manifest = commands(removeCertificates), affectedObjects = manifest.reduce((sum, cmd) => sum + 1 + (cmd.cascadeIds?.length ?? 0), 0) deletes += manifest.length; histories++; state.proof = manifest.length ? afterProof : beforeProof const value = { ok: true, verified: true, receiptId: options.receiptId, removeCertificates, commandCount: manifest.length, completedCommands: manifest.length, confirmedWrites: manifest.length, affectedObjects, afterProof: state.proof, historyRecorded: !historyFails, revisionRecorded: !historyFails, automaticReplay: false, forwardingVerified: false } await options.checkpoint({ receiptId: options.receiptId, commandCount: manifest.length, completedCommands: manifest.length, afterProof: state.proof }); return value }) as never, }) const prepare = async (removeCertificates = true) => { const evidence = await adapter.prepare({ serverId: 1, removeCertificates }, context) assert.equal(evidence.requiresHuman, true) assert.equal(evidence.mutationCost, noCommands ? 1 : removeCertificates ? 3 : 2) assert.ok(evidence.objects.some(ref => ref.id === "*protected")) if (!noCommands && removeCertificates) assert.ok(evidence.objects.some(ref => ref.id === "*child"), "CA cascade child explicitly protected") const step = evidence.steps[0]!; if (step.kind !== "service") throw Error("Expected service") assert.deepEqual(Object.keys(step.input).sort(), ["bindingCiphertext", "receiptId", "serverId"]) assert.equal(JSON.parse(sealed.get(String(step.input.bindingCiphertext))!).proofRevision,2,"New plans require the v2 dependency proof") return { evidence, input: step.input } } let plan = await prepare() assert.ok(plan.evidence.warnings.some(value => value.includes("*ca: *child"))) assert.ok(plan.evidence.warnings.some(value => value.includes("Profiles и proposals сохраняются"))) assert.deepEqual(await adapter.service.current(plan.input), { proof: beforeProof }) let receipt = await adapter.service.execute(plan.input) assert.equal(deletes, 1); assert.equal(histories, 1); assert.equal(await adapter.service.verify!(plan.input, receipt), true) storedRows = [{ connection_id: principal.connectionId, state: "verified", intended_state: redact({ kind: "service", service: operation, input: plan.input }), result: receipt }] assert.equal((await adapter.service.reconcile!(plan.input, async () => {})).matchesDesiredState, true) for (const field of ["ok", "verified", "receiptId", "removeCertificates", "commandCount", "completedCommands", "confirmedWrites", "affectedObjects", "historyRecorded", "revisionRecorded", "afterProof", "forwardingVerified", "automaticReplay"]) { const saved = structuredClone(storedRows[0]!) ;(storedRows[0]!.result as Record)[field] = "tampered" assert.equal((await adapter.service.reconcile!(plan.input, async () => {})).matchesDesiredState, false, field) storedRows = [saved] } storedRows[0]!.state = "applied"; assert.equal((await adapter.service.reconcile!(plan.input, async () => {})).matchesDesiredState, false) reset(); plan = await prepare(false); receipt = await adapter.service.execute(plan.input); assert.equal(await adapter.service.verify!(plan.input, receipt), true) reset(); noCommands = true; plan = await prepare(); const beforeEmpty = deletes; receipt = await adapter.service.execute(plan.input) assert.equal(deletes, beforeEmpty); assert.equal(await adapter.service.verify!(plan.input, receipt), true, "empty manifest still requires history") reset(); plan = await prepare(); historyFails = true; receipt = await adapter.service.execute(plan.input); assert.equal(await adapter.service.verify!(plan.input, receipt), false) for (const mutate of [() => { endpoint = "d".repeat(64) }, () => { current.policy.permissions = [] }, () => { current.policy.scope.operationIds = [] }, () => { current.policy.scope.serverIds = [] }, () => { current.generation = "rotated-generation" }]) { reset(); plan = await prepare(); const before = reads; mutate(); await assert.rejects(adapter.service.current(plan.input)); assert.equal(reads, before, "authority/source drift rejects before native GET") } reset(); plan = await prepare(); unexpectedManifest = true; const beforeManifest = deletes; await assert.rejects(adapter.service.execute(plan.input)); assert.equal(deletes, beforeManifest) reset(); plan = await prepare(); lateAuthority = () => { current.policy.permissions = [] }; const beforeLate = deletes; await assert.rejects(adapter.service.execute(plan.input)); assert.equal(deletes, beforeLate) reset(); plan = await prepare(); const cipher = String(plan.input.bindingCiphertext), binding = JSON.parse(sealed.get(cipher)!) for (const mutate of [ (value: Record) => { value.proofRevision = 1 }, (value: Record) => { value.affectedObjects = 1 }, (value: Record) => { value.commandCount = 2 }, (value: Record) => { value.stageProofs = [beforeProof] }, (value: Record) => { value.manifestProof = "f".repeat(64) }, ]) { const changed = structuredClone(binding); mutate(changed); sealed.set(cipher, JSON.stringify(changed)); const before = reads await assert.rejects(adapter.service.current(plan.input)); assert.equal(reads, before) } sealed.set(cipher, JSON.stringify(binding)) await assert.rejects(adapter.service.current({ ...plan.input, serverId: 2 })); await assert.rejects(adapter.service.current({ ...plan.input, receiptId: randomUUID() })) const cancelled = new AbortController(); cancelled.abort(); await assert.rejects(adapter.prepare({ serverId: 1 }, { ...context, signal: cancelled.signal })) reset(); plan = await prepare(); let checks = 0 await adapter.service.reconcile!(plan.input, async () => { checks++; if (checks === 2) throw Error("external authorization revoked") }).then(() => assert.fail("external revocation must fail"), () => {}) console.log("IPsec server MCP adapter: exact sealed HMAC manifest/stages, CA cascade budget/protections, human-only removal, source/access-before-GET, history-only empty manifest, mandatory-history receipts and verified-only reconciliation") } finally { pool.query = originalQuery; pool.connect = originalConnect }