import assert from "node:assert/strict" import { createHash, randomUUID } from "node:crypto" import { basename, dirname, resolve } from "node:path" assert.equal(process.env.MMAPP_OWN_CONTROLLED_MIGRATIONS, "true") const url = new URL(process.env.DATABASE_URL ?? "") assert.equal(url.hostname, "127.0.0.1"); assert.equal(url.pathname, "/postgres") assert(process.env.MCP_STATE_DIR && basename(dirname(resolve(process.env.MCP_STATE_DIR))).startsWith("mm-mcp-test-")) const { Pool } = await import("pg") const { pool, closePool } = await import("./index.js") const { applySqlMigrations } = await import("./migrate.js") const { executeControlledSqlMigrations } = await import("./controlled-migrations.js") const { initialDatabaseSchemaControlState } = await import("./database-schema-control-model.js") const { MIGRATION_MANIFEST } = await import("./migration-manifest.js") const { SYSTEM_DATABASE_OPERATION_LOCK, withOperationLock } = await import("./operation-lock.js") const originalConnect = pool.connect.bind(pool), databases: InstanceType[] = [], names: string[] = [], cases: string[] = [] const hashes = new Set(MIGRATION_MANIFEST.map(pin => pin.sha256)) async function database(seed = true) { const name = "mm_dispatch_" + randomUUID().replaceAll("-", "") assert(/^mm_dispatch_[a-f0-9]{32}$/.test(name)) await pool.query('CREATE DATABASE "' + name + '" TEMPLATE template0') const target = new URL(url); target.pathname = "/" + name const connection = new Pool({ connectionString: target.toString(), max: 6 }); databases.push(connection); names.push(name) if (seed) { await connection.query("CREATE SCHEMA mmapp_control; CREATE TABLE mmapp_control.database_schema_state(id smallint PRIMARY KEY CHECK(id=1),revision bigint NOT NULL CHECK(revision>=0),state jsonb NOT NULL); CREATE TABLE mmapp_control.database_schema_intents(id uuid PRIMARY KEY,intent jsonb NOT NULL,terminal jsonb)") await connection.query("INSERT INTO mmapp_control.database_schema_state VALUES(1,0,$1::jsonb)", [JSON.stringify(initialDatabaseSchemaControlState())]) } return connection } type Fault = "none" | "application-commit" | "terminal-commit" const requestAdmissionSql = "SELECT pg_catalog.pg_try_advisory_xact_lock_shared($1::bigint) AS acquired" async function run(connection: InstanceType, fault: Fault = "none") { const files: string[] = []; let ordinal = 0, controlCommits = 0 // Owned fixture instrumentation at the fixed module's actual Pool boundary. // Every SQL statement still executes on a real checked-out private backend. pool.connect = (async () => { const client = await connection.connect(), index = ++ordinal, originalQuery = client.query, release = client.release.bind(client), query = originalQuery.bind(client) client.release = (destroy?: boolean) => { client.query = originalQuery; release(destroy) } client.query = (async (text: string, values?: unknown[]) => { const digest = createHash("sha256").update(text).digest("hex") if (hashes.has(digest)) { files.push(digest) if (files.length === 1 || files.length === MIGRATION_MANIFEST.length) { const { rows } = await connection.query(requestAdmissionSql, [SYSTEM_DATABASE_OPERATION_LOCK]) assert.equal(rows[0]?.acquired, false, "Migration SQL must exclude MCP request writes") } } const result = await query(text, values) if (index === 2 && text === "COMMIT" && fault === "application-commit") throw Error("Owned application COMMIT ACK lost") if (index === 1 && text === "COMMIT" && ++controlCommits === 4 && fault === "terminal-commit") throw Error("Owned terminal publication COMMIT ACK lost") return result }) as typeof client.query return client }) as typeof pool.connect try { return { result: await executeControlledSqlMigrations(), files, failed: false } } catch { return { files, failed: true } } finally { pool.connect = originalConnect as typeof pool.connect } } try { await applySqlMigrations(pool) const missing = await database(false), noControl = await run(missing) assert(noControl.failed); assert.equal(noControl.files.length, 0) cases.push("missing external control refuses before application migration SQL") const clean = await database() await withOperationLock(() => clean.connect(), SYSTEM_DATABASE_OPERATION_LOCK, async () => { const blocked = await run(clean) assert(blocked.failed) assert.deepEqual(blocked.files, []) assert.equal((await clean.query("SELECT count(*)::int AS n FROM mmapp_control.database_schema_intents")).rows[0].n, 0) }) cases.push("live backup/restore lease refuses controlled migration before DDL or intent") const initial = await run(clean) assert(!initial.failed); assert.equal(initial.result?.completedFiles, MIGRATION_MANIFEST.length); assert.equal(initial.result?.ready, false) assert.deepEqual(initial.files, MIGRATION_MANIFEST.map(pin => pin.sha256)) assert.equal((await clean.query(requestAdmissionSql, [SYSTEM_DATABASE_OPERATION_LOCK])).rows[0].acquired, true) assert.equal((await clean.query("SELECT count(*)::int AS n FROM mmapp_control.database_schema_intents WHERE terminal->>'outcome'='observed-success'")).rows[0].n, MIGRATION_MANIFEST.length) cases.push("all current exact pinned files execute once with genuine keyed ACK receipts; READY remains closed") const repeated = await run(clean); assert(!repeated.failed); assert.equal(repeated.files.length, 0) cases.push("fresh owner verifies complete known prefix and executes no file twice") const legacy = await database(); await legacy.query("CREATE TABLE public.unmarked(id integer)") const refused = await run(legacy); assert(refused.failed); assert.equal(refused.files.length, 0) cases.push("unmarked legacy application objects are not treated as a fresh database") const unknown = await database(), lostFile = await run(unknown, "application-commit") assert(lostFile.failed); assert.equal(lostFile.files.length, 1) assert.equal((await unknown.query("SELECT terminal->>'outcome' AS outcome FROM mmapp_control.database_schema_intents")).rows[0].outcome, "interrupted-unknown") const unknownRepeat = await run(unknown); assert(unknownRepeat.failed); assert.equal(unknownRepeat.files.length, 0) cases.push("actual application COMMIT with lost ACK becomes unknown and is never replayed by fresh owner") const prefix = await database(), lostTerminal = await run(prefix, "terminal-commit") assert(lostTerminal.failed); assert.equal(lostTerminal.files.length, 1) assert.equal((await prefix.query("SELECT terminal->>'outcome' AS outcome FROM mmapp_control.database_schema_intents")).rows[0].outcome, "observed-success") const resumed = await run(prefix); assert(!resumed.failed); assert.equal(resumed.files.length, MIGRATION_MANIFEST.length - 1) assert.deepEqual(resumed.files, MIGRATION_MANIFEST.slice(1).map(pin => pin.sha256)) cases.push("lost terminal publication ACK preserves genuine known file ACK; fresh invocation resumes only remaining manifest files without replay") const badMarker = await database(), markerPrefix = await run(badMarker, "terminal-commit"); assert(markerPrefix.failed) await badMarker.query("DELETE FROM public.schema_migrations") const markerDrift = await run(badMarker); assert(markerDrift.failed); assert.equal(markerDrift.files.length, 0) cases.push("marker and protected history mismatch refuses before any next file") const tampered = await database(), tamperPrefix = await run(tampered, "terminal-commit"); assert(tamperPrefix.failed) await tampered.query("UPDATE mmapp_control.database_schema_intents SET terminal=jsonb_set(terminal,'{observationSha256}',to_jsonb($1::text))", ["f".repeat(64)]) await tampered.query("UPDATE mmapp_control.database_schema_state SET state=jsonb_set(state,'{terminal,observationSha256}',to_jsonb($1::text))", ["f".repeat(64)]) const forged = await run(tampered); assert(forged.failed); assert.equal(forged.files.length, 0) cases.push("matching singleton/history plain-hash forgery cannot replace fixed server-keyed file receipt") console.log("Owned controlled migration SQL:", JSON.stringify({ cases: cases.length, names: cases, databases: names.length, actualSql: true, fixedSourceFiles: MIGRATION_MANIFEST.length, fullRuns: 2, actualApplicationAckLosses: 1, actualTerminalPublicationAckLosses: 3, readyAuthorized: false, startupWired: false, productionDatabaseTouched: false })) } finally { pool.connect = originalConnect as typeof pool.connect for (const connection of databases) await connection.end() await closePool() }