import { MIGRATION_MANIFEST } from "../db/migration-manifest.js" /** Exclusive disposable PG + localhost license. Q is a synthetic fixture. */ import assert from "node:assert/strict" import { generateKeyPairSync, createHash, randomUUID, sign } from "node:crypto" import { readFile, unlink, writeFile } from "node:fs/promises" import { resolve } from "node:path" import { assertOwnedBandwidthSql } from "./bandwidth-admission-process.sql-helper.js" import type { BandwidthPeerSourceSnapshot } from "./bandwidth-peer-observation.js" async function main() { assertOwnedBandwidthSql() assert.equal(process.env.MMAPP_OWN_OPERATOR_PEER_METADATA, "true") const { createOwnedExternalRegistryHarness } = await import("./bandwidth-external-node-registry.sql-helper.js") const { createBandwidthOperatorEnrollmentPrerequisite, bandwidthOperatorEnrollmentGrantSchema } = await import("./bandwidth-operator-enrollment.js") const { createManagedBandwidthPeerMetadataChecker } = await import("./bandwidth-peer-metadata-source.js") const { canonicalBandwidthNodeValue: canonical } = await import("./bandwidth-node-bootstrap.js") const { pool } = await import("../db/index.js") const fixture = await createOwnedExternalRegistryHarness() let coordinator: ReturnType | undefined let serverId: number | undefined const checks: string[] = [] try { const claims = { "system-id": "OWNED-OPERATOR-METADATA", "software-id": "OWNED-PUBLIC-METADATA" } serverId = await fixture.managedEndpoint(claims) const peer = Object.freeze({ kind: "server" as const, serverId }) const originalRow = (await fixture.applicationRows([serverId]))[0] assert(originalRow) const endpoint = { host: String(originalRow.host), port: Number(originalRow.port), useSsl: originalRow.use_ssl as boolean, verifySsl: originalRow.verify_ssl as boolean, username: String(originalRow.username), password: String(originalRow.password), routingEndpointEpoch: String(originalRow.routing_endpoint_epoch), } const sourceProof = "d".repeat(64), authorityGeneration = "owned-operator-metadata-fixture" const keys = generateKeyPairSync("ed25519"), now = Date.now() let grant = bandwidthOperatorEnrollmentGrantSchema.parse({ format: "mmapp-bandwidth-operator-enrollment-v1", ...fixture.root, grantId: randomUUID(), operatorId: "owned-metadata-operator", executorInventorySha256: "c".repeat(64), executorsStoppedAt: now - 1000, issuedAt: now, expiresAt: now + 120000, peerRef: peer, sourceProof, authorityGeneration, routingEndpointEpoch: endpoint.routingEndpointEpoch, claims: Object.entries(claims).map(([kind, value]) => ({ kind, value })), }) const state = resolve(process.env.MCP_STATE_DIR!), trustKeyFile = resolve(state, "operator-metadata-trust.pem"), grantFile = resolve(state, "operator-metadata-grant.json") const grantBytes = () => { const bytes = Buffer.from(canonical(grant)) return JSON.stringify({ format: "mmapp-bandwidth-operator-enrollment-envelope-v1", payload: bytes.toString("base64url"), signature: sign(null, bytes, keys.privateKey).toString("base64url") }) } await writeFile(trustKeyFile, keys.publicKey.export({ type: "spki", format: "pem" }), { flag: "wx", mode: 0o600 }) await writeFile(grantFile, grantBytes(), { flag: "wx", mode: 0o600 }) const checker = createManagedBandwidthPeerMetadataChecker() let projections = 0, metadataChecks = 0, qChecks = 0, metadataPhase = false const quiescence = { async verify(current: unknown) { qChecks++; assert(!metadataPhase, "metadata must not assert Q"); assert.deepEqual(current, grant) } } coordinator = createBandwidthOperatorEnrollmentPrerequisite({ trustKeyFile, grantFile, trustKeySha256: createHash("sha256").update(keys.publicKey.export({ type: "spki", format: "der" })).digest("hex"), ...fixture.root, }, { async read(requested, scope): Promise { projections++; assert(!metadataPhase, "metadata must not reproject credentials"); assert.deepEqual(requested, peer) await quiescence.verify(grant); scope.signal?.throwIfAborted() const row = (await fixture.applicationRows([serverId!]))[0]; assert(row) return { peerRef: peer, enabled: row.enabled as boolean, sourceProof, authorityGeneration, endpoint: { host: String(row.host), port: Number(row.port), useSsl: row.use_ssl as boolean, verifySsl: row.verify_ssl as boolean, username: String(row.username), password: String(row.password), routingEndpointEpoch: String(row.routing_endpoint_epoch) } } }, async assertMetadataCurrent(expected, scope) { metadataChecks++; await checker.assertMetadataCurrent(expected, scope) }, }, quiescence) console.log("Owned operator metadata stage:", "genuine-license-acquire") const scope = () => ({ deadlineAt: Date.now() + 4500 }) let prerequisite = await coordinator.acquire(peer, scope()) assert(fixture.nativeGets() > 0); assert(projections > 0); assert(qChecks > 0) metadataPhase = true const inspect = async (capability: unknown = prerequisite) => { const before = { projections, qChecks, gets: fixture.nativeGets(), posts: fixture.nativePosts() } try { return await coordinator!.inspectMetadata(capability, scope()) } finally { assert.equal(projections, before.projections); assert.equal(qChecks, before.qChecks) assert.equal(fixture.nativeGets(), before.gets); assert.equal(fixture.nativePosts(), before.posts) } } const freshOrigin = async () => { // The real endpoint trigger advances epoch on every edit, including an // edit restoring old values. A fresh grant is required; never bypass it. metadataPhase = false const row = (await fixture.applicationRows([serverId!]))[0] grant = bandwidthOperatorEnrollmentGrantSchema.parse({ ...grant, grantId: randomUUID(), routingEndpointEpoch: String(row.routing_endpoint_epoch) }) await writeFile(grantFile, grantBytes()) prerequisite = await coordinator!.acquire(peer, scope()) metadataPhase = true } console.log("Owned operator metadata stage:", "current-managed-metadata") const first = await inspect() assert.equal(first.format, "mmapp-bandwidth-operator-enrollment-metadata-v1") assert.deepEqual(first.metadata.evidence.peerRef, peer) assert.deepEqual(first.metadata.evidence.claims, grant.claims) assert(Object.isFrozen(first) && Object.isFrozen(first.metadata)) const encoded = JSON.stringify(first) assert(!encoded.includes(endpoint.password) && !encoded.includes(endpoint.username)) assert(!("writerBarrierVerified" in first) && !("quiescenceVerified" in first)) assert.deepEqual(await inspect(), first) assert.equal(metadataChecks, 2) checks.push("genuine signed operator/license origin plus actual fixed SQL current endpoint predicate, public metadata only; no Q/native/credential re-projection") console.log("Owned operator metadata stage:", "private-predicate-with-unchanged-epoch") const wrongEndpoints = [ { ...endpoint, password: "owned-wrong-private-predicate" }, { ...endpoint, username: "owned-wrong-user-predicate" }, { ...endpoint, host: "127.0.0.2" }, { ...endpoint, port: endpoint.port === 1 ? 2 : 1 }, { ...endpoint, useSsl: !endpoint.useSsl }, { ...endpoint, verifySsl: !endpoint.verifySsl }, ] for (const wrong of wrongEndpoints) { assert.equal(wrong.routingEndpointEpoch, endpoint.routingEndpointEpoch) await assert.rejects(checker.assertMetadataCurrent({ peerRef: peer, enabled: true, sourceProof, authorityGeneration, endpoint: wrong }, scope())) } assert.equal(String((await fixture.applicationRows([serverId]))[0].routing_endpoint_epoch), endpoint.routingEndpointEpoch) checks.push("actual SQL rejects wrong private password/username/host/port/TLS predicates while the real row and endpoint epoch remain unchanged; epoch alone is insufficient") console.log("Owned operator metadata stage:", "endpoint-field-drift") const faults = [ { sql: "UPDATE public.servers SET password=$2 WHERE id=$1", next: "owned-changed-password-only", previous: endpoint.password }, { sql: "UPDATE public.servers SET username=$2 WHERE id=$1", next: "owned-changed-username", previous: endpoint.username }, { sql: "UPDATE public.servers SET host=$2 WHERE id=$1", next: "127.0.0.2", previous: endpoint.host }, { sql: "UPDATE public.servers SET port=$2 WHERE id=$1", next: endpoint.port === 1 ? 2 : 1, previous: endpoint.port }, { sql: "UPDATE public.servers SET use_ssl=$2 WHERE id=$1", next: !endpoint.useSsl, previous: endpoint.useSsl }, { sql: "UPDATE public.servers SET verify_ssl=$2 WHERE id=$1", next: !endpoint.verifySsl, previous: endpoint.verifySsl }, { sql: "UPDATE public.servers SET enabled=$2 WHERE id=$1", next: false, previous: true }, ] for (const fault of faults) { await freshOrigin() try { assert.equal((await pool.query(fault.sql, [serverId, fault.next])).rowCount, 1) assert.notEqual(String((await fixture.applicationRows([serverId]))[0].routing_endpoint_epoch), grant.routingEndpointEpoch) await assert.rejects(inspect()) } finally { await pool.query(fault.sql, [serverId, fault.previous]) } await assert.rejects(inspect()) } await freshOrigin(); await inspect() checks.push("actual password, username, host, port, TLS, verification and enabled drift refuse; real trigger advances endpoint epoch and restored values never revive the old origin; no trigger bypass") console.log("Owned operator metadata stage:", "grant-and-private-origin") const beforeInvalid = metadataChecks, savedGrant = await readFile(grantFile) try { await unlink(grantFile); await assert.rejects(inspect()) } finally { await writeFile(grantFile, savedGrant) } await assert.rejects(inspect(JSON.parse(JSON.stringify(prerequisite)))) assert.equal(metadataChecks, beforeInvalid) checks.push("deleted current signed grant and serialized prerequisite refuse before metadata SQL; exact grant bytes restored") const restored = (await fixture.applicationRows([serverId]))[0] const { routing_endpoint_epoch: oldEpoch, ...originalFields } = originalRow const { routing_endpoint_epoch: newEpoch, ...restoredFields } = restored assert.deepEqual(restoredFields, originalFields); assert.notEqual(newEpoch, oldEpoch) assert.equal(Number((await pool.query("SELECT count(*) AS n FROM public.schema_migrations")).rows[0].n), MIGRATION_MANIFEST.length) console.log("Owned operator peer metadata accepted:", JSON.stringify({ groups: checks.length, checks, actualSql: true, genuineLocalhostLicenseAcquire: true, coordinatorMetadataChecks: metadataChecks, unchangedEpochPredicateRejections: wrongEndpoints.length, metadataCredentialProjections: 0, metadataQChecks: 0, metadataNativeCalls: 0, externalMetadataAccepted: false, operatorWindowAccepted: false, productionWired: false, })) } finally { coordinator?.close() if (serverId !== undefined) await pool.query("DELETE FROM public.servers WHERE id=$1", [serverId]) await fixture.close() } } void main().catch(() => { console.error("Owned operator peer metadata acceptance failed; no real CHR/Docker actions"); process.exitCode = 1 })